From ae833b2765c7c8086bf8e1ea8e8ec8ee9b73e656 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 28 Apr 2026 17:10:27 +0000
Subject: feat(api): route elaboration through local LLM when configured
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 2 of "local OSS models as agents" plan. Adds a third elaboration
path that calls the local OpenAI-compatible LLM via the internal/llm
client, and reorders dispatch so the cheap path is tried first:
local → claude → gemini, with each next attempt only on hard failure
of the prior.

Wiring is opt-out, not opt-in: when [local_model].endpoint is set,
elaboration prefers local by default. Users with a slow or low-quality
local model can disable just elaboration via:

    [local_model]
    endpoint = "..."
    prefer_for_elaborate = false

without giving up the runner or the classifier path.

Implementation:
- Server gains an optional *llm.Client field via SetLLM (matches the
  existing SetNotifier/SetWorkspaceRoot setter pattern, no NewServer
  signature break).
- elaborateWithLocal() reuses buildElaboratePrompt verbatim and asks
  for response_format=json_object so we skip markdown-fence cleanup.
- handleElaborateTask reorders try chain; existing Claude-first
  behavior is preserved exactly when SetLLM is not called.
- LocalModel.UseForElaborate() encapsulates the default-true gating
  with a *bool so explicit-false survives TOML parse.

Tests:
- elaborateWithLocal: parses valid response, errors on nil client,
  errors on bad JSON.
- handler: local preferred when wired; falls back to claude when
  local fails; unchanged behavior when no LLM is configured.
- config: UseForElaborate gating across empty/default/explicit-true/
  explicit-false cases.

Pre-existing test failures noted in docs/plans/local-oss-runner.md
(post-epic cleanup): TestGeminiLogs_ParsedCorrectly returns 404 for
gemini execution log fetch — predates this change.

Plan: docs/plans/local-oss-runner.md.

https://claude.ai/code/session_017Edeq947TpSm1vQTxMhi1J
---
 internal/api/elaborate.go            |  60 ++++++++--
 internal/api/elaborate_local_test.go | 214 +++++++++++++++++++++++++++++++++++
 internal/api/server.go               |   9 ++
 3 files changed, 272 insertions(+), 11 deletions(-)
 create mode 100644 internal/api/elaborate_local_test.go

(limited to 'internal/api')

diff --git a/internal/api/elaborate.go b/internal/api/elaborate.go
index 0c681ae..30095c8 100644
--- a/internal/api/elaborate.go
+++ b/internal/api/elaborate.go
@@ -12,6 +12,8 @@ import (
 	"sort"
 	"strings"
 	"time"
+
+	"github.com/thepeterstone/claudomator/internal/llm"
 )
 
 const elaborateTimeout = 30 * time.Second
@@ -245,6 +247,33 @@ func (s *Server) elaborateWithClaude(ctx context.Context, workDir, fullPrompt st
 	return &result, nil
 }
 
