refactor: replace orchestrator/verifier chain with direct LiteLLM calls

Drop the three-layer Claude subprocess orchestration (local model →
Claude verifier → cloud escalation). Skills now call LiteLLM directly
and return plain text to Claude Code, which decides what to do with it.

- Delete executor, orchestrator, verifier, result, attempts packages
- Simplify LiteLLMExecutor: Run(Request)→Result becomes Complete(model,sys,user)→(string,int64,error)
- Replace ExecutorFn with CompleteFunc in all 6 skill configs
- Rewrite all skill handlers to call Complete and return {"text","model","duration_ms"}
- Simplify config/models: remove Verifier/LlamaSwapURL, add ModelFor
- Bump version to v0.5.0

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

internal/exec/litellm_test.go

@@ -13,23 +13,11 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func validLiteLLMResult() iexec.Result {
-	return iexec.Result{
-		Status:    "pass",
-		Phase:     "review",
-		Skill:     "review",
-		ModelUsed: "ollama/devstral",
-		Message:   "looks good",
-	}
-}
-
-func chatResponseFor(t *testing.T, result iexec.Result) []byte {
+func chatResponse(t *testing.T, content string) []byte {
 	t.Helper()
-	content, err := json.Marshal(result)
-	require.NoError(t, err)
 	resp := map[string]any{
 		"choices": []map[string]any{
-			{"message": map[string]any{"role": "assistant", "content": string(content)}},
+			{"message": map[string]any{"role": "assistant", "content": content}},
 		},
 	}
 	data, err := json.Marshal(resp)
@@ -37,25 +25,21 @@ func chatResponseFor(t *testing.T, result iexec.Result) []byte {
 	return data
 }
 
-func TestLiteLLMParsesValidResult(t *testing.T) {
+func TestLiteLLMReturnsText(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		assert.Equal(t, "/v1/chat/completions", r.URL.Path)
 		assert.Equal(t, "application/json", r.Header.Get("Content-Type"))
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write(chatResponseFor(t, validLiteLLMResult()))
+		_, _ = w.Write(chatResponse(t, "here is my analysis"))
 	}))
 	defer srv.Close()
 
 	ex := iexec.NewLiteLLM(srv.URL, "", 5*time.Second)
-	result, err := ex.Run(context.Background(), iexec.Request{
-		SkillPrompt: "review rules",
-		TaskPrompt:  "review the code",
-		Model:       "ollama/devstral",
-	})
+	text, dur, err := ex.Complete(context.Background(), "ollama/devstral", "system prompt", "user prompt")
 	require.NoError(t, err)
-	assert.Equal(t, "pass", result.Status)
-	assert.Equal(t, "review", result.Skill)
+	assert.Equal(t, "here is my analysis", text)
+	assert.GreaterOrEqual(t, dur, int64(0))
 }
 
 func TestLiteLLMSendsAuthHeader(t *testing.T) {
@@ -63,12 +47,12 @@ func TestLiteLLMSendsAuthHeader(t *testing.T) {
 		assert.Equal(t, "Bearer secret", r.Header.Get("Authorization"))
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write(chatResponseFor(t, validLiteLLMResult()))
+		_, _ = w.Write(chatResponse(t, "ok"))
 	}))
 	defer srv.Close()
 
 	ex := iexec.NewLiteLLM(srv.URL, "secret", 5*time.Second)
-	_, err := ex.Run(context.Background(), iexec.Request{Model: "x", TaskPrompt: "t", SkillPrompt: "s"})
+	_, _, err := ex.Complete(context.Background(), "model", "sys", "user")
 	require.NoError(t, err)
 }
 
@@ -79,34 +63,28 @@ func TestLiteLLMErrorOnNonOKStatus(t *testing.T) {
 	defer srv.Close()
 
 	ex := iexec.NewLiteLLM(srv.URL, "", 5*time.Second)
-	_, err := ex.Run(context.Background(), iexec.Request{Model: "x", TaskPrompt: "t"})
+	_, _, err := ex.Complete(context.Background(), "model", "sys", "user")
 	assert.ErrorContains(t, err, "503")
 }
 
-func TestLiteLLMErrorOnUnparsableJSON(t *testing.T) {
+func TestLiteLLMErrorOnEmptyChoices(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
-		resp := map[string]any{
-			"choices": []map[string]any{
-				{"message": map[string]any{"role": "assistant", "content": "not json at all"}},
-			},
-		}
-		data, _ := json.Marshal(resp)
-		_, _ = w.Write(data)
+		_, _ = w.Write([]byte(`{"choices":[]}`))
 	}))
 	defer srv.Close()
 
 	ex := iexec.NewLiteLLM(srv.URL, "", 5*time.Second)
-	_, err := ex.Run(context.Background(), iexec.Request{Model: "x", TaskPrompt: "t"})
-	assert.Error(t, err)
+	_, _, err := ex.Complete(context.Background(), "model", "sys", "user")
+	assert.ErrorContains(t, err, "no choices")
 }
 
 func TestLiteLLMRespectsContextCancellation(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	cancel() // Cancel immediately
+	cancel()
 
 	ex := iexec.NewLiteLLM("http://invalid.example.com", "", 1*time.Second)
-	_, err := ex.Run(ctx, iexec.Request{Model: "x", TaskPrompt: "t"})
+	_, _, err := ex.Complete(ctx, "model", "sys", "user")
 	assert.Error(t, err)
 }