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/skills/tdd/handlers.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/mathiasbq/supervisor/internal/brain"
-	iexec "github.com/mathiasbq/supervisor/internal/exec"
 	"github.com/mathiasbq/supervisor/internal/session"
 )
 
@@ -51,7 +50,7 @@ func (s *Skill) handleRed(ctx context.Context, raw json.RawMessage) (json.RawMes
 	if brainCtx != "" {
 		task = brainCtx + "\n---\n\n" + task
 	}
-	return s.execute(ctx, task)
+	return s.complete(ctx, s.resolveModel(args.Model), task)
 }
 
 type greenArgs struct {
@@ -80,11 +79,11 @@ func (s *Skill) handleGreen(ctx context.Context, raw json.RawMessage) (json.RawM
 	task = session.PrependHistory(s.cfg.SessionsDir, args.SessionID, "green", task)
 
 	t0 := time.Now()
-	result, err := s.execute(ctx, task)
+	result, err := s.complete(ctx, s.resolveModel(args.Model), task)
 	if err != nil {
 		return nil, err
 	}
-	s.logAttempt(args.SessionID, args.ProjectRoot, "tdd", "green", t0, result)
+	s.logEntry(args.SessionID, args.ProjectRoot, "tdd", "green", s.resolveModel(args.Model), t0, result)
 	return result, nil
 }
 
@@ -118,11 +117,11 @@ func (s *Skill) handleRefactor(ctx context.Context, raw json.RawMessage) (json.R
 	task = session.PrependHistory(s.cfg.SessionsDir, args.SessionID, "refactor", task)
 
 	t0 := time.Now()
-	result, err := s.execute(ctx, task)
+	result, err := s.complete(ctx, s.resolveModel(args.Model), task)
 	if err != nil {
 		return nil, err
 	}
-	s.logAttempt(args.SessionID, args.ProjectRoot, "tdd", "refactor", t0, result)
+	s.logEntry(args.SessionID, args.ProjectRoot, "tdd", "refactor", s.resolveModel(args.Model), t0, result)
 	return result, nil
 }
 
@@ -133,31 +132,32 @@ func (s *Skill) resolveModel(override string) string {
 	return s.cfg.DefaultModel
 }
 
-// execute calls ExecutorFn and returns the marshaled result.
-func (s *Skill) execute(ctx context.Context, task string) (json.RawMessage, error) {
-	if s.cfg.ExecutorFn == nil {
+// complete calls CompleteFunc and returns the text as JSON.
+func (s *Skill) complete(ctx context.Context, model, task string) (json.RawMessage, error) {
+	if s.cfg.CompleteFunc == nil {
 		return nil, fmt.Errorf("no executor configured")
 	}
-	req := iexec.Request{
-		SkillPrompt: s.cfg.SkillPrompt,
-		TaskPrompt:  task,
-	}
-	result, err := s.cfg.ExecutorFn(ctx, req)
+	text, dur, err := s.cfg.CompleteFunc(ctx, model, s.cfg.SkillPrompt, task)
 	if err != nil {
 		return nil, err
 	}
-	return json.Marshal(result)
+	return json.Marshal(map[string]any{"text": text, "model": model, "duration_ms": dur})
 }
 
-// logAttempt writes a session.Entry for a completed phase if session_id is set.
-// raw is the marshaled Result returned by execute; we unmarshal to extract fields.
-func (s *Skill) logAttempt(sessionID, projectRoot, skill, phase string, t0 time.Time, raw json.RawMessage) {
+// logEntry writes a session.Entry for a completed phase if session_id is set.
+func (s *Skill) logEntry(sessionID, projectRoot, skill, phase, model string, t0 time.Time, raw json.RawMessage) {
 	if sessionID == "" || s.cfg.SessionsDir == "" {
 		return
 	}
-	var result iexec.Result
-	if err := json.Unmarshal(raw, &result); err != nil {
-		return
+	var msg string
+	var result struct {
+		Text string `json:"text"`
+	}
+	if err := json.Unmarshal(raw, &result); err == nil && len(result.Text) > 0 {
+		msg = result.Text
+		if len(msg) > 200 {
+			msg = msg[:200]
+		}
 	}
 	_ = session.Append(s.cfg.SessionsDir, sessionID, session.Entry{
 		SessionID:   sessionID,
@@ -165,11 +165,9 @@ func (s *Skill) logAttempt(sessionID, projectRoot, skill, phase string, t0 time.
 		Skill:       skill,
 		Phase:       phase,
 		ProjectRoot: projectRoot,
-		Attempts:    session.AttemptsFrom(result.Attempts),
-		FinalStatus: result.Status,
-		FilePath:    result.FilePath,
-		ModelUsed:   result.ModelUsed,
+		FinalStatus: "ok",
+		ModelUsed:   model,
 		DurationMs:  time.Since(t0).Milliseconds(),
-		Message:     result.Message,
+		Message:     msg,
 	})
 }