+// elaborateWithLocal runs elaboration through an OpenAI-compatible local LLM.
+// It uses the same prompt template as the Claude/Gemini paths and requests
+// json_object response format so we can decode directly without the
+// markdown-fence cleanup needed for the CLI paths.
+func elaborateWithLocal(ctx context.Context, c *llm.Client, workDir, fullPrompt string) (*elaboratedTask, error) {
+	if c == nil {
+		return nil, fmt.Errorf("local llm: no client configured")
+	}
+	systemPrompt := buildElaboratePrompt(workDir)
+	resp, err := c.Chat(ctx, llm.ChatRequest{
+		Messages: []llm.Message{
+			{Role: "system", Content: systemPrompt},
+			{Role: "user", Content: fullPrompt},
+		},
+		ResponseJSON: true,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("local llm: %w", err)
+	}
+	body := strings.TrimSpace(resp.Content)
+	var result elaboratedTask
+	if jerr := json.Unmarshal([]byte(extractJSON(body)), &result); jerr != nil {
+		return nil, fmt.Errorf("local llm: parse JSON: %w (response: %s)", jerr, body)
+	}
+	return &result, nil
+}
+
 func (s *Server) elaborateWithGemini(ctx context.Context, workDir, fullPrompt string) (*elaboratedTask, error) {
 	combinedPrompt := fmt.Sprintf("%s\n\n%s", buildElaboratePrompt(workDir), fullPrompt)
 	cmd := exec.CommandContext(ctx, s.geminiBinaryPath(),
@@ -314,18 +343,27 @@ func (s *Server) handleElaborateTask(w http.ResponseWriter, r *http.Request) {
 	var result *elaboratedTask
 	var err error
 
-	// Try Claude first.
-	result, err = s.elaborateWithClaude(ctx, workDir, fullPrompt)
-	if err != nil {
-		s.logger.Warn("elaborate: claude failed, falling back to gemini", "error", err)
-		// Fallback to Gemini.
-		result, err = s.elaborateWithGemini(ctx, workDir, fullPrompt)
+	// Try local LLM first when configured. Falls back to Claude → Gemini on
+	// hard failure of each prior attempt.
+	if s.llm != nil {
+		result, err = elaborateWithLocal(ctx, s.llm, workDir, fullPrompt)
+		if err != nil {
+			s.logger.Warn("elaborate: local llm failed, falling back to claude", "error", err)
+			result = nil
+		}
+	}
+	if result == nil {
+		result, err = s.elaborateWithClaude(ctx, workDir, fullPrompt)
 		if err != nil {
-			s.logger.Error("elaborate: fallback gemini also failed", "error", err)
-			writeJSON(w, http.StatusBadGateway, map[string]string{
-				"error": fmt.Sprintf("elaboration failed: %v", err),
-			})
-			return
+			s.logger.Warn("elaborate: claude failed, falling back to gemini", "error", err)
+			result, err = s.elaborateWithGemini(ctx, workDir, fullPrompt)
+			if err != nil {
+				s.logger.Error("elaborate: gemini also failed", "error", err)
+				writeJSON(w, http.StatusBadGateway, map[string]string{
+					"error": fmt.Sprintf("elaboration failed: %v", err),
+				})
+				return
+			}
 		}
 	}
 
diff --git a/internal/api/elaborate_local_test.go b/internal/api/elaborate_local_test.go
new file mode 100644
index 0000000..09a8f9e
--- /dev/null
+++ b/internal/api/elaborate_local_test.go
@@ -0,0 +1,214 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/thepeterstone/claudomator/internal/llm"
+)
+
+// fakeChatCompletionsServer returns an httptest server that responds to a
+// /chat/completions POST with the given assistant content (which should be a
+// JSON-encoded elaboratedTask). Returns the server and a counter of calls
+// received so tests can assert dispatch ordering.
+func fakeChatCompletionsServer(t *testing.T, assistantContent string) (*httptest.Server, *int32) {
+	t.Helper()
+	var calls int32
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt32(&calls, 1)
+		w.Header().Set("Content-Type", "application/json")
+		// The assistant content has to be JSON-encoded inside the wire format.
+		escaped, _ := json.Marshal(assistantContent)
+		fmt.Fprintf(w, `{
+			"model":"local",
+			"choices":[{"message":{"role":"assistant","content":%s},"finish_reason":"stop"}],
+			"usage":{"prompt_tokens":10,"completion_tokens":50}
+		}`, string(escaped))
+	}))
+	t.Cleanup(srv.Close)
+	return srv, &calls
+}
+
+func TestElaborateWithLocal_ParsesValidResponse(t *testing.T) {
+	taskBody, _ := json.Marshal(elaboratedTask{
+		Name:        "Test elaborated task",
+		Description: "From local llm",
+		Agent: elaboratedAgent{
+			Type:         "claude",
+			Model:        "sonnet",
+			Instructions: "Run go build.",
+			MaxBudgetUSD: 0.25,
+			AllowedTools: []string{"Bash"},
+		},
+		Timeout:  "10m",
+		Priority: "normal",
+		Tags:     []string{"build"},
+	})
+	srv, calls := fakeChatCompletionsServer(t, string(taskBody))
+
+	c := &llm.Client{Endpoint: srv.URL + "/v1", Model: "fake"}
+	result, err := elaborateWithLocal(context.Background(), c, "/some/dir", "build the project")
+	if err != nil {
+		t.Fatalf("elaborateWithLocal: %v", err)
+	}
+	if result.Name != "Test elaborated task" {
+		t.Errorf("Name: %q", result.Name)
+	}
+	if result.Agent.Instructions != "Run go build." {
+		t.Errorf("Instructions: %q", result.Agent.Instructions)
+	}
+	if got := atomic.LoadInt32(calls); got != 1 {
+		t.Errorf("expected 1 call, got %d", got)
+	}
+}
+
+func TestElaborateWithLocal_NilClient(t *testing.T) {
+	_, err := elaborateWithLocal(context.Background(), nil, "", "p")
+	if err == nil || !strings.Contains(err.Error(), "no client") {
+		t.Errorf("expected nil-client error, got %v", err)
+	}
+}
+
+func TestElaborateWithLocal_BadJSON(t *testing.T) {
+	srv, _ := fakeChatCompletionsServer(t, "this is not JSON at all")
+	c := &llm.Client{Endpoint: srv.URL + "/v1", Model: "fake"}
+	_, err := elaborateWithLocal(context.Background(), c, "", "p")
+	if err == nil || !strings.Contains(err.Error(), "parse JSON") {
+		t.Errorf("expected parse error, got %v", err)
+	}
+}
+
+// TestElaborateTask_LocalLLMPreferred verifies the dispatcher uses local LLM
+// when SetLLM is configured, and does not invoke claude.
+func TestElaborateTask_LocalLLMPreferred(t *testing.T) {
+	srv, _ := testServer(t)
+
+	taskBody, _ := json.Marshal(elaboratedTask{
+		Name:        "Local-elaborated",
+		Description: "From local",
+		Agent: elaboratedAgent{
+			Type:         "claude",
+			Model:        "sonnet",
+			Instructions: "Do work. Tests pass when complete.",
+			MaxBudgetUSD: 0.25,
+			AllowedTools: []string{"Bash"},
+		},
+		Timeout:  "10m",
+		Priority: "normal",
+	})
+	llmSrv, _ := fakeChatCompletionsServer(t, string(taskBody))
+	srv.SetLLM(&llm.Client{Endpoint: llmSrv.URL + "/v1", Model: "fake"})
+	// Point Claude binary at a path that would fail if called.
+	srv.elaborateCmdPath = "/nonexistent/claude-should-not-run"
+
+	body := `{"prompt":"do work"}`
+	req := httptest.NewRequest("POST", "/api/tasks/elaborate", bytes.NewBufferString(body))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("status: want 200, got %d; body: %s", w.Code, w.Body.String())
+	}
+	var got elaboratedTask
+	if err := json.NewDecoder(w.Body).Decode(&got); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got.Name != "Local-elaborated" {
+		t.Errorf("Name: want Local-elaborated got %q", got.Name)
+	}
+}
+
+// TestElaborateTask_LocalFails_FallsBackToClaude verifies the dispatcher
+// falls back to the Claude path when the local LLM returns an error.
+func TestElaborateTask_LocalFails_FallsBackToClaude(t *testing.T) {
+	srv, _ := testServer(t)
+
+	// Local LLM server that always 500s.
+	failSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "boom", http.StatusInternalServerError)
+	}))
+	t.Cleanup(failSrv.Close)
+	srv.SetLLM(&llm.Client{Endpoint: failSrv.URL + "/v1", Model: "fake"})
+
+	// Configure a working fake Claude binary.
+	taskBody, _ := json.Marshal(elaboratedTask{
+		Name:        "Claude-fallback",
+		Description: "From claude after local failed",
+		Agent: elaboratedAgent{
+			Type:         "claude",
+			Model:        "sonnet",
+			Instructions: "Run tests.",
+			MaxBudgetUSD: 0.25,
+			AllowedTools: []string{"Bash"},
+		},
+		Timeout:  "10m",
+		Priority: "normal",
+	})
+	wrapper, _ := json.Marshal(map[string]string{"result": string(taskBody)})
+	srv.elaborateCmdPath = createFakeClaude(t, string(wrapper), 0)
+
+	body := `{"prompt":"run tests"}`
+	req := httptest.NewRequest("POST", "/api/tasks/elaborate", bytes.NewBufferString(body))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("status: want 200, got %d; body: %s", w.Code, w.Body.String())
+	}
+	var got elaboratedTask
+	if err := json.NewDecoder(w.Body).Decode(&got); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got.Name != "Claude-fallback" {
+		t.Errorf("Name: want Claude-fallback (fallback path) got %q", got.Name)
+	}
+}
+
+// TestElaborateTask_NoLocalLLM_UsesClaude verifies that when SetLLM is not
+// called, behavior is unchanged (Claude path still primary).
+func TestElaborateTask_NoLocalLLM_UsesClaude(t *testing.T) {
+	srv, _ := testServer(t)
+
+	taskBody, _ := json.Marshal(elaboratedTask{
+		Name:        "Claude-only",
+		Description: "no local llm configured",
+		Agent: elaboratedAgent{
+			Type:         "claude",
+			Model:        "sonnet",
+			Instructions: "Do work.",
+			MaxBudgetUSD: 0.25,
+			AllowedTools: []string{"Bash"},
+		},
+		Timeout:  "10m",
+		Priority: "normal",
+	})
+	wrapper, _ := json.Marshal(map[string]string{"result": string(taskBody)})
+	srv.elaborateCmdPath = createFakeClaude(t, string(wrapper), 0)
+
+	body := `{"prompt":"do work"}`
+	req := httptest.NewRequest("POST", "/api/tasks/elaborate", bytes.NewBufferString(body))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("status: want 200, got %d; body: %s", w.Code, w.Body.String())
+	}
+	var got elaboratedTask
+	if err := json.NewDecoder(w.Body).Decode(&got); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got.Name != "Claude-only" {
+		t.Errorf("Name: %q", got.Name)
+	}
+}
+
diff --git a/internal/api/server.go b/internal/api/server.go
index 8a20349..33048e4 100644
--- a/internal/api/server.go
+++ b/internal/api/server.go
@@ -12,6 +12,7 @@ import (
 
 	"github.com/thepeterstone/claudomator/internal/config"
 	"github.com/thepeterstone/claudomator/internal/executor"
+	"github.com/thepeterstone/claudomator/internal/llm"
 	"github.com/thepeterstone/claudomator/internal/notify"
 	"github.com/thepeterstone/claudomator/internal/storage"
 	"github.com/thepeterstone/claudomator/internal/task"
@@ -50,6 +51,7 @@ type Server struct {
 	elaborateLimiter *ipRateLimiter // per-IP rate limiter for elaborate/validate endpoints
 	webhookSecret    string         // HMAC-SHA256 secret for GitHub webhook validation
 	projects         []config.Project // configured projects for webhook routing
+	llm              *llm.Client    // optional local LLM client; when set, elaboration prefers it
 }
 
 // SetAPIToken configures a bearer token that must be supplied to access the API.
@@ -73,6 +75,13 @@ func (s *Server) SetWorkspaceRoot(path string) {
 	s.workspaceRoot = path
 }
 
+// SetLLM wires a local OpenAI-compatible LLM client for use by elaboration
+// (and future internal helpers). When non-nil, elaboration will prefer it
+// over the Claude CLI; on failure it falls back to claude → gemini.
+func (s *Server) SetLLM(c *llm.Client) {
+	s.llm = c
+}
+
 func NewServer(store *storage.DB, pool *executor.Pool, logger *slog.Logger, claudeBinPath, geminiBinPath string) *Server {
 	wd, _ := os.Getwd()
 	s := &Server{
-- 
cgit v1.2.3


From 6c5762848f4f3114a6ece9ce0bc70a84fca040ce Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 2 May 2026 07:54:51 +0000
Subject: feat(api): enrich CI failure task instructions via local LLM
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 3 of "local OSS models as agents" plan. When the webhook handler
creates a task for a failed CI run AND a local LLM is configured on
the server, the hardcoded 4-step investigation template is replaced
with a project-aware investigation plan generated by the LLM.

Scope adjustment from the original sketch: the original plan said
"summarize fetched workflow logs", but fetching logs requires GitHub
API auth that isn't wired. Narrowed to project-context triage —
recent git log + CLAUDE.md content + webhook metadata, fed to the
LLM with a system prompt asking for 6-12 lines of concrete next
steps. Deferred GitHub log fetching to post-epic cleanup.

Implementation:
- New internal/api/webhook_llm.go holds enrichCIInstructions and its
  helpers (readRecentCommits via `git log`, readProjectDoc).
- enrichCIInstructions is truly additive: any failure mode (no client,
  HTTP error, empty body, 10s timeout) returns the original fallback
  template unchanged. Existing webhook tests pass byte-for-byte.
- Always preserves a metadata header (repo/branch/SHA/check/URL)
  ahead of the LLM body so investigators don't lose context if the
  LLM is terse.
- Reuses s.llm (set via Server.SetLLM in Phase 2) — no new config
  knob, no per-feature gating. Asymmetric opt-out (yes-elaborate,
  no-CI-triage) deferred until there's actual demand.

Tests:
- enrichCIInstructions: nil client, LLM 500, empty body all return
  fallback unchanged.
- enrichCIInstructions: success path produces enriched body with
  metadata header preserved; user prompt contains repo/branch/SHA.
- enrichCIInstructions: real git repo (init + 2 commits) → recent
  commits appear in user prompt.
- Webhook handler regression guard: no-LLM path produces the exact
  legacy template substrings.
- Webhook handler with LLM stubbed: task instructions contain LLM
  body + metadata header.

Plan: docs/plans/local-oss-runner.md.

https://claude.ai/code/session_017Edeq947TpSm1vQTxMhi1J
---
 docs/plans/local-oss-runner.md   |  57 ++++++++++
 internal/api/webhook.go          |  15 ++-
 internal/api/webhook_llm.go      | 127 ++++++++++++++++++++++
 internal/api/webhook_llm_test.go | 228 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 426 insertions(+), 1 deletion(-)
 create mode 100644 internal/api/webhook_llm.go
 create mode 100644 internal/api/webhook_llm_test.go

(limited to 'internal/api')

diff --git a/docs/plans/local-oss-runner.md b/docs/plans/local-oss-runner.md
index 108495b..c065483 100644
--- a/docs/plans/local-oss-runner.md
+++ b/docs/plans/local-oss-runner.md
@@ -247,3 +247,60 @@ Second-cheapest, second-highest-volume LLM call after classification (one per ta
 - `prefer_local_for_elaborate=false` short-circuits to Claude path (preserves current behavior when user opts out)
 - Local-failure fallback to Claude verified by test
 - Branch pushed
+
+---
+
+# Phase 3 — Focused Plan (CI Failure Triage)
+
+## Scope adjustment from the original sketch
+
+The original Phase 3 sketch was "summarize fetched workflow logs". Fetching GitHub workflow logs requires authenticated GitHub API access (PAT or app token), which is out of scope and would balloon this phase into a GitHub-integration epic. Narrow Phase 3 to **project-context-based triage** — use signals we already have without new dependencies.
+
+What we have at webhook time: `repository.full_name`, `branch`, `SHA`, `check_name`, `html_url`, plus (when matched) a project directory we can read locally.
+
+What the LLM can do with that: produce a tighter, project-aware investigation prompt that names the recent commits, points at suspect files, and gives the agent better starting hypotheses than the current generic 4-step template.
+
+## What ships
+
+- New helper `enrichCIInstructions(ctx, *llm.Client, ciContext, projectDir, fallback string) string`
+- `createCIFailureTask` calls it when `s.llm != nil`; on any error, returns the existing hardcoded template (truly additive — webhook tests for the no-LLM path stay passing unchanged)
+- Helper uses: recent git log (last 5 commits from project_dir if it's a git repo), CLAUDE.md content if present, plus all webhook metadata
+- One configuration knob: reuse `LocalModel.UseForElaborate()` semantics? No — separate flag. Add `LocalModel.PreferForCITriage *bool` defaulting true when endpoint set, opt-out symmetrical with `PreferForElaborate`.
+
+## Explicit non-goals
+
+- No GitHub API integration (no log fetching, no auth)
+- No changes to webhook routing, signature validation, project matching, or task scheduling
+- No changes to the task schema (instructions stays a string)
+- No streaming — one-shot LLM call, sub-2s target
+
+## Task list
+
+1. Add `LocalModel.PreferForCITriage *bool` and `UseForCITriage()` helper, mirroring elaborate
+2. Add `enrichCIInstructions` in `internal/api/webhook.go` (or `webhook_llm.go` if it grows)
+3. Read recent git log from project_dir via `git log --oneline -n 5` (best-effort, swallow errors)
+4. Read CLAUDE.md from project_dir (best-effort)
+5. Build a focused prompt: "CI just failed on this project. Here's metadata + recent commits + project context. Produce a 6-12 line investigation plan that names suspect files/commits when you can, otherwise gives concrete starting steps." Plain text out, not JSON.
+6. Update `createCIFailureTask` to call enrichment when `s.llm != nil && cfg.LocalModel.UseForCITriage()`. Note: the server doesn't currently see the cfg directly — pass the gate as a setter `SetCITriageEnabled(bool)` from serve.go, OR (simpler) just gate on `s.llm != nil` and let users opt out by not calling `SetLLM`. Going with the simpler option since it matches the elaborate split: same `s.llm` for both, server doesn't track per-feature gates.
+7. Wiring in `serve.go`: when `cfg.LocalModel.Endpoint != ""`, `SetLLM(localClient)`. (Already done in Phase 2.) Per-feature opt-out via the `PreferFor*` config flags is read at wire time and could conditionally not call SetLLM, but that gives elaborate/CI an all-or-nothing toggle which is wrong. Better: introduce a separate setter `SetLLMForCITriage` so each feature can be controlled independently.
+
+   Actually, simplest and cleanest: keep one `SetLLM` setter, and gate each call site (`elaborateWithLocal`, `enrichCIInstructions`) by reading a per-feature config flag passed via separate setters. That's getting fiddly. Step back.
+
+   **Final decision:** the per-feature gate doesn't pull its weight in Phase 3. Ship it as: `s.llm != nil` enables both elaborate and CI triage. Users who want elaborate-yes/CI-triage-no can revisit later. The deferred per-feature toggles get added in the post-epic cleanup along with token telemetry — there's no real demand for the asymmetric case yet.
+
+   Revised: drop `PreferForCITriage` entirely; ship a simpler thing.
+8. Tests:
+   - `enrichCIInstructions` with stub LLM returns the LLM body
+   - `enrichCIInstructions` with failing LLM returns `fallback` unchanged
+   - `enrichCIInstructions` includes recent git log when project_dir is a real git repo (use `t.TempDir()` + `git init` + a commit)
+   - Webhook handler test: LLM configured → instructions reflect LLM output
+   - Webhook handler test: LLM not configured → instructions match the existing template byte-for-byte (regression guard)
+9. `go build ./... && go test -race ./...`
+10. Commit as Phase 3 on the same branch
+11. Push
+
+## Stop conditions
+
+- All new tests green under `-race`
+- Existing webhook tests pass byte-for-byte when LLM not configured
+- Build clean; pushed
diff --git a/internal/api/webhook.go b/internal/api/webhook.go
index 8bf1676..9437f7d 100644
--- a/internal/api/webhook.go
+++ b/internal/api/webhook.go
@@ -1,6 +1,7 @@
 package api
 
 import (
+	"context"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/hex"
@@ -154,7 +155,7 @@ func (s *Server) handleWorkflowRunEvent(w http.ResponseWriter, body []byte) {
 func (s *Server) createCIFailureTask(w http.ResponseWriter, repoName, fullName, branch, sha, checkName, htmlURL string) {
 	project := matchProject(s.projects, repoName)
 
-	instructions := fmt.Sprintf(
+	fallback := fmt.Sprintf(
 		"A CI failure has been detected and requires investigation.\n\n"+
 			"Repository: %s\n"+
 			"Branch: %s\n"+
@@ -169,6 +170,18 @@ func (s *Server) createCIFailureTask(w http.ResponseWriter, repoName, fullName,
 		fullName, branch, sha, checkName, htmlURL,
 	)
 
+	tctx := ciTriageContext{
+		Repo:      fullName,
+		Branch:    branch,
+		SHA:       sha,
+		CheckName: checkName,
+		URL:       htmlURL,
+	}
+	if project != nil {
+		tctx.ProjectDir = project.Dir
+	}
+	instructions := enrichCIInstructions(context.Background(), s.llm, tctx, fallback)
+
 	now := time.Now().UTC()
 	t := &task.Task{
 		ID:   uuid.New().String(),
diff --git a/internal/api/webhook_llm.go b/internal/api/webhook_llm.go
new file mode 100644
index 0000000..1cbca17
--- /dev/null
+++ b/internal/api/webhook_llm.go
@@ -0,0 +1,127 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/thepeterstone/claudomator/internal/llm"
+)
+
+// ciTriagePromptTimeout caps the LLM enrichment call so a slow local model
+// can't stall webhook handling. On timeout the original template is used.
+const ciTriagePromptTimeout = 10 * time.Second
+
+// ciTriageContext holds everything we know at webhook time, plus best-effort
+// project-side signals (recent git log, CLAUDE.md content) when project_dir
+// is available.
+type ciTriageContext struct {
+	Repo         string
+	Branch       string
+	SHA          string
+	CheckName    string
+	URL          string
+	ProjectDir   string
+	RecentCommits string // multi-line, may be ""
+	ProjectDoc    string // first ~4 KB of CLAUDE.md, may be ""
+}
+
+// enrichCIInstructions asks the local LLM to produce a tighter, project-aware
+// investigation plan than the hardcoded template. On any error (no client,
+// timeout, parse failure) it returns fallback unchanged so the webhook flow
+// is never worse off for trying.
+func enrichCIInstructions(parent context.Context, c *llm.Client, ctx ciTriageContext, fallback string) string {
+	if c == nil {
+		return fallback
+	}
+
+	// Pull project-side signals best-effort. Errors are silently swallowed —
+	// the LLM still gets the metadata it does have.
+	if ctx.ProjectDir != "" {
+		ctx.RecentCommits = readRecentCommits(ctx.ProjectDir, 5)
+		ctx.ProjectDoc = readProjectDoc(ctx.ProjectDir)
+	}
+
+	cctx, cancel := context.WithTimeout(parent, ciTriagePromptTimeout)
+	defer cancel()
+
+	prompt := buildCITriagePrompt(ctx)
+	resp, err := c.Chat(cctx, llm.ChatRequest{
+		Messages: []llm.Message{
+			{Role: "system", Content: "You produce concise, actionable CI failure investigation plans. Respond with plain text only — no markdown fences, no JSON, no preamble."},
+			{Role: "user", Content: prompt},
+		},
+	})
+	if err != nil {
+		return fallback
+	}
+	body := strings.TrimSpace(resp.Content)
+	if body == "" {
+		return fallback
+	}
+	// Always preserve the metadata header from the fallback so investigators
+	// can see repo/branch/SHA/URL even if the LLM body is terse.
+	return ciInstructionsHeader(ctx) + "\n\n" + body
+}
+
+func buildCITriagePrompt(ctx ciTriageContext) string {
+	var sb strings.Builder
+	fmt.Fprintf(&sb, "CI just failed.\n\nRepository: %s\nBranch: %s\nCommit SHA: %s\nCheck/Workflow: %s\nRun URL: %s\n",
+		ctx.Repo, ctx.Branch, ctx.SHA, ctx.CheckName, ctx.URL)
+	if ctx.RecentCommits != "" {
+		fmt.Fprintf(&sb, "\nRecent commits on this branch (newest first):\n%s\n", ctx.RecentCommits)
+	}
+	if ctx.ProjectDoc != "" {
+		fmt.Fprintf(&sb, "\nProject context (CLAUDE.md, truncated):\n%s\n", ctx.ProjectDoc)
+	}
+	sb.WriteString("\nProduce 6–12 lines of investigation steps. Name suspect commits or files when you can; otherwise give concrete starting actions (which logs to read, which tests to re-run locally). End with an explicit 'Acceptance Criteria' section listing what 'fixed' looks like.")
+	return sb.String()
+}
+
+func ciInstructionsHeader(ctx ciTriageContext) string {
+	return fmt.Sprintf(
+		"A CI failure has been detected and requires investigation.\n\n"+
+			"Repository: %s\n"+
+			"Branch: %s\n"+
+			"Commit SHA: %s\n"+
+			"Check/Workflow: %s\n"+
+			"Run URL: %s",
+		ctx.Repo, ctx.Branch, ctx.SHA, ctx.CheckName, ctx.URL,
+	)
+}
+
+// readRecentCommits returns the last n commits as a `git log --oneline`-style
+// string, or "" on any error.
+func readRecentCommits(projectDir string, n int) string {
+	if projectDir == "" {
+		return ""
+	}
+	cctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(cctx, "git", "-C", projectDir, "log", "--oneline", fmt.Sprintf("-n%d", n))
+	out, err := cmd.Output()
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(out))
+}
+
+// readProjectDoc returns CLAUDE.md content (capped at 4KB) or "".
+func readProjectDoc(projectDir string) string {
+	if projectDir == "" {
+		return ""
+	}
+	data, err := os.ReadFile(filepath.Join(projectDir, "CLAUDE.md"))
+	if err != nil {
+		return ""
+	}
+	const cap = 4096
+	if len(data) > cap {
+		data = data[:cap]
+	}
+	return strings.TrimSpace(string(data))
+}
diff --git a/internal/api/webhook_llm_test.go b/internal/api/webhook_llm_test.go
new file mode 100644
index 0000000..f2381a1
--- /dev/null
+++ b/internal/api/webhook_llm_test.go
@@ -0,0 +1,228 @@
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/thepeterstone/claudomator/internal/config"
+	"github.com/thepeterstone/claudomator/internal/llm"
+)
+
+// initGitRepo creates a fresh git repo with two commits and returns its path.
+// Used to verify enrichCIInstructions picks up recent commits.
+func initGitRepo(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	run := func(args ...string) {
+		cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
+		cmd.Env = append(os.Environ(),
+			"GIT_AUTHOR_NAME=test", "GIT_AUTHOR_EMAIL=test@example.com",
+			"GIT_COMMITTER_NAME=test", "GIT_COMMITTER_EMAIL=test@example.com",
+			// Disable signing in case the host has a global pre-commit signer.
+			"GIT_CONFIG_GLOBAL=/dev/null",
+		)
+		if out, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("git %v: %v\n%s", args, err, out)
+		}
+	}
+	run("init", "-q")
+	run("config", "commit.gpgsign", "false")
+	run("config", "tag.gpgsign", "false")
+	if err := os.WriteFile(filepath.Join(dir, "README"), []byte("v1\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	run("add", "README")
+	run("commit", "-q", "-m", "first commit", "--no-gpg-sign")
+	if err := os.WriteFile(filepath.Join(dir, "README"), []byte("v2\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	run("add", "README")
+	run("commit", "-q", "-m", "fix: bump readme", "--no-gpg-sign")
+	return dir
+}
+
+func TestEnrichCIInstructions_NilClient_ReturnsFallback(t *testing.T) {
+	got := enrichCIInstructions(context.Background(), nil, ciTriageContext{}, "FALLBACK")
+	if got != "FALLBACK" {
+		t.Errorf("nil client: want FALLBACK, got %q", got)
+	}
+}
+
+func TestEnrichCIInstructions_LLMFailure_ReturnsFallback(t *testing.T) {
+	// Server that always 500s.
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "boom", http.StatusInternalServerError)
+	}))
+	defer srv.Close()
+
+	c := &llm.Client{Endpoint: srv.URL + "/v1", Model: "fake"}
+	got := enrichCIInstructions(context.Background(), c,
+		ciTriageContext{Repo: "x", Branch: "main"}, "FALLBACK")
+	if got != "FALLBACK" {
+		t.Errorf("llm failure: want FALLBACK, got %q", got)
+	}
+}
+
+func TestEnrichCIInstructions_EmptyLLMBody_ReturnsFallback(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{"model":"x","choices":[{"message":{"content":""},"finish_reason":"stop"}],"usage":{}}`)
+	}))
+	defer srv.Close()
+	c := &llm.Client{Endpoint: srv.URL + "/v1", Model: "fake"}
+	got := enrichCIInstructions(context.Background(), c, ciTriageContext{}, "FALLBACK-2")
+	if got != "FALLBACK-2" {
+		t.Errorf("empty body: want fallback, got %q", got)
+	}
+}
+
+func TestEnrichCIInstructions_LLMSuccess_ReturnsEnriched(t *testing.T) {
+	expected := "1. Look at commit abc123\n2. Re-run build locally\n3. Check unit tests"
+
+	var capturedPrompt string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var body struct {
+			Messages []struct {
+				Role    string `json:"role"`
+				Content string `json:"content"`
+			} `json:"messages"`
+		}
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			t.Fatal(err)
+		}
+		// Capture the user message so we can assert metadata is in the prompt.
+		for _, m := range body.Messages {
+			if m.Role == "user" {
+				capturedPrompt = m.Content
+			}
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintf(w, `{"model":"x","choices":[{"message":{"content":%q},"finish_reason":"stop"}],"usage":{}}`, expected)
+	}))
+	defer srv.Close()
+
+	c := &llm.Client{Endpoint: srv.URL + "/v1", Model: "fake"}
+	tctx := ciTriageContext{
+		Repo:      "owner/myrepo",
+		Branch:    "main",
+		SHA:       "abc123",
+		CheckName: "CI Build",
+		URL:       "https://github.com/owner/myrepo/runs/1",
+	}
+	got := enrichCIInstructions(context.Background(), c, tctx, "FALLBACK")
+
+	if !strings.Contains(got, expected) {
+		t.Errorf("enriched body missing LLM content; got: %s", got)
+	}
+	if !strings.Contains(got, "Repository: owner/myrepo") {
+		t.Errorf("enriched body missing metadata header; got: %s", got)
+	}
+	for _, want := range []string{"owner/myrepo", "main", "abc123", "CI Build"} {
+		if !strings.Contains(capturedPrompt, want) {
+			t.Errorf("prompt missing %q; got: %s", want, capturedPrompt)
+		}
+	}
+}
+
+func TestEnrichCIInstructions_IncludesRecentCommits(t *testing.T) {
+	repo := initGitRepo(t)
+
+	var capturedPrompt string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var body struct {
+			Messages []struct {
+				Role    string `json:"role"`
+				Content string `json:"content"`
+			} `json:"messages"`
+		}
+		json.NewDecoder(r.Body).Decode(&body)
+		for _, m := range body.Messages {
+			if m.Role == "user" {
+				capturedPrompt = m.Content
+			}
+		}
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{"model":"x","choices":[{"message":{"content":"plan"},"finish_reason":"stop"}],"usage":{}}`)
+	}))
+	defer srv.Close()
+
+	c := &llm.Client{Endpoint: srv.URL + "/v1", Model: "fake"}
+	enrichCIInstructions(context.Background(), c,
+		ciTriageContext{Repo: "x", Branch: "y", ProjectDir: repo}, "FALLBACK")
+
+	if !strings.Contains(capturedPrompt, "Recent commits") {
+		t.Errorf("expected prompt to include recent commits section; got:\n%s", capturedPrompt)
+	}
+	if !strings.Contains(capturedPrompt, "fix: bump readme") {
+		t.Errorf("expected most recent commit message in prompt; got:\n%s", capturedPrompt)
+	}
+}
+
+// TestWebhook_NoLLM_InstructionsPreserved is the regression guard: when no
+// LLM is configured, webhook task instructions match the historical template
+// exactly.
+func TestWebhook_NoLLM_InstructionsPreserved(t *testing.T) {
+	srv, store := testServer(t)
+	srv.projects = []config.Project{{Name: "myrepo", Dir: "/workspace/myrepo"}}
+
+	w := webhookPost(t, srv, "check_run", checkRunFailurePayload, "")
+	if w.Code != http.StatusOK {
+		t.Fatalf("status: %d", w.Code)
+	}
+	var resp map[string]string
+	json.NewDecoder(w.Body).Decode(&resp)
+	tk, err := store.GetTask(resp["task_id"])
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"A CI failure has been detected",
+		"Please investigate the failure by:",
+		"1. Reviewing recent commits on the branch",
+		"4. Fixing the root cause and ensuring the build passes",
+	} {
+		if !strings.Contains(tk.Agent.Instructions, want) {
+			t.Errorf("instructions missing %q (regression: LLM path leaked into no-LLM case)", want)
+		}
+	}
+}
+
+// TestWebhook_WithLLM_InstructionsEnriched verifies the LLM body appears in
+// the created task's instructions when SetLLM is configured.
+func TestWebhook_WithLLM_InstructionsEnriched(t *testing.T) {
+	srv, store := testServer(t)
+	srv.projects = []config.Project{{Name: "myrepo", Dir: "/workspace/myrepo"}}
+
+	llmSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{"model":"x","choices":[{"message":{"content":"LLM-GENERATED-PLAN"},"finish_reason":"stop"}],"usage":{}}`)
+	}))
+	defer llmSrv.Close()
+	srv.SetLLM(&llm.Client{Endpoint: llmSrv.URL + "/v1", Model: "fake"})
+
+	w := webhookPost(t, srv, "check_run", checkRunFailurePayload, "")
+	if w.Code != http.StatusOK {
+		t.Fatalf("status: %d body: %s", w.Code, w.Body.String())
+	}
+	var resp map[string]string
+	json.NewDecoder(w.Body).Decode(&resp)
+	tk, err := store.GetTask(resp["task_id"])
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(tk.Agent.Instructions, "LLM-GENERATED-PLAN") {
+		t.Errorf("instructions missing LLM body; got:\n%s", tk.Agent.Instructions)
+	}
+	if !strings.Contains(tk.Agent.Instructions, "Repository: owner/myrepo") {
+		t.Errorf("instructions missing metadata header; got:\n%s", tk.Agent.Instructions)
+	}
+}
-- 
cgit v1.2.3


From 85c3bf4d28b0903a2005356339e6ea56855b8c80 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 3 May 2026 03:58:19 +0000
Subject: chore: post-epic cleanup — green test suite, no skips
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Addresses the cleanup queue captured in docs/plans/local-oss-runner.md
after the local-OSS-models epic landed. After this commit
`go test -race ./...` is green across every package with zero `t.Skip`
calls and no excluded tests.

Real bugs fixed:
- claude.go setupSandbox callsites used `sandboxDir, err := ...` which
  shadowed the outer variable, so BlockedError.SandboxDir was always
  empty. Resume-after-block was broken for both new and stale-sandbox
  paths. TestBlockedError_IncludesSandboxDir now exercises the right
  invariant.
- TestPool_ActivePerAgent_DeletesZeroEntries flake under -race: the
  cleanup defer in execute()/executeResume() runs AFTER
  handleRunResult sends on resultCh, so consumers observing a result
  could see a still-counted activePerAgent entry. Extracted
  decActiveAgent(agentType, *cleaned) helper; called explicitly before
  every resultCh send, defer becomes a no-op via the cleaned flag.
  Verified clean over `go test -race -count=10`.

Test infrastructure made hermetic:
- gitSafe now also passes -c commit.gpgsign=false / -c tag.gpgsign=false
  so sandbox tests pass on hosts whose global config requires signing.
- Bare repos in tests initialized with `-b main` (HEAD symbolic ref
  matched to the branch we push) so `git log` after push works.
- TestSandboxCloneSource_FallsBackToOrigin uses a local-FS origin URL,
  matching sandboxCloneSource's intentional filter against network URLs.
- TestGeminiLogs_ParsedCorrectly URL fixed to the actual log route
  (/api/executions/{id}/log).

GeminiRunner gap closed (partial):
- parseGeminiStream now walks lines for `result` events, surfacing
  is_error as an error and total_cost_usd as the float return value.
- GeminiRunner.Run propagates parsed cost to Execution.CostUSD.
- TestParseGeminiStream_ParsesStructuredOutput unskipped.

Notes:
- GeminiRunner is still simulated end-to-end (Run writes hardcoded
  stream data instead of execing the binary). The result/cost parser
  now exists; finishing the runner is a smaller, contained follow-up.
  Kept on the deferred queue.
- Frontend "Local" agent option and a minor storage.db.go logger TODO
  remain on the deferred queue, both intentionally — neither blocks
  anything in flight.

https://claude.ai/code/session_017Edeq947TpSm1vQTxMhi1J
---
 docs/plans/local-oss-runner.md   | 20 +++++++++
 internal/api/server_test.go      |  2 +-
 internal/executor/claude.go      | 23 ++++++++---
 internal/executor/claude_test.go | 37 +++++++++--------
 internal/executor/executor.go    | 57 ++++++++++++++------------
 internal/executor/gemini.go      | 87 ++++++++++++++++++++++++++++------------
 internal/executor/gemini_test.go |  1 -
 7 files changed, 151 insertions(+), 76 deletions(-)

(limited to 'internal/api')

diff --git a/docs/plans/local-oss-runner.md b/docs/plans/local-oss-runner.md
index c3d6291..4d5cb87 100644
--- a/docs/plans/local-oss-runner.md
+++ b/docs/plans/local-oss-runner.md
@@ -202,6 +202,26 @@ After all four phases land, plan and execute a deep cleanup pass. Things noticed
 
 Goal: clean `go test -race ./...` with zero skips and zero environmental failures on whatever platform CI runs on.
 
+## Cleanup pass — DONE
+
+All eight items in the cleanup queue above have been addressed in the post-epic cleanup commit. Summary of fixes:
+
+- `gitSafe` now disables `commit.gpgsign` and `tag.gpgsign` so sandbox tests pass on hosts with surprise signing config; matching `safe.directory=*` literals in test helpers updated for parity.
+- Real bug found and fixed: `setupSandbox(...)` callsites in `claude.go` used `sandboxDir, err := ...` which shadowed the outer variable. `BlockedError.SandboxDir` was always empty as a result; `TestBlockedError_IncludesSandboxDir` now passes for the right reason.
+- `parseGeminiStream` now parses `result` events for `is_error`/`total_cost_usd` and returns errors/cost accordingly; `TestParseGeminiStream_ParsesStructuredOutput` is unskipped.
+- `GeminiRunner.Run` propagates parsed cost to `Execution.CostUSD`.
+- `TestGeminiLogs_ParsedCorrectly` test URL fixed (`/api/tasks/{id}/executions/{exec-id}/log` → `/api/executions/{id}/log`, matching the actual route).
+- `TestPool_ActivePerAgent_DeletesZeroEntries` flake root-caused: `handleRunResult` was sending on `resultCh` before `execute()`'s deferred cleanup ran, so consumers could observe a zero-count map entry. Extracted `decActiveAgent(agentType, *cleaned)` helper, called explicitly before each `resultCh` send, defer becomes no-op via the cleaned flag. Verified clean over `-count=10` under `-race`.
+- `TestSandboxCloneSource_FallsBackToOrigin` updated to use a local-FS origin URL, matching `sandboxCloneSource`'s actual semantics (it filters non-local URLs to avoid network clones).
+- All bare repos in tests created with `git init --bare -b main` so `HEAD` symbolically points at `main` (not the default `master`), unblocking the `git log` queries the tests perform after pushing.
+
+Test-suite state after cleanup: `go test -race ./...` is green across all packages with zero `t.Skip` calls and zero excluded tests.
+
+Items not chased (deferred deliberately):
+- **GeminiRunner is still simulated** (`gemini.go` `Run` writes hardcoded stream data instead of executing the binary). The result/cost parsing now exists, so finishing the runner is a smaller, contained change. Kept on the queue but doesn't block anything else.
+- **Frontend "Local" agent option** — UI dropdown still says "Auto / Claude / Gemini". Pending token telemetry surface.
+- **`storage.db.go:706` TODO comment** — minor logger plumbing nit. Skipping unless it blocks something.
+
 ---
 
 # Phase 2 — Focused Plan (Elaboration)
diff --git a/internal/api/server_test.go b/internal/api/server_test.go
index 5c0deba..516e289 100644
--- a/internal/api/server_test.go
+++ b/internal/api/server_test.go
@@ -255,7 +255,7 @@ func TestGeminiLogs_ParsedCorrectly(t *testing.T) {
 	}
 
 	// 6. Verify the content retrieved via the API endpoint.
-	req = httptest.NewRequest("GET", "/api/tasks/"+tk.ID+"/executions/"+exec.ID+"/log", nil)
+	req = httptest.NewRequest("GET", "/api/executions/"+exec.ID+"/log", nil)
 	w = httptest.NewRecorder()
 	srv.Handler().ServeHTTP(w, req)
 
diff --git a/internal/executor/claude.go b/internal/executor/claude.go
index e3f8e1c..fa68382 100644
--- a/internal/executor/claude.go
+++ b/internal/executor/claude.go
@@ -117,7 +117,7 @@ func (r *ClaudeRunner) Run(ctx context.Context, t *task.Task, e *storage.Executi
 				e.SandboxDir = ""
 				if projectDir != "" {
 					var err error
-					sandboxDir, err := setupSandbox(t.Agent.ProjectDir, r.Logger)
+					sandboxDir, err = setupSandbox(t.Agent.ProjectDir, r.Logger)
 					if err != nil {
 						return fmt.Errorf("setting up sandbox: %w", err)
 					}
@@ -129,7 +129,7 @@ func (r *ClaudeRunner) Run(ctx context.Context, t *task.Task, e *storage.Executi
 		}
 	} else if projectDir != "" {
 		var err error
-		sandboxDir, err := setupSandbox(t.Agent.ProjectDir, r.Logger)
+		sandboxDir, err = setupSandbox(t.Agent.ProjectDir, r.Logger)
 		if err != nil {
 			return fmt.Errorf("setting up sandbox: %w", err)
 		}
@@ -226,11 +226,22 @@ func extractQuestionText(questionJSON string) string {
 	return strings.TrimSpace(q.Text)
 }
 
-// gitSafe returns git arguments that prepend "-c safe.directory=*" so that
-// commands succeed regardless of the repository owner. This is needed when
-// claudomator operates on project directories owned by a different OS user.
+// gitSafe returns git arguments that prepend safety overrides so that
+// commands succeed regardless of the repository owner or the host's global
+// git configuration. Specifically:
+//
+//   - "-c safe.directory=*" lets us operate on directories owned by a
+//     different OS user.
+//   - "-c commit.gpgsign=false" / "-c tag.gpgsign=false" stop git from
+//     trying to sign commits via the host's signing tooling. Sandbox commits
+//     are internal and don't need to be signed; an unconfigured or broken
+//     signing setup on the host should never block a sandbox merge.
 func gitSafe(args ...string) []string {
-	return append([]string{"-c", "safe.directory=*"}, args...)
+	return append([]string{
+		"-c", "safe.directory=*",
+		"-c", "commit.gpgsign=false",
+		"-c", "tag.gpgsign=false",
+	}, args...)
 }
 
 // sandboxCloneSource returns the URL to clone the sandbox from. It prefers a
diff --git a/internal/executor/claude_test.go b/internal/executor/claude_test.go
index 77596ca..b40c4ae 100644
--- a/internal/executor/claude_test.go
+++ b/internal/executor/claude_test.go
@@ -353,9 +353,9 @@ func TestExecOnce_NoGoroutineLeak_OnNaturalExit(t *testing.T) {
 func initGitRepo(t *testing.T, dir string) {
 	t.Helper()
 	cmds := [][]string{
-		{"git", "-c", "safe.directory=*", "-C", dir, "init", "-b", "main"},
-		{"git", "-c", "safe.directory=*", "-C", dir, "config", "user.email", "test@test"},
-		{"git", "-c", "safe.directory=*", "-C", dir, "config", "user.name", "test"},
+		{"git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", dir, "init", "-b", "main"},
+		{"git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", dir, "config", "user.email", "test@test"},
+		{"git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", dir, "config", "user.name", "test"},
 	}
 	for _, args := range cmds {
 		if out, err := exec.Command(args[0], args[1:]...).CombinedOutput(); err != nil {
@@ -365,10 +365,10 @@ func initGitRepo(t *testing.T, dir string) {
 	if err := os.WriteFile(filepath.Join(dir, "init.txt"), []byte("init"), 0644); err != nil {
 		t.Fatal(err)
 	}
-	if out, err := exec.Command("git", "-c", "safe.directory=*", "-C", dir, "add", ".").CombinedOutput(); err != nil {
+	if out, err := exec.Command("git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", dir, "add", ".").CombinedOutput(); err != nil {
 		t.Fatalf("git add: %v\n%s", err, out)
 	}
-	if out, err := exec.Command("git", "-c", "safe.directory=*", "-C", dir, "commit", "-m", "init").CombinedOutput(); err != nil {
+	if out, err := exec.Command("git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", dir, "commit", "-m", "init").CombinedOutput(); err != nil {
 		t.Fatalf("git commit: %v\n%s", err, out)
 	}
 }
@@ -391,7 +391,10 @@ func TestSandboxCloneSource_PrefersLocalRemote(t *testing.T) {
 func TestSandboxCloneSource_FallsBackToOrigin(t *testing.T) {
 	dir := t.TempDir()
 	initGitRepo(t, dir)
-	originURL := "https://example.com/origin-repo"
+	// sandboxCloneSource intentionally filters to local-FS remotes (so
+	// `git clone <src>` doesn't go over the network). Use a local path
+	// for origin to verify the fallback semantics.
+	originURL := t.TempDir()
 	exec.Command("git", "-C", dir, "remote", "add", "origin", originURL).Run()
 
 	got := sandboxCloneSource(dir)
@@ -455,23 +458,23 @@ func TestSetupSandbox_InitialisesNonGitDir(t *testing.T) {
 func TestTeardownSandbox_AutocommitsChanges(t *testing.T) {
 	// Create a bare repo as origin so push succeeds.
 	bare := t.TempDir()
-	if out, err := exec.Command("git", "init", "--bare", bare).CombinedOutput(); err != nil {
+	if out, err := exec.Command("git", "init", "--bare", "-b", "main", bare).CombinedOutput(); err != nil {
 		t.Fatalf("git init bare: %v\n%s", err, out)
 	}
 
 	// Create a sandbox directly.
 	sandbox := t.TempDir()
 	initGitRepo(t, sandbox)
-	if out, err := exec.Command("git", "-c", "safe.directory=*", "-C", sandbox, "remote", "add", "origin", bare).CombinedOutput(); err != nil {
+	if out, err := exec.Command("git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", sandbox, "remote", "add", "origin", bare).CombinedOutput(); err != nil {
 		t.Fatalf("git remote add: %v\n%s", err, out)
 	}
 	// Initial push to establish origin/main
-	if out, err := exec.Command("git", "-c", "safe.directory=*", "-C", sandbox, "push", "origin", "main").CombinedOutput(); err != nil {
+	if out, err := exec.Command("git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", sandbox, "push", "origin", "main").CombinedOutput(); err != nil {
 		t.Fatalf("git push initial: %v\n%s", err, out)
 	}
 
 	// Capture startHEAD
-	headOut, err := exec.Command("git", "-c", "safe.directory=*", "-C", sandbox, "rev-parse", "HEAD").Output()
+	headOut, err := exec.Command("git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", sandbox, "rev-parse", "HEAD").Output()
 	if err != nil {
 		t.Fatalf("rev-parse HEAD: %v", err)
 	}
@@ -514,18 +517,18 @@ func TestTeardownSandbox_AutocommitsChanges(t *testing.T) {
 
 func TestTeardownSandbox_BuildFailure_BlocksAutocommit(t *testing.T) {
 	bare := t.TempDir()
-	if out, err := exec.Command("git", "init", "--bare", bare).CombinedOutput(); err != nil {
+	if out, err := exec.Command("git", "init", "--bare", "-b", "main", bare).CombinedOutput(); err != nil {
 		t.Fatalf("git init bare: %v\n%s", err, out)
 	}
 
 	sandbox := t.TempDir()
 	initGitRepo(t, sandbox)
-	if out, err := exec.Command("git", "-c", "safe.directory=*", "-C", sandbox, "remote", "add", "origin", bare).CombinedOutput(); err != nil {
+	if out, err := exec.Command("git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", sandbox, "remote", "add", "origin", bare).CombinedOutput(); err != nil {
 		t.Fatalf("git remote add: %v\n%s", err, out)
 	}
 
 	// Capture startHEAD
-	headOut, err := exec.Command("git", "-c", "safe.directory=*", "-C", sandbox, "rev-parse", "HEAD").Output()
+	headOut, err := exec.Command("git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", sandbox, "rev-parse", "HEAD").Output()
 	if err != nil {
 		t.Fatalf("rev-parse HEAD: %v", err)
 	}
@@ -566,18 +569,18 @@ func TestTeardownSandbox_BuildFailure_BlocksAutocommit(t *testing.T) {
 
 func TestTeardownSandbox_BuildSuccess_ProceedsToAutocommit(t *testing.T) {
 	bare := t.TempDir()
-	if out, err := exec.Command("git", "init", "--bare", bare).CombinedOutput(); err != nil {
+	if out, err := exec.Command("git", "init", "--bare", "-b", "main", bare).CombinedOutput(); err != nil {
 		t.Fatalf("git init bare: %v\n%s", err, out)
 	}
 
 	sandbox := t.TempDir()
 	initGitRepo(t, sandbox)
-	if out, err := exec.Command("git", "-c", "safe.directory=*", "-C", sandbox, "remote", "add", "origin", bare).CombinedOutput(); err != nil {
+	if out, err := exec.Command("git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", sandbox, "remote", "add", "origin", bare).CombinedOutput(); err != nil {
 		t.Fatalf("git remote add: %v\n%s", err, out)
 	}
 
 	// Capture startHEAD
-	headOut, err := exec.Command("git", "-c", "safe.directory=*", "-C", sandbox, "rev-parse", "HEAD").Output()
+	headOut, err := exec.Command("git", "-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-C", sandbox, "rev-parse", "HEAD").Output()
 	if err != nil {
 		t.Fatalf("rev-parse HEAD: %v", err)
 	}
@@ -870,7 +873,7 @@ func TestTailFile_MissingFile_ReturnsEmpty(t *testing.T) {
 
 func TestGitSafe_PrependsSafeDirectory(t *testing.T) {
 	got := gitSafe("-C", "/some/path", "status")
-	want := []string{"-c", "safe.directory=*", "-C", "/some/path", "status"}
+	want := []string{"-c", "safe.directory=*", "-c", "commit.gpgsign=false", "-c", "tag.gpgsign=false", "-C", "/some/path", "status"}
 	if len(got) != len(want) {
 		t.Fatalf("gitSafe() = %v, want %v", got, want)
 	}
diff --git a/internal/executor/executor.go b/internal/executor/executor.go
index 4501a3c..315030d 100644
--- a/internal/executor/executor.go
+++ b/internal/executor/executor.go
@@ -196,6 +196,28 @@ func (p *Pool) getRunner(t *task.Task) (Runner, error) {
 	return runner, nil
 }
 
+// decActiveAgent decrements the active counters for a finished task. Safe to
+// call multiple times — subsequent calls are no-ops via the cleaned flag.
+// Always call this before sending on resultCh so consumers observing a result
+// see the accounting already settled (no zero-count map entries lingering).
+func (p *Pool) decActiveAgent(agentType string, cleaned *bool) {
+	if *cleaned {
+		return
+	}
+	*cleaned = true
+	p.mu.Lock()
+	p.active--
+	p.activePerAgent[agentType]--
+	if p.activePerAgent[agentType] == 0 {
+		delete(p.activePerAgent, agentType)
+	}
+	p.mu.Unlock()
+	select {
+	case p.doneCh <- struct{}{}:
+	default:
+	}
+}
+
 func (p *Pool) executeResume(ctx context.Context, t *task.Task, exec *storage.Execution) {
 	agentType := t.Agent.Type
 	if agentType == "" {
@@ -206,23 +228,13 @@ func (p *Pool) executeResume(ctx context.Context, t *task.Task, exec *storage.Ex
 	p.activePerAgent[agentType]++
 	p.mu.Unlock()
 
-	defer func() {
-		p.mu.Lock()
-		p.active--
-		p.activePerAgent[agentType]--
-		if p.activePerAgent[agentType] == 0 {
-			delete(p.activePerAgent, agentType)
-		}
-		p.mu.Unlock()
-		select {
-		case p.doneCh <- struct{}{}:
-		default:
-		}
-	}()
+	var cleaned bool
+	defer p.decActiveAgent(agentType, &cleaned)
 
 	runner, err := p.getRunner(t)
 	if err != nil {
 		p.logger.Error("failed to get runner for resume", "error", err, "taskID", t.ID)
+		p.decActiveAgent(agentType, &cleaned)
 		p.resultCh <- &Result{TaskID: t.ID, Execution: exec, Err: err}
 		return
 	}
@@ -264,6 +276,7 @@ func (p *Pool) executeResume(ctx context.Context, t *task.Task, exec *storage.Ex
 	err = runner.Run(ctx, t, exec)
 	exec.EndTime = time.Now().UTC()
 
+	p.decActiveAgent(agentType, &cleaned)
 	p.handleRunResult(ctx, t, exec, err, agentType)
 }
 
@@ -473,19 +486,8 @@ func (p *Pool) execute(ctx context.Context, t *task.Task) {
 	p.activePerAgent[agentType]++
 	p.mu.Unlock()
 
-	defer func() {
-		p.mu.Lock()
-		p.active--
-		p.activePerAgent[agentType]--
-		if p.activePerAgent[agentType] == 0 {
-			delete(p.activePerAgent, agentType)
-		}
-		p.mu.Unlock()
-		select {
-		case p.doneCh <- struct{}{}:
-		default:
-		}
-	}()
+	var cleaned bool
+	defer p.decActiveAgent(agentType, &cleaned)
 
 	runner, err := p.getRunner(t)
 	if err != nil {
@@ -505,6 +507,7 @@ func (p *Pool) execute(ctx context.Context, t *task.Task) {
 		if err := p.store.UpdateTaskState(t.ID, task.StateFailed); err != nil {
 			p.logger.Error("failed to update task state", "taskID", t.ID, "state", task.StateFailed, "error", err)
 		}
+		p.decActiveAgent(agentType, &cleaned)
 		p.resultCh <- &Result{TaskID: t.ID, Execution: exec, Err: err}
 		return
 	}
@@ -527,6 +530,7 @@ func (p *Pool) execute(ctx context.Context, t *task.Task) {
 			if err := p.store.UpdateTaskState(t.ID, task.StateFailed); err != nil {
 				p.logger.Error("failed to update task state", "taskID", t.ID, "state", task.StateFailed, "error", err)
 			}
+			p.decActiveAgent(agentType, &cleaned)
 			p.resultCh <- &Result{TaskID: t.ID, Execution: exec, Err: err}
 			return
 		}
@@ -583,6 +587,7 @@ func (p *Pool) execute(ctx context.Context, t *task.Task) {
 	err = runner.Run(ctx, t, exec)
 	exec.EndTime = time.Now().UTC()
 
+	p.decActiveAgent(agentType, &cleaned)
 	p.handleRunResult(ctx, t, exec, err, agentType)
 }
 
diff --git a/internal/executor/gemini.go b/internal/executor/gemini.go
index d79c47d..7f2f54f 100644
--- a/internal/executor/gemini.go
+++ b/internal/executor/gemini.go
@@ -2,6 +2,7 @@ package executor
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"log/slog"
@@ -117,16 +118,21 @@ func (r *GeminiRunner) execOnce(ctx context.Context, args []string, workingDir,
 
 
 	var streamErr error
+	var streamCost float64
 	var wg sync.WaitGroup
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		_, streamErr = parseGeminiStream(stdoutR, stdoutFile, r.Logger)
+		streamCost, streamErr = parseGeminiStream(stdoutR, stdoutFile, r.Logger)
 		stdoutR.Close()
 	}()
 
 	wg.Wait() // Wait for parseGeminiStream to finish
 
+	if streamCost > 0 {
+		e.CostUSD = streamCost
+	}
+
 	// Set a dummy exit code for this simulated run
 	e.ExitCode = 0
 
@@ -136,9 +142,10 @@ func (r *GeminiRunner) execOnce(ctx context.Context, args []string, workingDir,
 	return nil
 }
 
-// parseGeminiStream reads streaming JSON from the gemini CLI, unwraps markdown
-// code blocks, writes the inner JSON to w, and returns (costUSD, error).
-// For now, it focuses on unwrapping and writing, not detailed parsing of cost/errors.
+// parseGeminiStream reads streaming JSON from the gemini CLI, strips markdown
+// code fences if the output is wrapped in them, writes the inner stream-json
+// to w, and returns (costUSD, error). If a `result` event has `is_error: true`,
+// an error wrapping the result message is returned.
 func parseGeminiStream(r io.Reader, w io.Writer, logger *slog.Logger) (float64, error) {
 	fullOutput, err := io.ReadAll(r)
 	if err != nil {
@@ -146,31 +153,61 @@ func parseGeminiStream(r io.Reader, w io.Writer, logger *slog.Logger) (float64,
 	}
 	logger.Debug("parseGeminiStream: raw output received", "output", string(fullOutput))
 
-	outputStr := strings.TrimSpace(string(fullOutput)) // Trim leading/trailing whitespace/newlines from the whole output
-
-	jsonContent := outputStr // Default to raw output if no markdown block is found or malformed
-	jsonStartIdx := strings.Index(outputStr, "```json")
-	if jsonStartIdx != -1 {
-		// Found "```json", now look for the closing "```"
-		jsonEndIdx := strings.LastIndex(outputStr, "```")
-		if jsonEndIdx != -1 && jsonEndIdx > jsonStartIdx {
-			// Extract content between the markdown fences.
-			jsonContent = outputStr[jsonStartIdx+len("```json"):jsonEndIdx]
-			jsonContent = strings.TrimSpace(jsonContent) // Trim again after extraction, to remove potential inner newlines
-		} else {
-			logger.Warn("Malformed markdown JSON block from Gemini (missing closing ``` or invalid structure), falling back to raw output.", "outputLength", len(outputStr))
+	inner := stripGeminiFences(string(fullOutput), logger)
+	if _, writeErr := w.Write([]byte(inner)); writeErr != nil {
+		return 0, fmt.Errorf("writing gemini output: %w", writeErr)
+	}
+
+	// Walk lines looking for a result event so we can surface errors and cost.
+	var (
+		cost    float64
+		errMsg  string
+		isError bool
+	)
+	for _, raw := range strings.Split(inner, "\n") {
+		line := strings.TrimSpace(raw)
+		if line == "" {
+			continue
+		}
+		var evt struct {
+			Type    string  `json:"type"`
+			IsError bool    `json:"is_error"`
+			Result  string  `json:"result"`
+			Cost    float64 `json:"total_cost_usd"`
+		}
+		if err := json.Unmarshal([]byte(line), &evt); err != nil {
+			continue
+		}
+		if evt.Type == "result" {
+			if evt.Cost > 0 {
+				cost = evt.Cost
+			}
+			if evt.IsError {
+				isError = true
+				errMsg = evt.Result
+			}
 		}
-	} else {
-		logger.Warn("No markdown JSON block found from Gemini, falling back to raw output.", "outputLength", len(outputStr))
 	}
-
-	// Write the (possibly extracted and trimmed) JSON content to the writer.
-	_, writeErr := w.Write([]byte(jsonContent))
-	if writeErr != nil {
-		return 0, fmt.Errorf("writing extracted gemini json: %w", writeErr)
+	if isError {
+		return cost, fmt.Errorf("gemini reported error: %s", errMsg)
 	}
+	return cost, nil
+}
 
-	return 0, nil // For now, no cost/error parsing for Gemini stream
+// stripGeminiFences removes a surrounding ```json ... ``` markdown block if
+// present, returning the trimmed inner content. If no markdown fence is
+// found, the input is returned verbatim (no whitespace trimming) so callers
+// that expect byte-exact pass-through behavior get it.
+func stripGeminiFences(raw string, logger *slog.Logger) string {
+	trimmed := strings.TrimSpace(raw)
+	if start := strings.Index(trimmed, "```json"); start != -1 {
+		if end := strings.LastIndex(trimmed, "```"); end > start {
+			return strings.TrimSpace(trimmed[start+len("```json") : end])
+		}
+		logger.Warn("malformed gemini markdown block (missing closing fence); using raw output", "len", len(trimmed))
+		return trimmed
+	}
+	return raw
 }
 
 func (r *GeminiRunner) buildArgs(t *task.Task, e *storage.Execution, questionFile string) []string {
diff --git a/internal/executor/gemini_test.go b/internal/executor/gemini_test.go
index 75e3b45..4b0339e 100644
--- a/internal/executor/gemini_test.go
+++ b/internal/executor/gemini_test.go
@@ -148,7 +148,6 @@ func TestGeminiRunner_BinaryPath_Custom(t *testing.T) {
 
 
 func TestParseGeminiStream_ParsesStructuredOutput(t *testing.T) {
-	t.Skip("GeminiRunner stub: result error/cost parsing not yet implemented; tracked separately")
 	// Simulate a stream-json input with various message types, including a result with error and cost.
 	input := streamLine(`{"type":"content_block_start","content_block":{"text":"Hello,"}}`) +
 		streamLine(`{"type":"content_block_delta","content_block":{"text":" World!"}}`) +
-- 
cgit v1.2.3


From e7b382bf177cbe518af3d86c3ee6c49344d225f4 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 3 May 2026 08:00:20 +0000
Subject: chore: close deferred work — real GeminiRunner, Local UI option,
 db.go cleanup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes the three items left on the deferred queue after the post-epic
cleanup.

GeminiRunner.execOnce now actually executes the gemini binary instead
of writing hardcoded stream data. Mirrors ClaudeRunner.execOnce:
- exec.CommandContext with the same env vars (CLAUDOMATOR_API_URL etc.)
- process group SIGKILL on context cancel
- stdout piped through parseGeminiStream → stdoutFile
- stderr to file
- exit codes captured, stderr tail surfaced on failure

Test infrastructure bug uncovered in passing: testServerWithGeminiMockRunner's
mock script used double-quoted echo with literal triple-backticks, which
bash interpreted as command substitution. The script always produced
empty output. The bug was invisible until now because GeminiRunner
ignored the script entirely. Switched to a single-quoted heredoc.

Frontend: index.html dropdown gains a "Local" option. No JS branching
needed — the value flows through to agent.type verbatim and downstream
display reads the type string as-is.

storage/db.go: removed stale debug-comment scaffolding (the "TODO:
Replace with proper logger" block) that was tracking a dead
`fmt.Printf` call. The path it commented on is fine without logging —
unmarshal errors are returned wrapped.

Test status: `go test -race ./...` green across every package, zero
skips, zero excluded tests.

https://claude.ai/code/session_017Edeq947TpSm1vQTxMhi1J
---
 docs/plans/local-oss-runner.md |  9 +++++++
 internal/api/server_test.go    | 23 ++++++++--------
 internal/executor/gemini.go    | 61 +++++++++++++++++++++++++++++++-----------
 internal/storage/db.go         |  5 ----
 web/index.html                 |  1 +
 5 files changed, 67 insertions(+), 32 deletions(-)

(limited to 'internal/api')

diff --git a/docs/plans/local-oss-runner.md b/docs/plans/local-oss-runner.md
index 4d5cb87..4504bbb 100644
--- a/docs/plans/local-oss-runner.md
+++ b/docs/plans/local-oss-runner.md
@@ -222,6 +222,15 @@ Items not chased (deferred deliberately):
 - **Frontend "Local" agent option** — UI dropdown still says "Auto / Claude / Gemini". Pending token telemetry surface.
 - **`storage.db.go:706` TODO comment** — minor logger plumbing nit. Skipping unless it blocks something.
 
+## Deferred work — DONE
+
+Follow-up commit closed the three deferred items above:
+
+- `GeminiRunner.execOnce` now invokes the actual `gemini` binary via `exec.CommandContext`, mirroring the `ClaudeRunner` pattern: pipe stdout to `parseGeminiStream`, kill the process group on context cancel, capture stderr to file, surface exit codes. Hardcoded simulation removed.
+- Test infrastructure bug uncovered and fixed in passing: the mock gemini script in `testServerWithGeminiMockRunner` was using `"\``json\`"` which bash interpreted as command substitution, so the script always produced empty output. Switched to a single-quoted heredoc. The bug was masked previously because the runner ignored the script entirely.
+- Frontend `index.html` dropdown gains a `Local` option. No JS branching changes needed — the value flows through to `agent.type` verbatim and downstream display reads the type string as-is.
+- Stale debug-comment scaffolding around `storage.db.go:706` deleted.
+
 ---
 
 # Phase 2 — Focused Plan (Elaboration)
diff --git a/internal/api/server_test.go b/internal/api/server_test.go
index 516e289..2139e36 100644
--- a/internal/api/server_test.go
+++ b/internal/api/server_test.go
@@ -143,20 +143,21 @@ func testServerWithGeminiMockRunner(t *testing.T) (*Server, *storage.DB) {
 
 	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug}))
 
-	// Create the mock gemini binary script.
+	// Create the mock gemini binary script. Use single-quoted heredoc so
+	// bash does not try to evaluate the literal backticks as command
+	// substitution.
 	mockBinDir := t.TempDir()
 	mockGeminiPath := filepath.Join(mockBinDir, "mock-gemini-binary.sh")
 	mockScriptContent := `#!/bin/bash
-OUTPUT_FILE=$(mktemp)
-echo "` + "```json" + `" > "$OUTPUT_FILE"
-echo "{\"type\":\"content_block_start\",\"content_block\":{\"text\":\"Hello, Gemini!\",\"type\":\"text\"}}" >> "$OUTPUT_FILE"
-echo "{\"type\":\"content_block_delta\",\"content_block\":{\"text\":\" How are you?\"}}" >> "$OUTPUT_FILE"
-echo "{\"type\":\"content_block_end\"}" >> "$OUTPUT_FILE"
-echo "{\"type\":\"message_delta\",\"message\":{\"role\":\"model\"}}" >> "$OUTPUT_FILE"
-echo "{\"type\":\"message_end\"}" >> "$OUTPUT_FILE"
-echo "` + "```" + `" >> "$OUTPUT_FILE"
-cat "$OUTPUT_FILE"
-rm "$OUTPUT_FILE"
+cat <<'EOF'
+` + "```json" + `
+{"type":"content_block_start","content_block":{"text":"Hello, Gemini!","type":"text"}}
+{"type":"content_block_delta","content_block":{"text":" How are you?"}}
+{"type":"content_block_end"}
+{"type":"message_delta","message":{"role":"model"}}
+{"type":"message_end"}
+` + "```" + `
+EOF
 exit 0
 `
 	if err := os.WriteFile(mockGeminiPath, []byte(mockScriptContent), 0755); err != nil {
diff --git a/internal/executor/gemini.go b/internal/executor/gemini.go
index 7f2f54f..04382ae 100644
--- a/internal/executor/gemini.go
+++ b/internal/executor/gemini.go
@@ -7,9 +7,11 @@ import (
 	"io"
 	"log/slog"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"sync"
+	"syscall"
 
 	"github.com/thepeterstone/claudomator/internal/storage"
 	"github.com/thepeterstone/claudomator/internal/task"
@@ -84,8 +86,18 @@ func (r *GeminiRunner) Run(ctx context.Context, t *task.Task, e *storage.Executi
 }
 
 func (r *GeminiRunner) execOnce(ctx context.Context, args []string, workingDir, projectDir string, e *storage.Execution) error {
-	// Temporarily bypass external command execution to debug pipe.
-	// We will simulate outputting to stdoutW directly.
+	cmd := exec.CommandContext(ctx, r.binaryPath(), args...)
+	cmd.Env = append(os.Environ(),
+		"CLAUDOMATOR_API_URL="+r.APIURL,
+		"CLAUDOMATOR_TASK_ID="+e.TaskID,
+		"CLAUDOMATOR_PROJECT_DIR="+projectDir,
+		"CLAUDOMATOR_QUESTION_FILE="+filepath.Join(e.ArtifactDir, "question.json"),
+		"CLAUDOMATOR_SUMMARY_FILE="+filepath.Join(e.ArtifactDir, "summary.txt"),
+	)
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	if workingDir != "" {
+		cmd.Dir = workingDir
+	}
 
 	stdoutFile, err := os.Create(e.StdoutPath)
 	if err != nil {
@@ -103,22 +115,27 @@ func (r *GeminiRunner) execOnce(ctx context.Context, args []string, workingDir,
 	if err != nil {
 		return fmt.Errorf("creating stdout pipe: %w", err)
 	}
+	cmd.Stdout = stdoutW
+	cmd.Stderr = stderrFile
 
-	// Simulate writing to stdoutW
+	if err := cmd.Start(); err != nil {
+		stdoutW.Close()
+		stdoutR.Close()
+		return fmt.Errorf("starting gemini: %w", err)
+	}
+	stdoutW.Close()
+
+	killDone := make(chan struct{})
 	go func() {
-		defer stdoutW.Close() // Close the writer when done.
-		fmt.Fprintf(stdoutW, "```json\n")
-		fmt.Fprintf(stdoutW, "{\"type\":\"content_block_start\",\"content_block\":{\"text\":\"Hello, Gemini!\",\"type\":\"text\"}}\n")
-		fmt.Fprintf(stdoutW, "{\"type\":\"content_block_delta\",\"content_block\":{\"text\":\" How are you?\"}}\n")
-		fmt.Fprintf(stdoutW, "{\"type\":\"content_block_end\"}\n")
-		fmt.Fprintf(stdoutW, "{\"type\":\"message_delta\",\"message\":{\"role\":\"model\"}}\n")
-		fmt.Fprintf(stdoutW, "{\"type\":\"message_end\"}\n")
-		fmt.Fprintf(stdoutW, "```\n")
+		select {
+		case <-ctx.Done():
+			syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
+		case <-killDone:
+		}
 	}()
 
-
-	var streamErr error
 	var streamCost float64
+	var streamErr error
 	var wg sync.WaitGroup
 	wg.Add(1)
 	go func() {
@@ -127,14 +144,26 @@ func (r *GeminiRunner) execOnce(ctx context.Context, args []string, workingDir,
 		stdoutR.Close()
 	}()
 
-	wg.Wait() // Wait for parseGeminiStream to finish
+	waitErr := cmd.Wait()
+	close(killDone)
+	wg.Wait()
 
 	if streamCost > 0 {
 		e.CostUSD = streamCost
 	}
 
-	// Set a dummy exit code for this simulated run
-	e.ExitCode = 0
+	if waitErr != nil {
+		if exitErr, ok := waitErr.(*exec.ExitError); ok {
+			e.ExitCode = exitErr.ExitCode()
+		}
+		if streamErr != nil {
+			return streamErr
+		}
+		if tail := tailFile(e.StderrPath, 20); tail != "" {
+			return fmt.Errorf("gemini exited with error: %w\nstderr:\n%s", waitErr, tail)
+		}
+		return fmt.Errorf("gemini exited with error: %w", waitErr)
+	}
 
 	if streamErr != nil {
 		return streamErr
diff --git a/internal/storage/db.go b/internal/storage/db.go
index c871c77..ce60e2f 100644
--- a/internal/storage/db.go
+++ b/internal/storage/db.go
@@ -699,11 +699,6 @@ func scanTask(row scanner) (*task.Task, error) {
 	t.State = task.State(state)
 	t.Priority = task.Priority(priority)
 	t.Timeout.Duration = time.Duration(timeoutNS)
-	// Add debug log for configJSON
-	// The logger is not available directly in db.go, so I'll use fmt.Printf for now.
-	// For production code, a logger should be injected.
-	// fmt.Printf("DEBUG: configJSON from DB: %s\n", configJSON)
-	// TODO: Replace with proper logger when available.
 	if err := json.Unmarshal([]byte(configJSON), &t.Agent); err != nil {
 		return nil, fmt.Errorf("unmarshaling agent config: %w", err)
 	}
diff --git a/web/index.html b/web/index.html
index 1746baf..7c0b030 100644
--- a/web/index.html
+++ b/web/index.html
@@ -16,6 +16,7 @@
         <option value="auto">Auto</option>
         <option value="claude">Claude</option>
         <option value="gemini">Gemini</option>
+        <option value="local">Local</option>
       </select>
       <button id="btn-start-next" class="btn-secondary">Start Next</button>
       <button id="btn-new-task" class="btn-primary">New Task</button>
-- 
cgit v1.2.3