Job 674d51a5-6e57-4047-a635-239794f17213

{"path":".","recursive":false}

drwxr-xr-x  6 user user  4096 Aug 26 11:11 .
drwxr-xr-x  1 root root  4096 Aug 26 11:11 ..
drwxr-xr-x  7 user user  4096 Aug 26 11:11 .git
-rw-r--r--  1 user user    22 Aug 26 11:11 .gitignore
-rw-r--r--  1 user user  6387 Aug 26 11:11 README.md
drwxr-xr-x  3 user user  4096 Aug 26 11:11 cmd
drwxr-xr-x  2 user user  4096 Aug 26 11:11 docker
-rw-r--r--  1 user user  2628 Aug 26 11:11 go.mod
-rw-r--r--  1 user user 16578 Aug 26 11:11 go.sum
drwxr-xr-x 11 user user  4096 Aug 26 11:11 internal
-rw-r--r--  1 user user  3092 Aug 26 11:11 zoo.hcl.example

{"command":"cd /project && git log --oneline -5 && git status"}

7423d86 Try to re-roll broken tool calls.
f58963a Merge pull request 'Jobs page: follow the live log tail, with a jump-to-bottom button' (#58) from issue-57-greg into main
0b5138d Merge pull request 'tools: drop the PTY from docker exec, keep stdout/stderr separate' (#54) from issue-52-greg into main
c91b25a More correct tool schema.
f4da8cd Jobs page: follow the live log tail, with a jump-to-bottom button
On branch issue-62-greg
nothing to commit, working tree clean

{"command":"cd /project && find . -type f -name \"*.go\" | head -50 && echo \"---\" && cat README.md | head -60"}

./cmd/zoo/main.go
./internal/config/config.go
./internal/config/config_test.go
./internal/web/templates.go
./internal/web/web_test.go
./internal/web/web.go
./internal/livelog/hub.go
./internal/livelog/hub_test.go
./internal/tools/forgejo.go
./internal/tools/grep_search.go
./internal/tools/context.go
./internal/tools/remove_file.go
./internal/tools/registry.go
./internal/tools/write_file.go
./internal/tools/move_file.go
./internal/tools/read_file.go
./internal/tools/edit-file.go
./internal/tools/list_files.go
./internal/tools/bash.go
./internal/tools/shell.go
./internal/tools/tools_test.go
./internal/llm/arguments_test.go
./internal/llm/streamer_test.go
./internal/llm/client.go
./internal/llm/streamer.go
./internal/llm/arguments.go
./internal/llm/types.go
./internal/store/store.go
./internal/store/store_test.go
./internal/forgejo/watcher_test.go
./internal/forgejo/poll.go
./internal/forgejo/watcher.go
./internal/forgejo/repo_filter.go
./internal/forgejo/webhook_test.go
./internal/forgejo/webhook.go
./internal/forgejo/repo_filter_test.go
./internal/forgejo/client.go
./internal/forgejo/poll_test.go
./internal/forgejo/client_test.go
./internal/forgejo/event.go
./internal/agentrun/forgejo.go
./internal/agentrun/roster_test.go
./internal/agentrun/context.go
./internal/agentrun/loop.go
./internal/agentrun/sandboxgit.go
./internal/agentrun/loop_test.go
./internal/agentrun/docker.go
./internal/agentrun/seed_test.go
./internal/agentrun/docker_integration_test.go
./internal/agentrun/run.go
---
# 🐾 Zoo

**Autonomous AI agents that work your Forgejo issues & pull requests.**

Zoo watches a [Forgejo](https://codeberg.org/forgejo/forgejo) instance for issue and pull request events, then dispatches them to configured AI agents running in isolated Docker containers. Each agent has its own role, LLM model, and personality — like a menagerie working together to keep your projects moving.

---

## ✨ Features

- **Multi-agent orchestration** — Assign different tasks to specialized agents (reviewers, managers, developers).
- **Event-driven routing** — Configure which agent handles `issue:new`, `pr:new`, `issue:comment`, `issue:assigned`, and more.
- **LLM flexibility** — Plug in any OpenAI-compatible API; each agent gets its own model choice.
- **Isolated execution** — Agents run in Docker containers with full filesystem access but no persistence between runs.
- **Live dashboard** — Real-time web UI showing active agents, logs, and job history.
- **Webhook & polling support** — React to events instantly via webhooks, or fall back to polling.

---

## 🚀 Quick Start

### Prerequisites

| Requirement | Version |
|-------------|---------|
| Go          | 1.26+   |
| Docker      | Latest  |
| Forgejo     | Any (self-hosted or codeberg.dk) |
| LLM endpoint | OpenAI-compatible API |

### Configuration

Copy the example config and customize it:

```bash
cp zoo.hcl.example zoo.hcl
```

Edit `zoo.hcl` with your Forgejo credentials, LLM tokens, and agent definitions. See the [configuration reference](#-configuration-reference) below.

### Running

```bash
go build -o zoo ./cmd/zoo
./zoo
```

The daemon starts on port `:8080` by default. Open your browser to see the dashboard.

---

## 👥 Meet the Agents

The example configuration includes four agents, each with a distinct role:

| Agent    | Role                  | Suggested LLM       | Handles                          |
|----------|-----------------------|---------------------|----------------------------------|
| **leon** | Engineering Manager   | Qwen 3.8            | New issues, comments             |
| **greg** | Senior Developer      | Qwen 3.8            | Pull request reviews             |
| **anna** | UI/UX Designer        | Qwen 3.6            | Design-related issues & PRs      |

{"end_line":1,"path":"internal/livelog/hub.go","start_line":1}

{"path":"internal/livelog/hub.go","content":"// Package livelog is an in-memory pub/sub hub that lets agentrun publish","start_line":1,"end_line":1,"total_lines":165,"truncated":true}

{"end_line":1,"path":"internal/llm/streamer.go","start_line":1}

{"path":"internal/llm/streamer.go","content":"package llm","start_line":1,"end_line":1,"total_lines":79,"truncated":true}

{"end_line":165,"path":"internal/livelog/hub.go","start_line":1}

{"path":"internal/livelog/hub.go","content":"// Package livelog is an in-memory pub/sub hub that lets agentrun publish\n// fine-grained, not-yet-persisted events (reasoning/content deltas, tool\n// calls) for a running job, and lets the web dashboard subscribe to them\n// live over SSE. It carries only the tail of a run that hasn't made it\n// into SQLite yet — see Hub.Checkpoint.\npackage livelog\n\nimport \"sync\"\n\ntype Type string\n\nconst (\n\tReasoningStart Type = \"reasoning_start\"\n\tReasoningDelta Type = \"reasoning_delta\"\n\tReasoningEnd   Type = \"reasoning_end\"\n\tContentStart   Type = \"content_start\"\n\tContentDelta   Type = \"content_delta\"\n\tContentEnd     Type = \"content_end\"\n\tTool           Type = \"tool\"\n\tSystem         Type = \"system\"\n\tStatus         Type = \"status\"\n)\n\ntype Event struct {\n\tType      Type   `json:\"type\"`\n\tText      string `json:\"text,omitempty\"`\n\tName      string `json:\"name,omitempty\"`\n\tArguments string `json:\"arguments,omitempty\"`\n\tResult    string `json:\"result,omitempty\"`\n\tError     bool   `json:\"error,omitempty\"`\n\tStatus    string `json:\"status,omitempty\"`\n}\n\n// subChanBuffer bounds how many events a slow subscriber can lag behind\n// by before new events are dropped for it. Generous for a single-user\n// local dashboard; a dropped event just means a subscriber's browser\n// tab misses a chunk and catches up on the next one, never a hang.\nconst subChanBuffer = 256\n\n// maxBufferedEvents caps the per-job replay buffer as a safety net\n// against unbounded growth if a caller forgets to Checkpoint. Ordinary\n// operation clears the buffer far below this on every persisted block.\nconst maxBufferedEvents = 10000\n\ntype stream struct {\n\tmu   sync.Mutex\n\tbuf  []Event\n\tsubs map[chan Event]struct{}\n}\n\n// Hub fans out per-job Events to any number of live subscribers.\ntype Hub struct {\n\tmu   sync.Mutex\n\tjobs map[string]*stream\n}\n\nfunc NewHub() *Hub {\n\treturn \u0026Hub{jobs: make(map[string]*stream)}\n}\n\nfunc (h *Hub) get(jobID string) *stream {\n\th.mu.Lock()\n\tdefer h.mu.Unlock()\n\n\ts, ok := h.jobs[jobID]\n\tif !ok {\n\t\ts = \u0026stream{subs: make(map[chan Event]struct{})}\n\t\th.jobs[jobID] = s\n\t}\n\n\treturn s\n}\n\n// Publish appends ev to jobID's replay buffer and fans it out to every\n// current subscriber. Never blocks: a subscriber whose channel is full\n// simply misses this event.\nfunc (h *Hub) Publish(jobID string, ev Event) {\n\ts := h.get(jobID)\n\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\n\ts.buf = append(s.buf, ev)\n\tif len(s.buf) \u003e maxBufferedEvents {\n\t\ts.buf = s.buf[len(s.buf)-maxBufferedEvents:]\n\t}\n\n\tfor ch := range s.subs {\n\t\tselect {\n\t\tcase ch \u003c- ev:\n\t\tdefault:\n\t\t}\n\t}\n}\n\n// Checkpoint clears jobID's replay buffer. Call this right after a\n// block derived from buffered events has been durably written to\n// storage, so a subscriber that connects afterward — and therefore\n// already sees that block via the persisted history — is never replayed\n// it a second time over the live channel.\nfunc (h *Hub) Checkpoint(jobID string) {\n\ts := h.get(jobID)\n\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\n\ts.buf = nil\n}\n\n// Subscribe returns the events currently buffered for jobID (i.e. not\n// yet checkpointed) plus a channel of everything published from this\n// point on. The returned cancel func must be called when the caller is\n// done reading, to unregister and close the channel.\nfunc (h *Hub) Subscribe(jobID string) (buffered []Event, ch \u003c-chan Event, cancel func()) {\n\ts := h.get(jobID)\n\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\n\tbuffered = append([]Event(nil), s.buf...)\n\n\tc := make(chan Event, subChanBuffer)\n\ts.subs[c] = struct{}{}\n\n\tvar once sync.Once\n\n\tcancelFn := func() {\n\t\tonce.Do(func() {\n\t\t\ts.mu.Lock()\n\t\t\tdefer s.mu.Unlock()\n\n\t\t\tif _, ok := s.subs[c]; ok {\n\t\t\t\tdelete(s.subs, c)\n\t\t\t\tclose(c)\n\t\t\t}\n\t\t})\n\t}\n\n\treturn buffered, c, cancelFn\n}\n\n// Close publishes a terminal Status event, disconnects every current\n// subscriber, and drops jobID's state. Call this exactly once, when the\n// job's run has finished.\nfunc (h *Hub) Close(jobID string) {\n\th.Publish(jobID, Event{Type: Status, Status: \"done\"})\n\n\th.mu.Lock()\n\ts, ok := h.jobs[jobID]\n\tdelete(h.jobs, jobID)\n\th.mu.Unlock()\n\n\tif !ok {\n\t\treturn\n\t}\n\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\n\tfor ch := range s.subs {\n\t\tclose(ch)\n\t}\n\n\ts.subs = nil\n}","start_line":1,"end_line":165,"total_lines":165,"truncated":false}

{"end_line":79,"path":"internal/llm/streamer.go","start_line":1}

{"path":"internal/llm/streamer.go","content":"package llm\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n)\n\ntype Streamer struct {\n\tcompletion ChatCompletion\n\tresp       *http.Response\n\tscanner    *bufio.Scanner\n\teof        bool\n}\n\nfunc NewStreamer(resp *http.Response) (*Streamer, error) {\n\tif resp.StatusCode != http.StatusOK {\n\t\tbody, _ := io.ReadAll(resp.Body)\n\t\tresp.Body.Close()\n\t\treturn nil, fmt.Errorf(\"status: %d: %s\", resp.StatusCode, body)\n\t}\n\n\treturn \u0026Streamer{\n\t\tresp:    resp,\n\t\tscanner: bufio.NewScanner(resp.Body),\n\t}, nil\n}\n\n// Get returns the accumulated completion after merging in the next SSE\n// chunk. Callers should keep calling Get until it returns io.EOF.\nfunc (s *Streamer) Get() (*ChatCompletion, error) {\n\tif s.eof {\n\t\treturn nil, io.EOF\n\t}\n\n\tprefix := []byte(\"data: \")\n\n\tvar buf []byte\n\n\tfor s.scanner.Scan() {\n\t\tif err := s.scanner.Err(); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tbuf = bytes.TrimSpace(s.scanner.Bytes())\n\n\t\tif len(buf) == 0 {\n\t\t\tcontinue\n\t\t}\n\n\t\tif bytes.HasPrefix(buf, prefix) {\n\t\t\tbreak\n\t\t}\n\t}\n\n\tbuf = bytes.TrimPrefix(buf, prefix)\n\n\tif bytes.Equal(buf, []byte(\"[DONE]\")) {\n\t\ts.resp.Body.Close()\n\t\ts.eof = true\n\t\treturn nil, io.EOF\n\t}\n\n\tvar completion ChatCompletion\n\n\t// Unknown fields are tolerated on purpose: servers (e.g. newer\n\t// llama.cpp builds) may add fields we don't know about yet, and\n\t// failing on them would break compatibility.\n\tif err := json.Unmarshal(buf, \u0026completion); err != nil {\n\t\treturn nil, fmt.Errorf(\"decode completion chunk: %w: %s\", err, buf)\n\t}\n\n\ts.completion.Merge(\u0026completion)\n\n\treturn \u0026s.completion, nil\n}","start_line":1,"end_line":79,"total_lines":79,"truncated":false}

{"end_line":1,"path":"internal/web/web.go","start_line":1}

{"path":"internal/web/web.go","content":"// Package web is zoo's minimal server-rendered dashboard: config","start_line":1,"end_line":1,"total_lines":374,"truncated":true}

{"command":"cd /project && wc -l internal/web/web.go internal/web/templates.go internal/agentrun/loop.go internal/agentrun/run.go internal/llm/types.go internal/store/store.go"}

  374 internal/web/web.go
 1076 internal/web/templates.go
  192 internal/agentrun/loop.go
  447 internal/agentrun/run.go
  276 internal/llm/types.go
  360 internal/store/store.go
 2725 total

{"command":"cd /project && cat internal/web/web.go"}

// Package web is zoo's minimal server-rendered dashboard: config
// overview, live queue/history, and a per-job log tail.
package web

import (
	"encoding/json"
	"fmt"
	"html/template"
	"net/http"
	"strings"
	"sync"
	"time"

	"github.com/abrander/zoo/internal/config"
	"github.com/abrander/zoo/internal/forgejo"
	"github.com/abrander/zoo/internal/livelog"
	"github.com/abrander/zoo/internal/store"
)

type Server struct {
	cfg   *config.Config
	store *store.Store
	hub   *livelog.Hub
	fg    *forgejo.Client
	tmpl  *template.Template

	avatarMu    sync.Mutex
	avatarCache map[string]avatarCacheEntry
}

// avatarCacheTTL bounds how long a resolved avatar URL is trusted before
// it's re-fetched from Forgejo. Avatars rarely change, but a user can
// re-upload one (which changes its URL), so the cache expires instead of
// living for the process lifetime.
const avatarCacheTTL = time.Hour

type avatarCacheEntry struct {
	url       string
	fetchedAt time.Time
}

func New(cfg *config.Config, st *store.Store, hub *livelog.Hub, fg *forgejo.Client) *Server {
	return &Server{
		cfg:         cfg,
		store:       st,
		hub:         hub,
		fg:          fg,
		tmpl:        template.Must(template.New("").Parse(templates)),
		avatarCache: map[string]avatarCacheEntry{},
	}
}

// Handler returns the dashboard's http.Handler, gated by config.Web's
// bearer token if one is set.
func (s *Server) Handler() http.Handler {
	mux := http.NewServeMux()

	mux.HandleFunc("GET /{$}", s.handleIndex)
	mux.HandleFunc("GET /jobs", s.handleJobs)
	mux.HandleFunc("GET /jobs/{id}", s.handleJobDetail)
	mux.HandleFunc("GET /jobs/{id}/events", s.handleJobEvents)

	return s.authMiddleware(mux)
}

func (s *Server) authMiddleware(next http.Handler) http.Handler {
	if s.cfg.Web == nil || s.cfg.Web.Token == "" {
		return next
	}

	token := s.cfg.Web.Token

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		auth := r.Header.Get("Authorization")
		if auth != "Bearer "+token {
			w.Header().Set("WWW-Authenticate", `Bearer realm="zoo"`)
			http.Error(w, "unauthorized", http.StatusUnauthorized)

			return
		}

		next.ServeHTTP(w, r)
	})
}

func (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
	// Fetch active (pending or running) jobs for the dashboard overview.
	// We fetch more than we display so we can filter to just active ones.
	allJobs, err := s.store.ListJobs(r.Context(), 200)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Collect unique agent names from active jobs.
	var agentNames []string
	seenAgents := make(map[string]bool)

	var activeJobs []activeJobRow
	for _, j := range allJobs {
		if j.Status != store.JobPending && j.Status != store.JobRunning {
			continue
		}
		if !seenAgents[j.Agent] {
			seenAgents[j.Agent] = true
			agentNames = append(agentNames, j.Agent)
		}
		activeJobs = append(activeJobs, activeJobRow{
			Job:       j,
			AvatarURL: s.avatarFor(j.Agent),
		})
	}

	type indexData struct {
		*config.Config
		ActiveJobs []activeJobRow
	}

	s.render(w, "index", indexData{
		Config:     s.cfg,
		ActiveJobs: activeJobs,
	})
}

// activeJobRow is a store.Job enriched with the agent's avatar URL.
type activeJobRow struct {
	store.Job
	AvatarURL string
}

// jobRow is a store.Job plus the agent's Forgejo avatar, resolved for the
// jobs table so it's immediately clear who is running each job.
type jobRow struct {
	store.Job
	AvatarURL string
}

func (s *Server) handleJobs(w http.ResponseWriter, r *http.Request) {
	jobs, err := s.store.ListJobs(r.Context(), 200)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)

		return
	}

	rows := make([]jobRow, 0, len(jobs))

	for _, j := range jobs {
		rows = append(rows, jobRow{Job: j, AvatarURL: s.avatarFor(j.Agent)})
	}

	s.render(w, "jobs", rows)
}

// avatarFor returns the Forgejo avatar URL of the agent named username,
// or "" if it can't be resolved (no Forgejo client configured, unknown
// user, API error). The dashboard must never fail to render because of a
// missing avatar, so every failure mode degrades to no image. Results are
// cached per username for avatarCacheTTL so a page refresh doesn't turn
// into one GetUserInfo call per unique agent.
func (s *Server) avatarFor(username string) string {
	if s.fg == nil || username == "" {
		return ""
	}

	s.avatarMu.Lock()

	if e, ok := s.avatarCache[username]; ok && time.Since(e.fetchedAt) < avatarCacheTTL {
		s.avatarMu.Unlock()

		return e.url
	}

	s.avatarMu.Unlock()

	profile, err := s.fg.AgentProfile(username)
	if err != nil {
		return ""
	}

	s.avatarMu.Lock()
	s.avatarCache[username] = avatarCacheEntry{url: profile.AvatarURL, fetchedAt: time.Now()}
	s.avatarMu.Unlock()

	return profile.AvatarURL
}

// toolBlock is the parsed form of a stream="tool" store.LogLine, for the
// template to render as a single collapsed detail.
type toolBlock struct {
	Name      string
	Arguments string
	Result    string
	Error     bool
}

// block is one self-contained, already-complete unit of job output: a
// finished reasoning or assistant-message block, a finished tool call,
// or a misc system note. Unlike the old flat log view, one store.LogLine
// maps to exactly one block — grouping/streaming happens upstream, when
// agentrun persists the row.
type block struct {
	Kind string // "reasoning" | "content" | "tool" | "system"
	Text string
	Tool *toolBlock
}

func buildBlocks(logs []store.LogLine) []block {
	blocks := make([]block, 0, len(logs))

	for _, l := range logs {
		switch l.Stream {
		case "reasoning", "content":
			// Model output routinely starts/ends with newlines. The block
			// body renders with white-space: pre-wrap, so those would show
			// up as visible blank lines inflating the block's height. Trim
			// them for display (internal newlines are kept) and drop
			// blocks that are nothing but whitespace.
			text := strings.TrimSpace(l.Line)
			if text == "" {
				continue
			}
			blocks = append(blocks, block{Kind: l.Stream, Text: text})

		case "tool":
			var entry store.ToolLogEntry
			if err := json.Unmarshal([]byte(l.Line), &entry); err != nil {
				blocks = append(blocks, block{Kind: "system", Text: l.Line})

				continue
			}

			blocks = append(blocks, block{Kind: "tool", Tool: &toolBlock{
				Name:      entry.Name,
				Arguments: entry.Arguments,
				Result:    entry.Result,
				Error:     entry.Error,
			}})

		default:
			blocks = append(blocks, block{Kind: "system", Text: l.Line})
		}
	}

	return blocks
}

func (s *Server) handleJobDetail(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")

	job, err := s.store.GetJob(r.Context(), id)
	if err != nil {
		http.Error(w, "job not found", http.StatusNotFound)

		return
	}

	logs, err := s.store.TailLogs(r.Context(), id, -1)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)

		return
	}

	s.render(w, "job_detail", struct {
		Job       store.Job
		Blocks    []block
		Live      bool
		AvatarURL string
	}{job, buildBlocks(logs), job.Status == store.JobPending || job.Status == store.JobRunning, s.avatarFor(job.Agent)})
}

// handleJobEvents streams job jobID's live output as Server-Sent
// Events. It only ever carries events for the current, not-yet-persisted
// block (see livelog.Hub.Checkpoint) — everything already written to
// the store is rendered once, statically, by handleJobDetail. If the
// job isn't live, the response just ends immediately and the client
// falls back to the static page.
func (s *Server) handleJobEvents(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")

	job, err := s.store.GetJob(r.Context(), id)
	if err != nil {
		http.Error(w, "job not found", http.StatusNotFound)

		return
	}

	if job.Status != store.JobPending && job.Status != store.JobRunning {
		return
	}

	flusher, ok := w.(http.Flusher)
	if !ok {
		http.Error(w, "streaming unsupported", http.StatusInternalServerError)

		return
	}

	w.Header().Set("Content-Type", "text/event-stream")
	w.Header().Set("Cache-Control", "no-cache")
	w.Header().Set("Connection", "keep-alive")
	w.WriteHeader(http.StatusOK)

	buffered, ch, cancel := s.hub.Subscribe(id)
	defer cancel()

	write := func(ev livelog.Event) bool {
		data, err := json.Marshal(ev)
		if err != nil {
			return true
		}

		if _, err := fmt.Fprintf(w, "data: %s\n\n", data); err != nil {
			return false
		}

		flusher.Flush()

		return true
	}

	for _, ev := range buffered {
		if !write(ev) {
			return
		}
	}

	heartbeat := time.NewTicker(15 * time.Second)
	defer heartbeat.Stop()

	for {
		select {
		case ev, ok := <-ch:
			if !ok {
				return
			}

			if !write(ev) {
				return
			}

			if ev.Type == livelog.Status {
				return
			}

		case <-heartbeat.C:
			if _, err := fmt.Fprint(w, ": heartbeat\n\n"); err != nil {
				return
			}

			flusher.Flush()

		case <-r.Context().Done():
			return
		}
	}
}

func (s *Server) render(w http.ResponseWriter, name string, data any) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")

	// Every page here reflects live, fast-changing state (job status, log
	// blocks). Without this, browsers are free to serve a stale cached
	// copy of the job detail page on a same-URL navigation — including
	// the auto location.reload() a job's SSE stream triggers when it
	// finishes — which looks exactly like blocks that were visible while
	// streaming vanishing once the page reloads.
	w.Header().Set("Cache-Control", "no-store")

	if err := s.tmpl.ExecuteTemplate(w, name, data); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}

{"command":"cd /project && cat internal/web/templates.go"}

package web

const templates = `
{{define "layout_head"}}
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>zoo</title>
<style>
  :root {
    --bg: #0f0f13;
    --bg-surface: #1a1a24;
    --bg-surface-hover: #22222e;
    --bg-code: #12121a;
    --border: #2a2a3a;
    --text: #e4e4e8;
    --text-muted: #8888a0;
    --accent: #7c6aef;
    --accent-glow: rgba(124, 106, 239, 0.15);
    --radius: 12px;
    --radius-sm: 8px;
    --font: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
    --mono: 'JetBrains Mono', 'Fira Code', 'SF Mono', monospace;
  }

  * { margin: 0; padding: 0; box-sizing: border-box; }

  body {
    font-family: var(--font);
    background: var(--bg);
    color: var(--text);
    line-height: 1.6;
    min-height: 100vh;
  }

  /* ── Navigation ─────────────────────────────── */
  nav {
    position: sticky;
    top: 0;
    z-index: 100;
    display: flex;
    align-items: center;
    justify-content: space-between;
    padding: 0 2rem;
    height: 60px;
    background: var(--bg-surface);
    border-bottom: 1px solid var(--border);
    backdrop-filter: blur(12px);
  }

  nav .brand {
    display: flex;
    align-items: center;
    gap: 0.6rem;
    font-size: 1.25rem;
    font-weight: 700;
    color: var(--text);
    text-decoration: none;
    letter-spacing: -0.02em;
  }

  nav .brand .logo {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    width: 32px;
    height: 32px;
    border-radius: var(--radius-sm);
    background: linear-gradient(135deg, var(--accent), #a78bfa);
    color: #fff;
    font-size: 1rem;
    font-weight: 800;
  }

  nav .links {
    display: flex;
    gap: 0.25rem;
  }

  nav .links a {
    display: inline-flex;
    align-items: center;
    gap: 0.4rem;
    padding: 0.5rem 1rem;
    border-radius: var(--radius-sm);
    color: var(--text-muted);
    text-decoration: none;
    font-size: 0.9rem;
    font-weight: 500;
    transition: all 0.15s ease;
  }

  nav .links a:hover {
    color: var(--text);
    background: var(--bg-surface-hover);
  }

  nav .links a.active {
    color: var(--accent);
    background: var(--accent-glow);
  }

  /* ── Main container ─────────────────────────── */
  .container {
    max-width: 1200px;
    margin: 0 auto;
    padding: 2rem;
  }

  /* ── Page header ────────────────────────────── */
  .page-header {
    margin-bottom: 2rem;
  }

  h1 {
    font-size: 2rem;
    font-weight: 700;
    letter-spacing: -0.03em;
    margin-bottom: 0.25rem;
    background: linear-gradient(135deg, var(--text), var(--text-muted));
    -webkit-background-clip: text;
    -webkit-text-fill-color: transparent;
    background-clip: text;
  }

  .page-header p {
    color: var(--text-muted);
    font-size: 0.95rem;
  }

  h2 {
    font-size: 1.15rem;
    font-weight: 600;
    color: var(--text-muted);
    text-transform: uppercase;
    letter-spacing: 0.06em;
    margin: 2rem 0 1rem;
    padding-bottom: 0.5rem;
    border-bottom: 1px solid var(--border);
  }

  /* ── Cards ──────────────────────────────────── */
  .card {
    background: var(--bg-surface);
    border: 1px solid var(--border);
    border-radius: var(--radius);
    overflow: hidden;
    transition: border-color 0.2s ease;
  }

  .card:hover {
    border-color: #3a3a50;
  }

  /* ── Job Cards ──────────────────────────────── */
  .job-cards {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(340px, 1fr));
    gap: 1rem;
    margin-bottom: 2rem;
  }

  .job-card {
    background: var(--bg-surface);
    border: 1px solid var(--border);
    border-radius: var(--radius);
    padding: 1rem 1.25rem;
    transition: border-color 0.2s ease, box-shadow 0.2s ease;
    display: flex;
    flex-direction: column;
    gap: 0.75rem;
  }

  .job-card:hover {
    border-color: #3a3a50;
    box-shadow: 0 2px 12px rgba(0, 0, 0, 0.2);
  }

  .job-card-header {
    display: flex;
    align-items: center;
    justify-content: space-between;
  }

  .job-card-link {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    width: 28px;
    height: 28px;
    border-radius: var(--radius-sm);
    color: var(--text-muted);
    text-decoration: none;
    font-size: 1.1rem;
    font-weight: 600;
    transition: all 0.15s ease;
  }

  .job-card-link:hover {
    color: var(--accent);
    background: var(--accent-glow);
  }

  .job-card-body {
    display: flex;
    flex-direction: column;
    gap: 0.4rem;
  }

  .job-card-title {
    font-size: 1rem;
    font-weight: 600;
    color: var(--text);
    line-height: 1.4;
    margin: 0;
    display: -webkit-box;
    -webkit-line-clamp: 2;
    -webkit-box-orient: vertical;
    overflow: hidden;
  }

  .job-card-meta {
    font-size: 0.82rem;
    color: var(--text-muted);
    margin: 0;
  }

  .job-card-meta code {
    background: var(--bg-code);
    padding: 0.15rem 0.4rem;
    border-radius: 4px;
    font-size: 0.8rem;
  }

  .job-card-agent {
    display: inline-flex;
    align-items: center;
    gap: 0.5rem;
    margin-top: 0.25rem;
  }

  .job-card-avatar {
    width: 28px;
    height: 28px;
    border-radius: 50%;
    border: 1px solid var(--border);
    background: var(--bg-code);
    flex-shrink: 0;
  }

  .job-card-agent-name {
    font-size: 0.9rem;
    font-weight: 500;
    color: var(--text);
  }

  /* ── Tables ─────────────────────────────────── */
  .table-wrap {
    border-radius: var(--radius);
    overflow: hidden;
    border: 1px solid var(--border);
  }

  table {
    width: 100%;
    border-collapse: collapse;
    font-size: 0.9rem;
  }

  thead {
    background: var(--bg-surface-hover);
  }

  th {
    text-align: left;
    padding: 0.75rem 1rem;
    font-weight: 600;
    font-size: 0.8rem;
    text-transform: uppercase;
    letter-spacing: 0.05em;
    color: var(--text-muted);
    border-bottom: 1px solid var(--border);
  }

  td {
    padding: 0.75rem 1rem;
    border-bottom: 1px solid var(--border);
    vertical-align: middle;
  }

  tbody tr:last-child td {
    border-bottom: none;
  }

  tbody tr {
    transition: background 0.15s ease;
  }

  tbody tr:hover {
    background: var(--bg-surface-hover);
  }

  td a {
    color: var(--accent);
    text-decoration: none;
    font-weight: 500;
  }

  td a:hover {
    text-decoration: underline;
  }

  /* ── Badges ─────────────────────────────────── */
  .badge {
    display: inline-flex;
    align-items: center;
    gap: 0.35rem;
    padding: 0.2rem 0.65rem;
    border-radius: 999px;
    font-size: 0.78rem;
    font-weight: 600;
    letter-spacing: 0.01em;
  }

  .badge .dot {
    width: 6px;
    height: 6px;
    border-radius: 50%;
    flex-shrink: 0;
  }

  .badge-pending {
    background: rgba(234, 170, 2, 0.12);
    color: #eab308;
  }
  .badge-pending .dot { background: #eab308; }

  .badge-running {
    background: rgba(124, 106, 239, 0.15);
    color: var(--accent);
  }
  .badge-running .dot {
    background: var(--accent);
    animation: pulse 1.5s ease-in-out infinite;
  }

  .badge-succeeded {
    background: rgba(34, 197, 94, 0.12);
    color: #22c55e;
  }
  .badge-succeeded .dot { background: #22c55e; }

  .badge-failed, .badge-timed_out {
    background: rgba(239, 68, 68, 0.12);
    color: #ef4444;
  }
  .badge-failed .dot, .badge-timed_out .dot { background: #ef4444; }

  @keyframes pulse {
    0%, 100% { opacity: 1; }
    50% { opacity: 0.3; }
  }

  /* ── Agent avatars ──────────────────────────── */
  .agent {
    display: inline-flex;
    align-items: center;
    gap: 0.5rem;
  }

  .agent-avatar {
    width: 22px;
    height: 22px;
    border-radius: 50%;
    border: 1px solid var(--border);
    background: var(--bg-code);
    flex-shrink: 0;
  }

  /* ── Info grid ──────────────────────────────── */
  .info-grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
    gap: 1rem;
    margin-bottom: 1rem;
  }

  .info-item {
    display: flex;
    flex-direction: column;
    gap: 0.2rem;
  }

  .info-item .label {
    font-size: 0.78rem;
    text-transform: uppercase;
    letter-spacing: 0.05em;
    color: var(--text-muted);
    font-weight: 600;
  }

  .info-item .value {
    font-size: 0.95rem;
    color: var(--text);
    word-break: break-all;
  }

  /* ── Code / Log ─────────────────────────────── */
  .log-container {
    background: var(--bg-code);
    border: 1px solid var(--border);
    border-radius: var(--radius);
    overflow-y: auto;
    max-height: 70vh;
    padding: 1rem;
  }

  /* The log box (not the window) is the scrollable element, so the
     jump-to-bottom button floats over it via a positioned wrapper. */
  .log-wrap {
    position: relative;
  }

  .log-jump {
    position: absolute;
    right: 1.5rem;
    bottom: 1.5rem;
    display: inline-flex;
    align-items: center;
    gap: 0.35rem;
    padding: 0.45rem 0.9rem;
    border: 1px solid var(--border);
    border-radius: 999px;
    background: var(--bg-surface);
    color: var(--text);
    font-family: var(--font);
    font-size: 0.8rem;
    font-weight: 600;
    line-height: 1.2;
    cursor: pointer;
    box-shadow: 0 6px 16px rgba(0, 0, 0, 0.45);
    transition: background 0.15s ease, border-color 0.15s ease;
  }

  .log-jump:hover {
    background: var(--bg-surface-hover);
    border-color: var(--accent);
  }

  /* The display rule above would otherwise outrank the UA stylesheet's
     [hidden] { display: none }. */
  .log-jump[hidden] {
    display: none;
  }

  /* Plain block flow, not flex: a flex column with overflow:hidden
     children (.block-tool) gives those children an automatic min-height
     of 0 instead of their content height, so once total content
     exceeded max-height, flexbox was free to squash them down. */
  .log-container .block + .block {
    margin-top: 0.6rem;
  }

  pre {
    margin: 0;
    padding: 1.25rem;
    font-family: var(--mono);
    font-size: 0.82rem;
    line-height: 1.7;
    color: #c4c4d0;
    white-space: pre-wrap;
    word-break: break-all;
  }

  /* ── Log blocks ─────────────────────────────── */
  .block-label {
    font-size: 0.72rem;
    text-transform: uppercase;
    letter-spacing: 0.06em;
    color: var(--text-muted);
    font-weight: 600;
    margin-bottom: 0.35rem;
  }

  .block-body {
    font-family: var(--font);
    font-size: 0.9rem;
    line-height: 1.6;
    color: var(--text);
    white-space: pre-wrap;
    word-break: break-word;
  }

  .block-reasoning,
  .block-content {
    padding: 0.75rem 1rem;
    border-radius: var(--radius-sm);
  }

  .block-reasoning {
    background: rgba(124, 106, 239, 0.06);
    border-left: 3px solid var(--accent);
  }

  .block-reasoning .block-body {
    color: var(--text-muted);
    font-style: italic;
  }

  .block-content {
    background: var(--bg-surface);
    border: 1px solid var(--border);
  }

  .block-system {
    padding: 0.35rem 0.75rem;
    color: var(--text-muted);
    font-family: var(--mono);
    font-size: 0.8rem;
  }

  .block-tool {
    background: rgba(34, 211, 238, 0.06);
    border: 1px solid var(--border);
    border-left: 4px solid #22d3ee;
    border-radius: var(--radius-sm);
    overflow: hidden;
  }

  .block-tool summary {
    display: flex;
    align-items: center;
    gap: 0.75rem;
    cursor: pointer;
    padding: 0.9rem 1.1rem;
    min-height: 2.75rem;
    color: var(--text);
    list-style: none;
  }

  .block-tool summary::-webkit-details-marker { display: none; }

  .block-tool summary::before {
    content: "▸";
    display: inline-block;
    font-size: 1.1rem;
    color: var(--text-muted);
    transition: transform 0.15s ease;
    flex-shrink: 0;
  }

  .block-tool[open] summary::before { transform: rotate(90deg); }

  .tool-badge {
    flex-shrink: 0;
    padding: 0.25rem 0.6rem;
    border-radius: 999px;
    background: rgba(34, 211, 238, 0.15);
    color: #22d3ee;
    font-size: 0.7rem;
    font-weight: 700;
    text-transform: uppercase;
    letter-spacing: 0.06em;
  }

  .tool-summary-text {
    display: flex;
    flex-direction: column;
    gap: 0.2rem;
    min-width: 0;
  }

  .block-tool .tool-name {
    font-size: 1rem;
    font-weight: 700;
    color: var(--text);
  }

  .block-tool .tool-args-preview {
    color: var(--text-muted);
    font-family: var(--mono);
    font-size: 0.78rem;
    font-weight: 400;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
    min-width: 0;
  }

  .block-tool-error { border-left-color: #ef4444; }
  .block-tool-error .tool-badge { background: rgba(239, 68, 68, 0.15); color: #ef4444; }

  .block-tool .block-body {
    padding: 0 1.1rem 1rem;
    border-top: 1px solid var(--border);
    /* Unlike a reasoning/content block, this wraps element children
       (labels + <pre>s), not raw text, so it must not inherit the base
       .block-body's white-space: pre-wrap — that would render the
       template source's own whitespace between those child tags as
       visible blank lines. */
    white-space: normal;
  }

  .block-tool .tool-section-label {
    font-size: 0.72rem;
    text-transform: uppercase;
    letter-spacing: 0.05em;
    color: var(--text-muted);
    font-weight: 600;
    margin: 0.6rem 0 0.25rem;
  }

  .block-tool pre {
    margin: 0;
    padding: 0;
    background: transparent;
    font-size: 0.8rem;
    color: #c4c4d0;
  }

  code {
    font-family: var(--mono);
    background: var(--bg-code);
    padding: 0.15rem 0.45rem;
    border-radius: 4px;
    font-size: 0.85em;
    color: #c4b5fd;
  }

  /* ── Job detail meta ────────────────────────── */
  .job-meta {
    display: flex;
    flex-wrap: wrap;
    gap: 1.5rem;
    margin-bottom: 1.5rem;
  }

  .job-meta-item {
    display: flex;
    flex-direction: column;
    gap: 0.15rem;
  }

  .job-meta-item .label {
    font-size: 0.75rem;
    text-transform: uppercase;
    letter-spacing: 0.05em;
    color: var(--text-muted);
    font-weight: 600;
  }

  .job-meta-item .value {
    font-size: 0.95rem;
  }

  .error-text {
    color: #ef4444;
  }

  /* ── Responsive ─────────────────────────────── */
  @media (max-width: 768px) {
    nav { padding: 0 1rem; }
    .container { padding: 1rem; }
    h1 { font-size: 1.5rem; }
    th, td { padding: 0.5rem 0.65rem; font-size: 0.82rem; }
    .info-grid { grid-template-columns: 1fr; }
    .job-meta { gap: 1rem; }
  }

  /* ── Scrollbar ──────────────────────────────── */
  ::-webkit-scrollbar { width: 8px; height: 8px; }
  ::-webkit-scrollbar-track { background: transparent; }
  ::-webkit-scrollbar-thumb {
    background: var(--border);
    border-radius: 4px;
  }
  ::-webkit-scrollbar-thumb:hover { background: #3a3a50; }
</style>
</head>
<body>
<nav>
  <a href="/" class="brand">
    <span class="logo">Z</span>
    zoo
  </a>
  <div class="links">
    <a href="/">Dashboard</a>
    <a href="/jobs">Jobs</a>
  </div>
</nav>
{{end}}

{{define "index"}}
{{template "layout_head" .}}
<div class="container">
  <div class="page-header">
    <h1>Dashboard</h1>
    <p>Overview of your zoo configuration and running agents.</p>
  </div>

  {{if .ActiveJobs}}
  <h2>Running Jobs</h2>
  <div class="job-cards">
    {{range .ActiveJobs}}
    <div class="job-card">
      <div class="job-card-header">
        <span class="badge badge-{{.Status}}">
          <span class="dot"></span>
          {{.Status}}
        </span>
        <a href="/jobs/{{.ID}}" class="job-card-link" title="View job details">→</a>
      </div>
      <div class="job-card-body">
        <h3 class="job-card-title">
          {{if .Title}}{{.Title}}{{else}}Issue #{{.IssueIndex}}{{end}}
        </h3>
        <p class="job-card-meta">
          <code>{{.Owner}}/{{.Repo}}#{{.IssueIndex}}</code>
        </p>
        <div class="job-card-agent">
          {{if .AvatarURL}}<img class="job-card-avatar" src="{{.AvatarURL}}" alt="{{.Agent}}" title="{{.Agent}}" loading="lazy">{{end}}
          <span class="job-card-agent-name">{{.Agent}}</span>
        </div>
      </div>
    </div>
    {{end}}
  </div>
  {{end}}

  <h2>LLMs</h2>
  <div class="table-wrap">
    <table>
      <thead><tr><th>Name</th><th>Endpoint</th><th>Model</th></tr></thead>
      <tbody>
        {{range .LLMs}}
        <tr>
          <td><strong>{{.Name}}</strong></td>
          <td><code>{{.OpenAI}}</code></td>
          <td>{{.Model}}</td>
        </tr>
        {{end}}
      </tbody>
    </table>
  </div>

  <h2>Agents</h2>
  <div class="table-wrap">
    <table>
      <thead><tr><th>Name</th><th>LLM</th></tr></thead>
      <tbody>
        {{range .Agents}}
        <tr>
          <td><strong>{{.Name}}</strong></td>
          <td>{{.LLM}}</td>
        </tr>
        {{end}}
      </tbody>
    </table>
  </div>

  <h2>Event Mappings</h2>
  <div class="table-wrap">
    <table>
      <thead><tr><th>Event</th><th>Agent</th><th>Instructions</th></tr></thead>
      <tbody>
        {{range .Events}}
        <tr>
          <td><code>{{.Kind}}</code></td>
          <td>{{if .Agent}}<strong>{{.Agent}}</strong>{{else}}<em style="color:var(--text-muted)">dynamic (assignee username)</em>{{end}}</td>
          <td>{{.Instructions}}</td>
        </tr>
        {{end}}
      </tbody>
    </table>
  </div>

  <h2>Environment</h2>
  <div class="info-grid">
    <div class="info-item">
      <span class="label">Docker Image</span>
      <span class="value"><code>{{.Environment.DockerImage}}</code></span>
    </div>
    <div class="info-item">
      <span class="label">Max Live Agents</span>
      <span class="value">{{.Environment.MaxLive}}</span>
    </div>
  </div>
</div>
</body>
</html>
{{end}}

{{define "jobs"}}
{{template "layout_head" .}}
<div class="container">
  <div class="page-header">
    <h1>Jobs</h1>
    <p>All agent runs and their current status.</p>
  </div>

  <div class="table-wrap">
    <table>
      <thead>
        <tr>
          <th>ID</th>
          <th>Status</th>
          <th>Event</th>
          <th>Agent</th>
          <th>Repository</th>
          <th>Created</th>
        </tr>
      </thead>
      <tbody>
        {{range .}}
        <tr>
          <td><a href="/jobs/{{.ID}}">{{.ID}}</a></td>
          <td>
            <span class="badge badge-{{.Status}}">
              <span class="dot"></span>
              {{.Status}}
            </span>
          </td>
          <td>{{.EventKind}}</td>
          <td>
            <span class="agent">
              {{if .AvatarURL}}<img class="agent-avatar" src="{{.AvatarURL}}" alt="{{.Agent}}" title="{{.Agent}}" loading="lazy">{{end}}
              <strong>{{.Agent}}</strong>
            </span>
          </td>
          <td><code>{{.Owner}}/{{.Repo}}#{{.IssueIndex}}</code></td>
          <td>{{.CreatedAt.Format "2006-01-02 15:04:05"}}</td>
        </tr>
        {{end}}
      </tbody>
    </table>
  </div>
</div>
</body>
</html>
{{end}}

{{define "job_detail"}}
{{template "layout_head" .}}
<div class="container">
  <div class="page-header">
    <h1>Job {{.Job.ID}}</h1>
    <p>Details and log output for this agent run.</p>
  </div>

  <div class="job-meta">
    <div class="job-meta-item">
      <span class="label">Status</span>
      <span class="value">
        <span class="badge badge-{{.Job.Status}}">
          <span class="dot"></span>
          {{.Job.Status}}
        </span>
      </span>
    </div>
    <div class="job-meta-item">
      <span class="label">Event</span>
      <span class="value">{{.Job.EventKind}} on <code>{{.Job.Owner}}/{{.Job.Repo}}#{{.Job.IssueIndex}}</code></span>
    </div>
    <div class="job-meta-item">
      <span class="label">Agent</span>
      <span class="value">
        <span class="agent">
          {{if .AvatarURL}}<img class="agent-avatar" src="{{.AvatarURL}}" alt="{{.Job.Agent}}" title="{{.Job.Agent}}">{{end}}
          <strong>{{.Job.Agent}}</strong>
        </span>
      </span>
    </div>
    {{if .Job.Error}}
    <div class="job-meta-item">
      <span class="label">Error</span>
      <span class="value error-text">{{.Job.Error}}</span>
    </div>
    {{end}}
  </div>

  <h2>Log</h2>
  <div class="log-wrap">
  <div class="log-container" id="log">
    {{range .Blocks}}
      {{if eq .Kind "reasoning"}}
      <div class="block block-reasoning">
        <div class="block-label">Thinking</div>
        <div class="block-body">{{.Text}}</div>
      </div>
      {{else if eq .Kind "content"}}
      <div class="block block-content">
        <div class="block-body">{{.Text}}</div>
      </div>
      {{else if eq .Kind "tool"}}
      <details class="block block-tool{{if .Tool.Error}} block-tool-error{{end}}">
        <summary>
          <span class="tool-badge">Tool</span>
          <span class="tool-summary-text">
            <span class="tool-name">🔧 {{.Tool.Name}}</span>
            <span class="tool-args-preview">{{.Tool.Arguments}}</span>
          </span>
        </summary>
        <div class="block-body">
          <div class="tool-section-label">Arguments</div>
          <pre>{{.Tool.Arguments}}</pre>
          <div class="tool-section-label">Result</div>
          <pre>{{.Tool.Result}}</pre>
        </div>
      </details>
      {{else}}
      <div class="block block-system">{{.Text}}</div>
      {{end}}
    {{end}}
  </div>
  {{if .Live}}
  <button type="button" class="log-jump" id="log-jump" hidden>↓ Latest</button>
  {{end}}
  </div>

  {{if .Live}}
  <script>
    (function() {
      var jobID = {{.Job.ID}};
      var log = document.getElementById("log");
      var jumpBtn = document.getElementById("log-jump");
      var reasoningBody = null;
      var contentBody = null;

      // The log box (not the window) is what scrolls, so all scroll
      // math is done against it. While the view is pinned to the
      // newest output we keep it there as the stream grows; the moment
      // the user scrolls up to read earlier output we stop, and the
      // jump button reappears so they can get back to the live tail.
      var stick = true;

      function atBottom() {
        return log.scrollHeight - log.scrollTop - log.clientHeight <= 80;
      }

      function follow() {
        if (stick) log.scrollTop = log.scrollHeight;
      }

      log.addEventListener("scroll", function() {
        stick = atBottom();
        jumpBtn.hidden = !stick;
      });

      jumpBtn.addEventListener("click", function() {
        stick = true;
        log.scrollTop = log.scrollHeight;
        jumpBtn.hidden = true;
      });

      // Opening a live job means spying on its tail: start at the
      // newest output.
      follow();

      function newBlock(kind, label) {
        var div = document.createElement("div");
        div.className = "block block-" + kind;
        if (label) {
          var l = document.createElement("div");
          l.className = "block-label";
          l.textContent = label;
          div.appendChild(l);
        }
        var body = document.createElement("div");
        body.className = "block-body";
        div.appendChild(body);
        log.appendChild(div);
        return body;
      }

      function newToolBlock(ev) {
        var details = document.createElement("details");
        details.className = "block block-tool" + (ev.error ? " block-tool-error" : "");

        var summary = document.createElement("summary");

        var badge = document.createElement("span");
        badge.className = "tool-badge";
        badge.textContent = "Tool";

        var text = document.createElement("span");
        text.className = "tool-summary-text";

        var name = document.createElement("span");
        name.className = "tool-name";
        name.textContent = "🔧 " + ev.name;

        var preview = document.createElement("span");
        preview.className = "tool-args-preview";
        preview.textContent = ev.arguments;

        text.appendChild(name);
        text.appendChild(preview);
        summary.appendChild(badge);
        summary.appendChild(text);
        details.appendChild(summary);

        var body = document.createElement("div");
        body.className = "block-body";

        var argsLabel = document.createElement("div");
        argsLabel.className = "tool-section-label";
        argsLabel.textContent = "Arguments";
        var argsPre = document.createElement("pre");
        argsPre.textContent = ev.arguments;

        var resultLabel = document.createElement("div");
        resultLabel.className = "tool-section-label";
        resultLabel.textContent = "Result";
        var resultPre = document.createElement("pre");
        resultPre.textContent = ev.result;

        body.appendChild(argsLabel);
        body.appendChild(argsPre);
        body.appendChild(resultLabel);
        body.appendChild(resultPre);
        details.appendChild(body);
        log.appendChild(details);
      }

      var es = new EventSource("/jobs/" + jobID + "/events");

      es.onmessage = function(e) {
        var ev = JSON.parse(e.data);

        switch (ev.type) {
          case "reasoning_start":
            reasoningBody = newBlock("reasoning", "Thinking");
            break;
          case "reasoning_delta":
            if (reasoningBody) reasoningBody.textContent += ev.text;
            break;
          case "reasoning_end":
            // Model output routinely starts/ends with newlines; drop them
            // so the finished block matches the static (trimmed) view.
            if (reasoningBody) reasoningBody.textContent = reasoningBody.textContent.trim();
            reasoningBody = null;
            break;
          case "content_start":
            contentBody = newBlock("content", null);
            break;
          case "content_delta":
            if (contentBody) contentBody.textContent += ev.text;
            break;
          case "content_end":
            if (contentBody) contentBody.textContent = contentBody.textContent.trim();
            contentBody = null;
            break;
          case "tool":
            newToolBlock(ev);
            break;
          case "system":
            newBlock("system", null).textContent = ev.text;
            break;
          case "status":
            es.close();
            location.reload();
            return;
        }

        follow();
      };
    })();
  </script>
  {{end}}
</div>
</body>
</html>
{{end}}
`

{"command":"cd /project && cat internal/agentrun/loop.go"}

package agentrun

import (
	"context"
	"fmt"
	"io"
	"strings"

	"github.com/abrander/zoo/internal/llm"
	"github.com/abrander/zoo/internal/tools"
)

// Hooks lets a caller observe a runLoop invocation live, as the model
// streams and tool calls execute, in addition to the final []llm.Message
// it returns. Any of these may be nil.
type Hooks struct {
	// OnReasoningDelta and OnContentDelta fire with just the newly
	// streamed text for the current turn, not the accumulated total.
	OnReasoningDelta func(delta string)
	OnContentDelta   func(delta string)

	// OnTurnEnd fires once per completed streamer round-trip, after the
	// model's message for that turn is fully received and before any of
	// its tool calls run.
	OnTurnEnd func()

	// OnTool fires once per tool call, after it has run.
	OnTool func(name, arguments, result string, toolErr bool)

	// OnReroll fires when a turn is thrown away because a tool call's
	// arguments couldn't be parsed, just before the model is asked
	// again. attempt counts from 1 and resets on every usable turn.
	OnReroll func(name, arguments string, attempt int)
}

// maxRerolls bounds how many times in a row a turn may be discarded for
// unparsable tool-call arguments before the run gives up. A model that
// keeps mangling the same call would otherwise resample until the run
// deadline, spending the whole timeout on nothing.
const maxRerolls = 3

// runLoop is a headless port of ../a's App.generate(): send messages +
// tool defs, get a completion, run any tool_calls and append their
// results, repeat until a plain finish or ctx is done.
func runLoop(ctx context.Context, client *llm.Client, toolsCtx tools.Context, messages []llm.Message, hooks Hooks) ([]llm.Message, error) {
	rerolls := 0

	for {
		if err := ctx.Err(); err != nil {
			return messages, err
		}

		streamer, err := client.StreamChatCompletion(ctx, &llm.ChatCompletionRequest{
			Messages: messages,
			Stream:   true,
			Tools:    tools.All(),
		})
		if err != nil {
			return messages, fmt.Errorf("chat completion: %w", err)
		}

		var completion *llm.ChatCompletion

		var prevContent, prevReasoning string

		for {
			c, err := streamer.Get()
			if err == io.EOF {
				break
			}

			if err != nil {
				return messages, fmt.Errorf("stream completion: %w", err)
			}

			completion = c

			if len(c.Choices) > 0 {
				msg := c.Choices[0].Message

				if hooks.OnReasoningDelta != nil && len(msg.ReasoningContent) > len(prevReasoning) {
					hooks.OnReasoningDelta(msg.ReasoningContent[len(prevReasoning):])
				}
				prevReasoning = msg.ReasoningContent

				if hooks.OnContentDelta != nil && len(msg.Content) > len(prevContent) {
					hooks.OnContentDelta(msg.Content[len(prevContent):])
				}
				prevContent = msg.Content
			}
		}

		if hooks.OnTurnEnd != nil {
			hooks.OnTurnEnd()
		}

		if completion == nil || len(completion.Choices) == 0 {
			return messages, fmt.Errorf("model returned an empty completion")
		}

		choice := completion.Choices[0]

		// Tool-call arguments have to be valid JSON before the turn can
		// enter the history: servers validate every assistant tool call we
		// send back, and reject the whole conversation with a 400 once one
		// of them doesn't parse, so a single bad call would fail every
		// following request and kill the run. Trailing junk after the
		// arguments object is dropped losslessly; anything we can't make
		// sense of makes the whole turn unusable.
		broken := brokenToolCall(choice.Message.ToolCalls)
		if broken != nil {
			// Throw the turn away wholesale, before running any of its
			// tool calls — a discarded turn must leave no side effects
			// behind, since no trace of it remains in the history. The
			// next request is then identical to this one, and (with no
			// seed pinned) samples afresh.
			rerolls++

			if rerolls > maxRerolls {
				return messages, fmt.Errorf("model called %s with arguments that are not valid JSON %d times in a row: %s",
					broken.Name, rerolls, truncate(broken.Arguments, 200))
			}

			if hooks.OnReroll != nil {
				hooks.OnReroll(broken.Name, truncate(broken.Arguments, 200), rerolls)
			}

			continue
		}

		rerolls = 0

		messages = append(messages, choice.Message)

		if choice.FinishReason != "tool_calls" || len(choice.Message.ToolCalls) == 0 {
			return messages, nil
		}

		for _, tc := range choice.Message.ToolCalls {
			if err := ctx.Err(); err != nil {
				return messages, err
			}

			result, err := tools.Call(toolsCtx, tc.FunctionCall)

			toolErr := err != nil
			if toolErr {
				result = fmt.Sprintf("ERROR CALLING TOOL: %s", err.Error())
			}

			if hooks.OnTool != nil {
				hooks.OnTool(tc.FunctionCall.Name, tc.FunctionCall.Arguments, result, toolErr)
			}

			messages = append(messages, llm.Message{
				Role:       "tool",
				Content:    result,
				ToolCallID: tc.Id,
				Name:       tc.FunctionCall.Name,
			})
		}
	}
}

// brokenToolCall repairs the arguments of every call in place and
// returns the first one that couldn't be repaired, or nil if the whole
// turn is usable. The returned call carries the model's original,
// unrepaired arguments.
func brokenToolCall(calls []llm.ToolCall) *llm.FunctionCall {
	for i := range calls {
		fcall := &calls[i].FunctionCall

		clean, ok := llm.SanitizeArguments(fcall.Arguments)
		if !ok {
			return &llm.FunctionCall{Name: fcall.Name, Arguments: fcall.Arguments}
		}

		fcall.Arguments = clean
	}

	return nil
}

// truncate shortens s to at most limit bytes, so a mangled tool call
// echoed back to the model can't flood the context.
func truncate(s string, limit int) string {
	if len(s) <= limit {
		return s
	}

	return strings.ToValidUTF8(s[:limit], "") + "…"
}

{"command":"cd /project && cat internal/agentrun/run.go"}

// Package agentrun creates the throwaway per-job environment an agent
// runs in: a Docker container with the agent's git working tree cloned
// inside it (authenticated with the agent's own Forgejo token), the
// triggering event written to /event, and the tool-calling loop
// (internal/llm + internal/tools) driven against it.
package agentrun

import (
	"context"
	_ "embed"
	"encoding/json"
	"fmt"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"

	"github.com/abrander/zoo/internal/config"
	"github.com/abrander/zoo/internal/forgejo"
	"github.com/abrander/zoo/internal/livelog"
	"github.com/abrander/zoo/internal/llm"
	"github.com/abrander/zoo/internal/store"
)

//go:embed system.md
var defaultSystemPrompt string

// DefaultTimeout bounds a single agent run's wall-clock time if the
// caller doesn't override it.
const DefaultTimeout = 120 * time.Minute

type Runner struct {
	docker        *dockerRuntime
	forgejo       *forgejo.Client
	store         *store.Store
	hub           *livelog.Hub
	cfg           *config.Config
	logger        *slog.Logger
	timeout       time.Duration
	keepOnFailure bool

	agentClientsMu sync.Mutex
	agentClients   map[string]*forgejo.Client
}

func NewRunner(cfg *config.Config, fg *forgejo.Client, st *store.Store, hub *livelog.Hub, logger *slog.Logger, timeout time.Duration, keepOnFailure bool) (*Runner, error) {
	docker, err := newDockerRuntime()
	if err != nil {
		return nil, err
	}

	if timeout <= 0 {
		timeout = DefaultTimeout
	}

	return &Runner{
		docker:        docker,
		forgejo:       fg,
		store:         st,
		hub:           hub,
		cfg:           cfg,
		logger:        logger,
		timeout:       timeout,
		keepOnFailure: keepOnFailure,
		agentClients:  make(map[string]*forgejo.Client),
	}, nil
}

// forgejoAs returns a Forgejo client that authenticates as the given
// agent (using the agent's own token from config). This lets each agent
// act as themselves on Forgejo without needing a global token with sudo
// privileges. Clients are built once per agent and cached, since
// constructing one costs an extra API round trip.
//
// If the agent has no token configured, falls back to the shared zoo
// identity so existing deployments without per-agent tokens still work.
func (r *Runner) forgejoAs(agentName, token string) *forgejo.Client {
	r.agentClientsMu.Lock()
	defer r.agentClientsMu.Unlock()

	if c, ok := r.agentClients[agentName]; ok {
		return c
	}

	var c *forgejo.Client
	if token != "" {
		c = r.forgejo.As(token)
	} else {
		// Fallback: use shared identity. Optionally log a warning
		// if we ever want to enforce per-agent tokens.
		c = r.forgejo
	}

	r.agentClients[agentName] = c

	return c
}

// Run implements scheduler.Runner.
func (r *Runner) Run(ctx context.Context, jobID string, agent config.AgentConfig, llmCfg config.LLM, dockerImage string, ev forgejo.Event) error {
	ctx, cancel := context.WithTimeout(ctx, r.timeout)
	defer cancel()

	logger := r.logger.With("job", jobID, "agent", agent.Name)

	repoInfo, err := r.forgejo.RepositoryInfo(ev.Owner, ev.Repo)
	if err != nil {
		return fmt.Errorf("look up repository: %w", err)
	}

	workDir, err := os.MkdirTemp("", "zoo-run-*")
	if err != nil {
		return fmt.Errorf("create work dir: %w", err)
	}

	succeeded := false

	defer func() {
		if succeeded || !r.keepOnFailure {
			os.RemoveAll(workDir)
		} else {
			logger.Warn("keeping work dir after failure", "dir", workDir)
		}
	}()

	// The container bind-mounts projectDir as /project and does the
	// initial clone into it, so the (empty) directory must exist on the
	// host before the container is created — otherwise Docker would
	// create it itself, root-owned.
	projectDir := filepath.Join(workDir, "project")

	if err := os.MkdirAll(projectDir, 0o755); err != nil {
		return fmt.Errorf("create project dir: %w", err)
	}

	// A pr:review run works on the PR's own head branch, so the agent's
	// commits push straight to the PR. Every other event kind branches
	// off the default branch as usual.
	var review *forgejo.ReviewDetail
	branch := fmt.Sprintf("issue-%d-%s", ev.Index, agent.Name)

	if ev.Kind == forgejo.EventPRReview {
		// Always fetch the current head ref, not just when the event
		// lacks one (the polling path doesn't carry it): the webhook's
		// copy could be stale if the PR's head branch was renamed since
		// the review, and the push target depends on it.
		headRef := ev.HeadRef

		if prInfo, err := r.forgejo.PullRequestInfo(ev.Owner, ev.Repo, ev.Index); err != nil {
			logger.Warn("fetch pull request head failed; falling back to the event's head ref", "error", err)
		} else if prInfo.HeadRef != "" {
			headRef = prInfo.HeadRef
		}

		if headRef == "" {
			return fmt.Errorf("pr:review event has no pull request head branch to check out")
		}

		branch = headRef

		// Fetch the full review (verdict, body, inline comments) so the
		// agent sees all the feedback, not just the triggering event. A
		// failure degrades to no review detail rather than failing the
		// run: the agent can still do its job, just without the inline
		// comments.
		review, err = r.forgejo.ReviewDetail(ev.Owner, ev.Repo, ev.Index, ev.ReviewID)
		if err != nil {
			logger.Warn("fetch review detail failed; agent will not see inline review comments", "error", err)
			review = nil
		}
	}

	roster := buildRoster(r.forgejo, r.cfg.Agents, logger)
	gitName, gitEmail := gitIdentity(agent.Name, roster)

	// The credential the sandbox's git uses for remote operations: the
	// agent's own Forgejo token when configured, so its git activity is
	// attributed to its own account, falling back to the shared zoo
	// identity for deployments without per-agent tokens (mirroring
	// forgejoAs).
	gitUser, gitToken := "zoo", r.forgejo.Token()

	if agent.Token != "" {
		gitUser, gitToken = agent.Name, agent.Token
	}

	eventPath := filepath.Join(workDir, "event.json")
	if err := os.WriteFile(eventPath, ev.Raw, 0o644); err != nil {
		return fmt.Errorf("write event file: %w", err)
	}

	containerID, err := r.docker.createContainer(ctx, dockerImage, []string{
		projectDir + ":/project",
		eventPath + ":/event:ro",
	}, fmt.Sprintf("zoo-issue-%d-%s", ev.Index, agent.Name))
	if err != nil {
		return fmt.Errorf("start container: %w", err)
	}

	defer func() {
		cleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 30*time.Second)
		defer cleanupCancel()
		if err := r.docker.remove(cleanupCtx, containerID); err != nil {
			logger.Warn("failed to remove container", "container", containerID, "error", err)
		}
	}()

	// Git must simply work inside the sandbox: safe.directory, commit
	// identity, and the remote credential all go into the container's
	// system gitconfig (see configureSandboxGit).
	if err := configureSandboxGit(ctx, r.docker, containerID, repoInfo.CloneURL, gitUser, gitToken, gitName, gitEmail); err != nil {
		return fmt.Errorf("configure git in container: %w", err)
	}

	// The initial clone happens inside the sandbox, so the working tree
	// is owned by the container's user and git never runs on the host.
	if ev.Kind == forgejo.EventPRReview {
		if err := clonePRHead(ctx, r.docker, containerID, repoInfo.CloneURL, repoInfo.DefaultBranch, branch, ev.Index); err != nil {
			return fmt.Errorf("prepare git working tree: %w", err)
		}
	} else {
		if err := cloneAndBranch(ctx, r.docker, containerID, repoInfo.CloneURL, repoInfo.DefaultBranch, branch); err != nil {
			return fmt.Errorf("prepare git working tree: %w", err)
		}
	}

	logAppend := func(stream, line string) {
		if err := r.store.AppendLog(context.Background(), jobID, stream, line); err != nil {
			logger.Warn("failed to append log", "error", err)
		}
	}

	runCtx := &runContext{
		docker:      r.docker,
		containerID: containerID,
		forgejo: &runForgejoActions{
			client: r.forgejoAs(agent.Name, agent.Token),
			owner:  ev.Owner,
			repo:   ev.Repo,
			index:  ev.Index,
			logger: logger,
		},
	}

	llmClient := llm.NewClient(llmCfg)

	systemPrompt := defaultSystemPrompt + identitySection(agent.Name, roster)

	instructions := r.cfg.EventInstructions(ev.Kind)

	// Fetch the full comment thread so the agent sees everything that's
	// been said on the issue/PR, not just the triggering event (which
	// only carries the latest comment, if any). A failure degrades to
	// no comments rather than failing the run: the agent can still do
	// its job, just without prior context.
	comments, err := r.forgejo.ListIssueComments(ev.Owner, ev.Repo, ev.Index)
	if err != nil {
		logger.Warn("fetch issue comments failed; agent will not see prior comments", "error", err)
		comments = nil
	}

	messages := []llm.Message{
		{Role: "system", Content: systemPrompt},
		{Role: "user", Content: seedMessage(ev, branch, repoInfo.DefaultBranch, instructions, comments, review)},
	}

	hooks := r.streamHooks(jobID, logAppend)

	_, err = runLoop(ctx, llmClient, runCtx, messages, hooks)
	if err != nil {
		return fmt.Errorf("agent loop: %w", err)
	}

	succeeded = true

	return nil
}

// streamHooks builds the Hooks a single Run passes to runLoop: every
// delta is published live to the hub for connected dashboard viewers,
// and once a reasoning/content block or tool call is complete, it's
// persisted to the store as one row and the hub's replay buffer for
// jobID is checkpointed — so a viewer connecting from this point on
// sees it via the persisted history instead of a live replay, and is
// never shown it twice.
func (r *Runner) streamHooks(jobID string, logAppend func(stream, line string)) Hooks {
	var reasoningBuf, contentBuf strings.Builder

	reasoningOpen, contentOpen := false, false

	return Hooks{
		OnReasoningDelta: func(delta string) {
			if !reasoningOpen {
				reasoningOpen = true
				reasoningBuf.Reset()
				r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningStart})
			}

			reasoningBuf.WriteString(delta)
			r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningDelta, Text: delta})
		},
		OnContentDelta: func(delta string) {
			if !contentOpen {
				contentOpen = true
				contentBuf.Reset()
				r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentStart})
			}

			contentBuf.WriteString(delta)
			r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentDelta, Text: delta})
		},
		OnTurnEnd: func() {
			if reasoningOpen {
				r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})
				logAppend("reasoning", reasoningBuf.String())
				r.hub.Checkpoint(jobID)
				reasoningOpen = false
			}

			if contentOpen {
				r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})
				logAppend("content", contentBuf.String())
				r.hub.Checkpoint(jobID)
				contentOpen = false
			}
		},
		OnReroll: func(name, arguments string, attempt int) {
			// A discarded turn leaves its reasoning/content already in
			// the log, so say why the next one repeats it.
			note := fmt.Sprintf("discarded turn %d/%d: %s was called with arguments that are not valid JSON, asking again: %s",
				attempt, maxRerolls, name, arguments)

			r.hub.Publish(jobID, livelog.Event{Type: livelog.System, Text: note})
			logAppend("system", note)
			r.hub.Checkpoint(jobID)
		},
		OnTool: func(name, arguments, result string, toolErr bool) {
			r.hub.Publish(jobID, livelog.Event{
				Type:      livelog.Tool,
				Name:      name,
				Arguments: arguments,
				Result:    result,
				Error:     toolErr,
			})

			line, err := json.Marshal(store.ToolLogEntry{Name: name, Arguments: arguments, Result: result, Error: toolErr})
			if err != nil {
				r.logger.Warn("failed to marshal tool log entry", "job", jobID, "error", err)
			} else {
				logAppend("tool", string(line))
			}

			r.hub.Checkpoint(jobID)
		},
	}
}

func seedMessage(ev forgejo.Event, branch, defaultBranch, instructions string, comments []forgejo.IssueComment, review *forgejo.ReviewDetail) string {
	raw, _ := json.MarshalIndent(json.RawMessage(ev.Raw), "", "  ")

	var instructionsSection string
	if instructions != "" {
		instructionsSection = fmt.Sprintf("Instructions for this event, from zoo.hcl:\n%s\n\n", instructions)
	}

	// A pr:review run works on the PR's own head branch, not a fresh
	// branch off the default branch.
	branchLine := fmt.Sprintf("Your working branch is %q, checked out from the default branch %q.\n\n", branch, defaultBranch)
	if ev.Kind == forgejo.EventPRReview {
		branchLine = fmt.Sprintf("Your working branch is %q, the pull request's head branch — commits you push here update the pull request directly.\n\n", branch)
	}

	var reviewSection string
	if review != nil {
		reviewSection = renderReviewSection(review)
	}

	var commentsSection string
	if len(comments) > 0 {
		var b strings.Builder
		fmt.Fprintf(&b, "Comments (%d):\n\n", len(comments))

		for i, c := range comments {
			fmt.Fprintf(&b, "%d. %s (%s):\n%s\n\n", i+1, c.Author, c.Created.Format(time.RFC3339), c.Body)
		}

		commentsSection = b.String()
	}

	return fmt.Sprintf(
		"You were triggered by a %q event on %s/%s.\n\n"+
			"%s%s"+
			"%sTitle: %s\n\nBody:\n%s\n\n%sFull event payload:\n```json\n%s\n```",
		ev.Kind, ev.Owner, ev.Repo, instructionsSection, branchLine, reviewSection, ev.Title, ev.Body, commentsSection, raw)
}

// renderReviewSection renders the submitted review as a briefing
// section: the verdict, the review body, and each inline comment with
// its location and id (the id lets the agent refer to a specific
// comment in its reply).
func renderReviewSection(review *forgejo.ReviewDetail) string {
	var b strings.Builder

	fmt.Fprintf(&b, "Review submitted by %s:\n", review.Reviewer)
	fmt.Fprintf(&b, "  Verdict: %s\n", humanReviewState(review.State))

	if review.Body != "" {
		b.WriteString("  Review body:\n")
		for _, line := range strings.Split(review.Body, "\n") {
			fmt.Fprintf(&b, "  %s\n", line)
		}
	}

	if len(review.Comments) > 0 {
		fmt.Fprintf(&b, "  Inline comments (%d):\n", len(review.Comments))

		for i, c := range review.Comments {
			where := c.Path
			if c.Line > 0 {
				where = fmt.Sprintf("%s:%d", c.Path, c.Line)
			}

			fmt.Fprintf(&b, "  %d. [%s] %s (comment id %d):\n", i+1, where, c.Author, c.ID)
			for _, line := range strings.Split(c.Body, "\n") {
				fmt.Fprintf(&b, "     %s\n", line)
			}
		}
	}

	return b.String() + "\n"
}

// humanReviewState maps a Forgejo review state to a readable verdict.
func humanReviewState(state string) string {
	switch state {
	case "APPROVED":
		return "approved"
	case "REQUEST_CHANGES":
		return "changes requested"
	case "COMMENT":
		return "comment"
	default:
		return state
	}
}

{"command":"cd /project && cat internal/llm/types.go"}

// Package llm is an OpenAI-compatible chat completions client with
// streaming and tool-call support, ported from ../a's llamacpp package.
package llm

import "fmt"

type Message struct {
	Content          string     `json:"content"`
	Role             string     `json:"role"`
	ReasoningContent string     `json:"reasoning_content,omitempty"`
	ToolCalls        []ToolCall `json:"tool_calls,omitempty"`
	ToolCallID       string     `json:"tool_call_id,omitempty"`
	Name             string     `json:"name,omitempty"`
}

func (m *Message) String() string {
	str := fmt.Sprintf("Role: %s, Content: %s ReasoningContent: %s", m.Role, m.Content, m.ReasoningContent)

	for _, call := range m.ToolCalls {
		str += fmt.Sprintf("\n  ToolCall: %s", call.String())
	}

	return str
}

// Merge folds a streamed delta into the accumulated message.
func (m *Message) Merge(next *Message) {
	m.Content += next.Content

	if next.Role != "" {
		m.Role = next.Role
	}

	m.ReasoningContent += next.ReasoningContent

	minLength := 0
	for _, choice := range next.ToolCalls {
		if choice.Index+1 > minLength {
			minLength = choice.Index + 1
		}
	}

	if len(m.ToolCalls) < minLength {
		newToolCalls := make([]ToolCall, minLength)
		copy(newToolCalls, m.ToolCalls)
		m.ToolCalls = newToolCalls
	}

	for _, nextChoice := range next.ToolCalls {
		m.ToolCalls[nextChoice.Index].Merge(&nextChoice)
	}
}

type FunctionCall struct {
	Name      string `json:"name"`
	Arguments string `json:"arguments"`
}

type ToolCall struct {
	Type         string       `json:"type"`
	Id           string       `json:"id"`
	Index        int          `json:"index"`
	Name         string       `json:"name"`
	FunctionCall FunctionCall `json:"function"`
}

func (t *ToolCall) String() string {
	return fmt.Sprintf("Type: %s, Id: %s, Index: %d, Name: %s, FunctionCall: {Name: %s, Arguments: %s}",
		t.Type, t.Id, t.Index, t.Name, t.FunctionCall.Name, t.FunctionCall.Arguments)
}

func (t *ToolCall) Merge(next *ToolCall) {
	if next.Type != "" {
		t.Type = next.Type
	}

	if next.Id != "" {
		t.Id = next.Id
	}

	if next.Name != "" {
		t.Name = next.Name
	}

	t.Index = next.Index

	if next.FunctionCall.Name != "" {
		t.FunctionCall.Name = next.FunctionCall.Name
	}

	t.FunctionCall.Arguments += next.FunctionCall.Arguments
}

type Property struct {
	Type        string    `json:"type"`
	Description string    `json:"description,omitempty"`
	Enum        []string  `json:"enum,omitempty"`
	Items       *Property `json:"items,omitempty"`
}

type Parameters struct {
	Type       string              `json:"type"` // always "object"
	Properties map[string]Property `json:"properties"`
	Required   []string            `json:"required,omitempty"`
}

type Function struct {
	Name        string     `json:"name"`
	Description string     `json:"description,omitempty"`
	Parameters  Parameters `json:"parameters,omitempty"`
	Strict      bool       `json:"strict"`
}

type Tool struct {
	Type     string   `json:"type"`
	Function Function `json:"function"`
}

func NewTool(name, description string) Tool {
	return Tool{
		Type: "function",
		Function: Function{
			Name:        name,
			Description: description,
			Strict:      true,
			// Servers validate parameters against the JSON Schema
			// metaschema, which rejects a missing or empty type,
			// and an object schema without properties.
			Parameters: Parameters{
				Type:       "object",
				Properties: map[string]Property{},
			},
		},
	}
}

func (t *Tool) AddProperty(name string, property Property, required bool) *Tool {
	if t.Function.Parameters.Properties == nil {
		t.Function.Parameters.Properties = make(map[string]Property)
	}

	if _, exists := t.Function.Parameters.Properties[name]; exists {
		panic("property already exists: " + name)
	}

	t.Function.Parameters.Properties[name] = property

	if required {
		t.Function.Parameters.Required = append(t.Function.Parameters.Required, name)
	}

	return t
}

func (t *Tool) AddStringProperty(name, description string, required bool) *Tool {
	return t.AddProperty(name, Property{Type: "string", Description: description}, required)
}

func (t *Tool) AddBooleanProperty(name, description string, required bool) *Tool {
	return t.AddProperty(name, Property{Type: "boolean", Description: description}, required)
}

func (t *Tool) AddIntegerProperty(name, description string, required bool) *Tool {
	return t.AddProperty(name, Property{Type: "integer", Description: description}, required)
}

func (t *Tool) AddEnumProperty(name, description string, values []string, required bool) *Tool {
	return t.AddProperty(name, Property{Type: "string", Description: description, Enum: values}, required)
}

func (t *Tool) AddArrayProperty(name, itemType, description string, required bool) *Tool {
	return t.AddProperty(name, Property{
		Type:        "array",
		Description: description,
		Items:       &Property{Type: itemType},
	}, required)
}

func (t *Tool) AddStringArrayProperty(name, description string, required bool) *Tool {
	return t.AddArrayProperty(name, "string", description, required)
}

type ChatCompletionRequest struct {
	Model       string    `json:"model"`
	Messages    []Message `json:"messages,omitempty"`
	Stream      bool      `json:"stream"`
	Tools       []Tool    `json:"tools,omitempty"`
	Seed        int       `json:"seed,omitempty"`
	Temperature float64   `json:"temperature,omitempty"`
	TopP        float64   `json:"top_p,omitempty"`
}

type Choice struct {
	Delta        Message `json:"delta"`
	FinishReason string  `json:"finish_reason,omitempty"`
	Index        int     `json:"index"`
	Message      Message `json:"message"`
	Role         string  `json:"role"`
}

func (c *Choice) String() string {
	return fmt.Sprintf("Index: %d, Role: %s, FinishReason: %v, Delta: %s, Message: %s",
		c.Index, c.Role, c.FinishReason, c.Delta.String(), c.Message.String())
}

func (c *Choice) Merge(next *Choice) {
	c.Message.Merge(&next.Delta)

	if next.FinishReason != "" {
		c.FinishReason = next.FinishReason
	}

	if next.Role != "" {
		c.Role = next.Role
	}
}

// Timings mirrors llama.cpp's /chat/completions timing block. The
// streamer tolerates unknown fields, so extra fields from the server
// are simply ignored.
type Timings struct {
	CacheN              int     `json:"cache_n"`
	DraftN              int     `json:"draft_n"`
	DraftNAccepted      int     `json:"draft_n_accepted"`
	PromptN             int     `json:"prompt_n"`
	PromptMs            float64 `json:"prompt_ms"`
	PromptPerTokenMs    float64 `json:"prompt_per_token_ms"`
	PromptPerSecond     float64 `json:"prompt_per_second"`
	PredictedN          int     `json:"predicted_n"`
	PredictedMs         float64 `json:"predicted_ms"`
	PredictedPerTokenMs float64 `json:"predicted_per_token_ms"`
	PredictedPerSecond  float64 `json:"predicted_per_second"`
}

type ChatCompletion struct {
	Choices           []Choice `json:"choices"`
	Created           int64    `json:"created"`
	Id                string   `json:"id"`
	Model             string   `json:"model"`
	SystemFingerprint string   `json:"system_fingerprint"`
	Object            string   `json:"object"`
	Timings           Timings  `json:"timings"`
}

func (c *ChatCompletion) String() string {
	s := fmt.Sprintf("Id: %s, Model: %s, Created: %d, SystemFingerprint: %s, Object: %s\n",
		c.Id, c.Model, c.Created, c.SystemFingerprint, c.Object)

	for _, choice := range c.Choices {
		s += fmt.Sprintf("  Choice: %s\n", choice.String())
	}

	return s
}

// Merge folds a streamed chunk into the accumulated completion.
func (c *ChatCompletion) Merge(next *ChatCompletion) {
	minLength := 0
	for _, choice := range next.Choices {
		if choice.Index+1 > minLength {
			minLength = choice.Index + 1
		}
	}

	if len(c.Choices) < minLength {
		newChoices := make([]Choice, minLength)
		copy(newChoices, c.Choices)
		c.Choices = newChoices
	}

	for _, nextChoice := range next.Choices {
		c.Choices[nextChoice.Index].Merge(&nextChoice)
	}

	c.Timings = next.Timings
}

{"command":"cd /project && cat internal/web/web_test.go"}

package web

import (
	"context"
	"fmt"
	"net/http"
	"net/http/httptest"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"github.com/abrander/zoo/internal/config"
	"github.com/abrander/zoo/internal/forgejo"
	"github.com/abrander/zoo/internal/livelog"
	"github.com/abrander/zoo/internal/store"
)

func testServer(t *testing.T) (*Server, *store.Store) {
	t.Helper()

	st, err := store.Open(filepath.Join(t.TempDir(), "zoo.db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { st.Close() })

	cfg := &config.Config{
		LLMs:        []config.LLM{{Name: "qwen", OpenAI: "https://example.com", Model: "qwen3"}},
		Agents:      []config.Agent{{Name: "leon", LLM: "qwen"}},
		Events:      []config.Event{{Kind: config.EventIssueNew, Agent: "leon"}},
		Environment: config.Environment{DockerImage: "debian:unstable", MaxLive: 2},
	}

	// No Forgejo client: pages render without avatars.
	return New(cfg, st, livelog.NewHub(), nil), st
}

func TestIndexRenders(t *testing.T) {
	s, _ := testServer(t)

	rr := httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/", nil))

	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
	}
	if !strings.Contains(rr.Body.String(), "leon") {
		t.Fatalf("expected agent name in output, got %s", rr.Body.String())
	}
}

func TestJobsAndDetail(t *testing.T) {
	s, st := testServer(t)
	ctx := context.Background()

	if err := st.CreateJob(ctx, store.Job{ID: "job-1", EventKind: "issue:new", Agent: "leon", Owner: "acme", Repo: "widgets", IssueIndex: 1}); err != nil {
		t.Fatal(err)
	}
	if err := st.AppendLog(ctx, "job-1", "stdout", "hello"); err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs", nil))
	if rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), "job-1") {
		t.Fatalf("unexpected jobs page: %d %s", rr.Code, rr.Body.String())
	}

	rr = httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs/job-1", nil))
	if rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), "hello") {
		t.Fatalf("unexpected job detail page: %d %s", rr.Code, rr.Body.String())
	}

	// job-1 was never marked started/finished, so it's still "live":
	// hitting /events should stream whatever's currently buffered in the
	// hub (not yet checkpointed/persisted) and then wait for more, until
	// the request context is done.
	s.hub.Publish("job-1", livelog.Event{Type: livelog.ContentDelta, Text: "streaming"})

	evCtx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
	defer cancel()

	rr = httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs/job-1/events", nil).WithContext(evCtx))
	if rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), "streaming") {
		t.Fatalf("unexpected events response: %d %s", rr.Code, rr.Body.String())
	}

	// A finished job isn't live: /events should return immediately with
	// nothing to stream, so the client falls back to the static page.
	if err := st.CreateJob(ctx, store.Job{ID: "job-2", EventKind: "issue:new", Agent: "leon", Owner: "acme", Repo: "widgets", IssueIndex: 2}); err != nil {
		t.Fatal(err)
	}
	if err := st.MarkJobFinished(ctx, "job-2", store.JobSucceeded, ""); err != nil {
		t.Fatal(err)
	}

	rr = httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs/job-2/events", nil))
	if rr.Code != http.StatusOK || rr.Body.Len() != 0 {
		t.Fatalf("expected empty response for a non-live job, got %d %q", rr.Code, rr.Body.String())
	}
}

// TestJobDetailTrimsBlockWhitespace verifies that reasoning/content
// blocks are rendered without the leading/trailing newlines the model
// routinely emits: the block body uses white-space: pre-wrap, so those
// would show up as visible blank lines inflating the block's height
// (issue #53). Internal newlines must be preserved.
func TestJobDetailTrimsBlockWhitespace(t *testing.T) {
	s, st := testServer(t)
	ctx := context.Background()

	if err := st.CreateJob(ctx, store.Job{ID: "job-1", EventKind: "issue:new", Agent: "leon", Owner: "acme", Repo: "widgets", IssueIndex: 1}); err != nil {
		t.Fatal(err)
	}
	if err := st.MarkJobFinished(ctx, "job-1", store.JobSucceeded, ""); err != nil {
		t.Fatal(err)
	}
	if err := st.AppendLog(ctx, "job-1", "content", "\nNow the remaining tool callers:\n\n\n"); err != nil {
		t.Fatal(err)
	}
	// A block that is nothing but whitespace should not render at all.
	if err := st.AppendLog(ctx, "job-1", "content", "   \n\t  "); err != nil {
		t.Fatal(err)
	}
	if err := st.AppendLog(ctx, "job-1", "reasoning", "  \ninner\nlines\nkept\n  "); err != nil {
		t.Fatal(err)
	}

	r := httptest.NewRecorder()
	s.Handler().ServeHTTP(r, httptest.NewRequest(http.MethodGet, "/jobs/job-1", nil))
	if r.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", r.Code, r.Body.String())
	}

	body := r.Body.String()
	if !strings.Contains(body, `<div class="block-body">Now the remaining tool callers:</div>`) {
		t.Fatalf("expected trimmed content block, got: %s", body)
	}
	if strings.Contains(body, "<div class=\"block-body\">\n") {
		t.Fatalf("block body still starts with a newline: %s", body)
	}
	if got := strings.Count(body, `class="block block-content"`); got != 1 {
		t.Fatalf("expected exactly one content block (whitespace-only one dropped), got %d: %s", got, body)
	}
	if !strings.Contains(body, "inner\nlines\nkept") {
		t.Fatalf("expected internal newlines to be preserved, got: %s", body)
	}
}

// TestJobDetailAutoScroll verifies the live job detail page ships the
// tail-following controls (issue #57): the log box is wrapped so the
// jump-to-bottom button can float over it, and the streaming script does
// its scroll math against the log container (the actual scrollable
// element) instead of the window. A finished job is static and must not
// carry either the button or the streaming script.
func TestJobDetailAutoScroll(t *testing.T) {
	s, st := testServer(t)
	ctx := context.Background()

	if err := st.CreateJob(ctx, store.Job{ID: "job-1", EventKind: "issue:new", Agent: "leon", Owner: "acme", Repo: "widgets", IssueIndex: 1}); err != nil {
		t.Fatal(err)
	}

	r := httptest.NewRecorder()
	s.Handler().ServeHTTP(r, httptest.NewRequest(http.MethodGet, "/jobs/job-1", nil))
	if r.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", r.Code, r.Body.String())
	}

	body := r.Body.String()
	for _, want := range []string{
		`class="log-wrap"`,
		`id="log-jump"`,
		`log.scrollHeight - log.scrollTop - log.clientHeight`,
		`log.scrollTop = log.scrollHeight`,
	} {
		if !strings.Contains(body, want) {
			t.Fatalf("expected %q in live job detail page, got:\n%s", want, body)
		}
	}
	// The old window-based scroll math must be gone: it never worked,
	// because the log box (not the window) is what scrolls.
	for _, gone := range []string{
		"window.scrollY",
		"window.scrollTo",
	} {
		if strings.Contains(body, gone) {
			t.Fatalf("live job detail page still uses window scroll math %q:\n%s", gone, body)
		}
	}

	// A finished job is static: no jump button, no streaming script.
	if err := st.MarkJobFinished(ctx, "job-1", store.JobSucceeded, ""); err != nil {
		t.Fatal(err)
	}

	r = httptest.NewRecorder()
	s.Handler().ServeHTTP(r, httptest.NewRequest(http.MethodGet, "/jobs/job-1", nil))
	if r.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", r.Code, r.Body.String())
	}
	if b := r.Body.String(); strings.Contains(b, `id="log-jump"`) || strings.Contains(b, "EventSource") {
		t.Fatalf("finished job detail page should not carry live streaming controls:\n%s", b)
	}
}

func TestAuthGate(t *testing.T) {
	st, err := store.Open(filepath.Join(t.TempDir(), "zoo.db"))
	if err != nil {
		t.Fatal(err)
	}
	defer st.Close()

	cfg := &config.Config{Web: &config.Web{Token: "secret"}}
	s := New(cfg, st, livelog.NewHub(), nil)

	rr := httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs", nil))
	if rr.Code != http.StatusUnauthorized {
		t.Fatalf("expected 401 without token, got %d", rr.Code)
	}

	req := httptest.NewRequest(http.MethodGet, "/jobs", nil)
	req.Header.Set("Authorization", "Bearer secret")
	rr = httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, req)
	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200 with correct token, got %d", rr.Code)
	}
}

// TestJobsShowAgentAvatars verifies the jobs pages render each agent's
// Forgejo avatar, and that an unresolvable avatar (unknown user) degrades
// to no image instead of breaking the page.
func TestJobsShowAgentAvatars(t *testing.T) {
	// Minimal in-test Forgejo API: the version probe the SDK makes when
	// the client is constructed, plus per-user profile lookups.
	avatars := map[string]string{
		"leon": "https://forgejo.example/avatars/leon",
	}

	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == "/api/v1/version" {
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprint(w, `{"version":"1.23.0"}`)

			return
		}

		if user, ok := strings.CutPrefix(r.URL.Path, "/api/v1/users/"); ok {
			if url, ok := avatars[user]; ok {
				w.Header().Set("Content-Type", "application/json")
				fmt.Fprintf(w, `{"login_name":%q,"avatar_url":%q}`, user, url)

				return
			}
		}

		http.NotFound(w, r)
	}))
	t.Cleanup(api.Close)

	fg, err := forgejo.NewClient(config.Forgejo{URL: api.URL, Token: "test"})
	if err != nil {
		t.Fatal(err)
	}

	st, err := store.Open(filepath.Join(t.TempDir(), "zoo.db"))
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { st.Close() })

	s := New(&config.Config{}, st, livelog.NewHub(), fg)

	ctx := context.Background()

	if err := st.CreateJob(ctx, store.Job{ID: "job-1", EventKind: "issue:new", Agent: "leon", Owner: "acme", Repo: "widgets", IssueIndex: 1}); err != nil {
		t.Fatal(err)
	}
	// "ghost" doesn't exist on the mock Forgejo: the page must still
	// render, just without an avatar for that job.
	if err := st.CreateJob(ctx, store.Job{ID: "job-2", EventKind: "issue:new", Agent: "ghost", Owner: "acme", Repo: "widgets", IssueIndex: 2}); err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs", nil))
	if rr.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
	}

	body := rr.Body.String()
	if !strings.Contains(body, `src="https://forgejo.example/avatars/leon"`) {
		t.Fatalf("expected leon's avatar on the jobs page, got: %s", body)
	}
	if !strings.Contains(body, "job-2") {
		t.Fatalf("expected the unknown-agent job to still render, got: %s", body)
	}

	rr = httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs/job-1", nil))
	if rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), `src="https://forgejo.example/avatars/leon"`) {
		t.Fatalf("expected leon's avatar on the job detail page, got %d: %s", rr.Code, rr.Body.String())
	}
}

{"command":"cd /project && ls -la internal/agentrun/ && echo \"=== loop_test.go (head) ===\" && head -60 internal/agentrun/loop_test.go"}

total 100
drwxr-xr-x  2 user user  4096 Aug 26 11:11 .
drwxr-xr-x 11 user user  4096 Aug 26 11:11 ..
-rw-r--r--  1 user user  1026 Aug 26 11:11 context.go
-rw-r--r--  1 user user  5163 Aug 26 11:11 docker.go
-rw-r--r--  1 user user  9325 Aug 26 11:11 docker_integration_test.go
-rw-r--r--  1 user user  2752 Aug 26 11:11 forgejo.go
-rw-r--r--  1 user user  5691 Aug 26 11:11 loop.go
-rw-r--r--  1 user user  6922 Aug 26 11:11 loop_test.go
-rw-r--r--  1 user user  2999 Aug 26 11:11 roster.go
-rw-r--r--  1 user user  2203 Aug 26 11:11 roster_test.go
-rw-r--r--  1 user user 14505 Aug 26 11:11 run.go
-rw-r--r--  1 user user  6600 Aug 26 11:11 sandboxgit.go
-rw-r--r--  1 user user  2232 Aug 26 11:11 sandboxgit_test.go
-rw-r--r--  1 user user  4333 Aug 26 11:11 seed_test.go
-rw-r--r--  1 user user  2284 Aug 26 11:11 system.md
=== loop_test.go (head) ===
package agentrun

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"reflect"
	"strings"
	"testing"

	"github.com/abrander/zoo/internal/config"
	"github.com/abrander/zoo/internal/llm"
	"github.com/abrander/zoo/internal/tools"
)

// fakeToolsContext is enough for tools that only shell out.
type fakeToolsContext struct{}

func (fakeToolsContext) Exec(context.Context, string) (string, string, error) {
	return "hi\n", "", nil
}

func (fakeToolsContext) Forgejo() tools.ForgejoActions { return nil }

func sseChunk(t *testing.T, choice llm.Choice) string {
	t.Helper()

	body, err := json.Marshal(llm.ChatCompletion{Choices: []llm.Choice{choice}})
	if err != nil {
		t.Fatal(err)
	}

	return "data: " + string(body) + "\n\n"
}

// sseServer serves one canned SSE response per request, and rejects any
// history containing a tool call whose arguments aren't valid JSON —
// the server-side validation that produced the 400 in production.
func sseServer(t *testing.T, turns []string, requests *[]llm.ChatCompletionRequest) *httptest.Server {
	t.Helper()

	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var req llm.ChatCompletionRequest
		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			t.Errorf("decode request: %v", err)
		}

		for _, msg := range req.Messages {
			for _, tc := range msg.ToolCalls {
				var obj map[string]any
				if err := json.Unmarshal([]byte(tc.FunctionCall.Arguments), &obj); err != nil {
					http.Error(w, fmt.Sprintf("tool call function.arguments must be valid JSON: %q", tc.FunctionCall.Arguments), http.StatusBadRequest)

					return
				}
			}
		}

{"command":"cd /project && sed -n 60,220p internal/agentrun/loop_test.go"}

		turn := len(*requests)
		*requests = append(*requests, req)

		if turn >= len(turns) {
			t.Errorf("unexpected request %d", turn)
			http.Error(w, "too many requests", http.StatusInternalServerError)

			return
		}

		w.Header().Set("Content-Type", "text/event-stream")
		fmt.Fprint(w, turns[turn])
	}))
}

func toolCallTurn(t *testing.T, calls ...llm.ToolCall) string {
	t.Helper()

	return sseChunk(t, llm.Choice{
		Delta:        llm.Message{Role: "assistant", ToolCalls: calls},
		FinishReason: "tool_calls",
	}) + "data: [DONE]\n\n"
}

func doneTurn(t *testing.T) string {
	t.Helper()

	return sseChunk(t, llm.Choice{
		Delta:        llm.Message{Role: "assistant", Content: "done"},
		FinishReason: "stop",
	}) + "data: [DONE]\n\n"
}

// brokenCall is the shape that killed job 6a36c082: the model leaked
// chat-template markup where the arguments object should have been.
func brokenCall() llm.ToolCall {
	return llm.ToolCall{
		Index: 1, Id: "call-2", Type: "function",
		FunctionCall: llm.FunctionCall{Name: "grep_search", Arguments: "</parameter>\nmax_results>30"},
	}
}

func bashCall() llm.ToolCall {
	// A stray trailing brace: repairable without guessing.
	return llm.ToolCall{
		Index: 0, Id: "call-1", Type: "function",
		FunctionCall: llm.FunctionCall{Name: "bash", Arguments: `{"command": "echo hi"}}`},
	}
}

// A repairable turn runs as normal, and the arguments that reach both
// the tool and the history are valid JSON.
func TestRunLoopRepairsTrailingJunkInToolArguments(t *testing.T) {
	var requests []llm.ChatCompletionRequest

	srv := sseServer(t, []string{toolCallTurn(t, bashCall()), doneTurn(t)}, &requests)
	defer srv.Close()

	var called []string

	messages, err := runLoop(context.Background(), llm.NewClient(config.LLM{OpenAI: srv.URL, Model: "test"}),
		fakeToolsContext{}, []llm.Message{{Role: "user", Content: "go"}}, Hooks{
			OnTool: func(name, arguments, result string, _ bool) {
				called = append(called, name+" "+arguments+" -> "+result)
			},
			OnReroll: func(string, string, int) {
				t.Error("a repairable turn must not be discarded")
			},
		})
	if err != nil {
		t.Fatalf("runLoop: %v", err)
	}

	if len(called) != 1 || called[0] != `bash {"command":"echo hi"} -> hi`+"\n" {
		t.Fatalf("tool calls = %q", called)
	}

	if got := messages[len(messages)-1].Content; got != "done" {
		t.Errorf("final message = %q, want %q", got, "done")
	}
}

// An unparsable tool call takes its whole turn with it: nothing runs,
// nothing is recorded, and the retry request is identical to the first.
func TestRunLoopRerollsTurnWithBrokenToolCall(t *testing.T) {
	var requests []llm.ChatCompletionRequest

	// The broken call shares a turn with a perfectly good one, which
	// must not run: the turn it belongs to never reaches the history.
	srv := sseServer(t, []string{
		toolCallTurn(t, bashCall(), brokenCall()),
		doneTurn(t),
	}, &requests)
	defer srv.Close()

	var called []string

	var rerolls []string

	messages, err := runLoop(context.Background(), llm.NewClient(config.LLM{OpenAI: srv.URL, Model: "test"}),
		fakeToolsContext{}, []llm.Message{{Role: "user", Content: "go"}}, Hooks{
			OnTool: func(name, _, _ string, _ bool) {
				called = append(called, name)
			},
			OnReroll: func(name, arguments string, attempt int) {
				rerolls = append(rerolls, fmt.Sprintf("%d %s %s", attempt, name, arguments))
			},
		})
	if err != nil {
		t.Fatalf("runLoop: %v", err)
	}

	if len(called) != 0 {
		t.Errorf("discarded turn ran tools: %q", called)
	}

	want := []string{"1 grep_search </parameter>\nmax_results>30"}
	if !reflect.DeepEqual(rerolls, want) {
		t.Errorf("rerolls = %q, want %q", rerolls, want)
	}

	if len(requests) != 2 {
		t.Fatalf("expected 2 requests, got %d", len(requests))
	}

	// The discarded turn left no trace, so the retry asks exactly the
	// same question — which is only useful because no seed is pinned.
	if !reflect.DeepEqual(requests[0].Messages, requests[1].Messages) {
		t.Errorf("retry history differs:\n%+v\n%+v", requests[0].Messages, requests[1].Messages)
	}

	if requests[1].Seed != 0 {
		t.Errorf("request pins seed %d; rerolling can't resample", requests[1].Seed)
	}

	if got := messages[len(messages)-1].Content; got != "done" {
		t.Errorf("final message = %q, want %q", got, "done")
	}
}

// A model that keeps mangling the same call must not burn the whole run
// deadline on it.
func TestRunLoopGivesUpAfterMaxRerolls(t *testing.T) {
	turns := make([]string, maxRerolls+1)
	for i := range turns {
		turns[i] = toolCallTurn(t, brokenCall())
	}

	var requests []llm.ChatCompletionRequest

	srv := sseServer(t, turns, &requests)
	defer srv.Close()

	_, err := runLoop(context.Background(), llm.NewClient(config.LLM{OpenAI: srv.URL, Model: "test"}),
		fakeToolsContext{}, []llm.Message{{Role: "user", Content: "go"}}, Hooks{})
	if err == nil {
		t.Fatal("expected an error once the rerolls are exhausted")
	}

	if !strings.Contains(err.Error(), "grep_search") || !strings.Contains(err.Error(), "not valid JSON") {

{"command":"cd /project && grep -n \"func (s \\*Store)\" internal/store/store.go && echo \"=== AppendLog/TailLogs ===\" && sed -n '/func (s \\*Store) AppendLog/,/^}/p' internal/store/store.go && sed -n '/func (s \\*Store) TailLogs/,/^}/p' internal/store/store.go"}

43:func (s *Store) Close() error {
50:func (s *Store) MarkSeen(ctx context.Context, id string) (isNew bool, err error) {
75:func (s *Store) SyncAssignees(ctx context.Context, issueID int64, assignees []string) (added []string, err error) {
147:func (s *Store) GetWatermark(ctx context.Context, key string) (string, error) {
162:func (s *Store) SetWatermark(ctx context.Context, key, value string) error {
200:func (s *Store) CreateJob(ctx context.Context, j Job) error {
226:func (s *Store) ReapOrphanedJobs(ctx context.Context) (int64, error) {
243:func (s *Store) MarkJobStarted(ctx context.Context, id string) error {
256:func (s *Store) MarkJobFinished(ctx context.Context, id string, status JobStatus, errMsg string) error {
268:func (s *Store) GetJob(ctx context.Context, id string) (Job, error) {
284:func (s *Store) ListJobs(ctx context.Context, limit int) ([]Job, error) {
327:func (s *Store) AppendLog(ctx context.Context, jobID, stream, line string) error {
340:func (s *Store) TailLogs(ctx context.Context, jobID string, afterSeq int64) ([]LogLine, error) {
=== AppendLog/TailLogs ===
func (s *Store) AppendLog(ctx context.Context, jobID, stream, line string) error {
	_, err := s.db.ExecContext(ctx,
		`INSERT INTO job_logs (job_id, seq, stream, line, ts)
		 VALUES (?, COALESCE((SELECT MAX(seq) + 1 FROM job_logs WHERE job_id = ?), 0), ?, ?, ?)`,
		jobID, jobID, stream, line, time.Now().UTC())
	if err != nil {
		return fmt.Errorf("append log: %w", err)
	}

	return nil
}
func (s *Store) TailLogs(ctx context.Context, jobID string, afterSeq int64) ([]LogLine, error) {
	rows, err := s.db.QueryContext(ctx,
		`SELECT seq, stream, line, ts FROM job_logs WHERE job_id = ? AND seq > ? ORDER BY seq ASC`,
		jobID, afterSeq)
	if err != nil {
		return nil, fmt.Errorf("tail logs: %w", err)
	}
	defer rows.Close()

	var lines []LogLine
	for rows.Next() {
		var l LogLine
		if err := rows.Scan(&l.Seq, &l.Stream, &l.Line, &l.TS); err != nil {
			return nil, fmt.Errorf("tail logs: %w", err)
		}

		lines = append(lines, l)
	}

	return lines, rows.Err()
}

{"command":"cd /project && sed -n '/^import (/,/^)/p' internal/agentrun/run.go"}

import (
	"context"
	_ "embed"
	"encoding/json"
	"fmt"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"

	"github.com/abrander/zoo/internal/config"
	"github.com/abrander/zoo/internal/forgejo"
	"github.com/abrander/zoo/internal/livelog"
	"github.com/abrander/zoo/internal/llm"
	"github.com/abrander/zoo/internal/store"
)

{"find":"\treturn Hooks{\n\t\tOnReasoningDelta: func(delta string) {\n\t\t\tif !reasoningOpen {\n\t\t\t\treasoningOpen = true\n\t\t\t\treasoningBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningStart})\n\t\t\t}\n\n\t\t\treasoningBuf.WriteString(delta)\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningDelta, Text: delta})\n\t\t},\n\t\tOnContentDelta: func(delta string) {\n\t\t\tif !contentOpen {\n\t\t\t\tcontentOpen = true\n\t\t\t\tcontentBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentStart})\n\t\t\t}\n\n\t\t\tcontentBuf.WriteString(delta)\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentDelta, Text: delta})\n\t\t},\n\t\tOnTurnEnd: func() {\n\t\t\tif reasoningOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})\n\t\t\t\tlogAppend(\"reasoning\", reasoningBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\treasoningOpen = false\n\t\t\t}\n\n\t\t\tif contentOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})\n\t\t\t\tlogAppend(\"content\", contentBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\tcontentOpen = false\n\t\t\t}\n\t\t},","path":"internal/agentrun/run.go","replace":"\treturn Hooks{\n\t\tOnReasoningDelta: func(delta string) {\n\t\t\treasoningBuf.WriteString(delta)\n\n\t\t\t// Open the block lazily, on the first delta that gives it\n\t\t\t// real text. The model routinely emits whitespace-only\n\t\t\t// reasoning/content on reasoning+tool-call turns, and a\n\t\t\t// whitespace-only block renders as an empty block in the\n\t\t\t// live view while the static view (buildBlocks) drops it —\n\t\t\t// so the two views would disagree. Gating the start on\n\t\t\t// non-whitespace text keeps them in lockstep, and keeps the\n\t\t\t// whitespace-only turn out of the persisted log as well.\n\t\t\tif !reasoningOpen && strings.TrimSpace(reasoningBuf.String()) != \"\" {\n\t\t\t\treasoningOpen = true\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningStart})\n\t\t\t}\n\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningDelta, Text: delta})\n\t\t},\n\t\tOnContentDelta: func(delta string) {\n\t\t\tcontentBuf.WriteString(delta)\n\n\t\t\tif !contentOpen && strings.TrimSpace(contentBuf.String()) != \"\" {\n\t\t\t\tcontentOpen = true\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentStart})\n\t\t\t}\n\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentDelta, Text: delta})\n\t\t},\n\t\tOnTurnEnd: func() {\n\t\t\tif reasoningOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})\n\t\t\t\tlogAppend(\"reasoning\", reasoningBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t}\n\n\t\t\tif contentOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})\n\t\t\t\tlogAppend(\"content\", contentBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t}\n\n\t\t\t// Each turn starts from a clean slate. The buffers were\n\t\t\t// previously reset when a block opened, but with lazy open a\n\t\t\t// whitespace-only turn never opens one, so reset here instead\n\t\t\t// to keep one turn's text from leaking into the next.\n\t\t\treasoningOpen, contentOpen = false, false\n\t\t\treasoningBuf.Reset()\n\t\t\tcontentBuf.Reset()\n\t\t},"}

1 occurrences replaced

{"command":"cd /project && go build ./... 2>&1 | head -30 && echo \"BUILD_EXIT=$?\""}

go: downloading github.com/docker/docker v28.5.2+incompatible
go: downloading github.com/hashicorp/hcl/v2 v2.24.0
go: downloading codeberg.org/mvdkleijn/forgejo-sdk/forgejo/v2 v2.2.0
go: downloading github.com/google/uuid v1.6.0
go: downloading modernc.org/sqlite v1.56.0
go: downloading github.com/docker/go-connections v0.8.1
go: downloading github.com/docker/go-units v0.5.0
go: downloading github.com/moby/docker-image-spec v1.3.1
go: downloading github.com/opencontainers/image-spec v1.1.1
go: downloading github.com/containerd/errdefs v1.0.0
go: downloading github.com/containerd/errdefs/pkg v0.3.0
go: downloading github.com/distribution/reference v0.6.0
go: downloading github.com/opencontainers/go-digest v1.0.0
go: downloading github.com/pkg/errors v0.9.1
go: downloading go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0
go: downloading go.opentelemetry.io/otel/trace v1.45.0
go: downloading go.opentelemetry.io/otel v1.45.0
go: downloading github.com/42wim/httpsig v1.2.3
go: downloading github.com/go-fed/httpsig v1.1.0
go: downloading github.com/hashicorp/go-version v1.7.0
go: downloading golang.org/x/crypto v0.39.0
go: downloading github.com/felixge/httpsnoop v1.1.0
go: downloading go.opentelemetry.io/otel/metric v1.45.0
go: downloading github.com/agext/levenshtein v1.2.1
go: downloading github.com/apparentlymart/go-textseg/v15 v15.0.0
go: downloading github.com/mitchellh/go-wordwrap v1.0.1
go: downloading github.com/zclconf/go-cty v1.16.3
go: downloading github.com/go-logr/logr v1.4.4
go: downloading golang.org/x/sys v0.47.0
go: downloading github.com/google/go-cmp v0.7.0
BUILD_EXIT=0

{"command":"cd /project && go test ./internal/agentrun/ ./internal/web/ ./internal/livelog/ 2>&1 | tail -20"}

go: downloading github.com/go-logr/stdr v1.2.2
go: downloading go.opentelemetry.io/auto/sdk v1.2.1
go: downloading github.com/cespare/xxhash/v2 v2.3.0
go: downloading golang.org/x/text v0.40.0
go: downloading modernc.org/libc v1.74.4
go: downloading github.com/dustin/go-humanize v1.0.1
go: downloading modernc.org/mathutil v1.7.1
go: downloading modernc.org/memory v1.11.0
go: downloading github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec
ok  	github.com/abrander/zoo/internal/agentrun	0.006s
ok  	github.com/abrander/zoo/internal/web	1.174s
ok  	github.com/abrander/zoo/internal/livelog	0.052s

{"content":"package agentrun\n\nimport (\n\t\"io\"\n\t\"log/slog\"\n\t\"testing\"\n\n\t\"github.com/abrander/zoo/internal/livelog\"\n)\n\n// streamHooksTestRunner builds a Runner with just the fields streamHooks\n// touches (hub + logger), so the test doesn't have to stand up Docker.\nfunc streamHooksTestRunner(t *testing.T) (*Runner, *livelog.Hub) {\n\tt.Helper()\n\n\thub := livelog.NewHub()\n\n\treturn &Runner{hub: hub, logger: slog.New(slog.NewTextHandler(io.Discard, nil))}, hub\n}\n\n// collectEvents subscribes to jobID, runs fn (which publishes events\n// synchronously), and returns everything published, in order.\nfunc collectEvents(t *testing.T, hub *livelog.Hub, jobID string, fn func()) []livelog.Event {\n\tt.Helper()\n\n\tbuffered, ch, cancel := hub.Subscribe(jobID)\n\tdefer cancel()\n\n\tfn()\n\n\tevents := append([]livelog.Event(nil), buffered...)\n\ndrain:\n\tfor {\n\t\tselect {\n\t\tcase ev, ok := <-ch:\n\t\t\tif !ok {\n\t\t\t\tbreak drain\n\t\t\t}\n\t\t\tevents = append(events, ev)\n\t\tdefault:\n\t\t\tbreak drain\n\t\t}\n\t}\n\n\treturn events\n}\n\nfunc hasType(events []livelog.Event, want livelog.Type) bool {\n\tfor _, ev := range events {\n\t\tif ev.Type == want {\n\t\t\treturn true\n\t\t}\n\t}\n\n\treturn false\n}\n\n// A whitespace-only content block — the model's habit on reasoning +\n// tool-call turns — must not open a block: no start/end events, and\n// nothing persisted. This is what made the live view show an empty\n// block while the static view (buildBlocks) dropped it (issue #62).\nfunc TestStreamHooksDropsWhitespaceOnlyBlocks(t *testing.T) {\n\tr, hub := streamHooksTestRunner(t)\n\n\tvar persisted []string\n\n\thooks := r.streamHooks(\"job-1\", func(stream, line string) {\n\t\tpersisted = append(persisted, stream+\":\"+line)\n\t})\n\n\tevents := collectEvents(t, hub, \"job-1\", func() {\n\t\t// A reasoning + tool-call turn where the server emits a\n\t\t// whitespace-only content field.\n\t\thooks.OnReasoningDelta(\"thinking hard\")\n\t\thooks.OnContentDelta(\" \")\n\t\thooks.OnTurnEnd()\n\t})\n\n\t// The reasoning block opened and closed normally.\n\tfor _, want := range []livelog.Type{livelog.ReasoningStart, livelog.ReasoningDelta, livelog.ReasoningEnd} {\n\t\tif !hasType(events, want) {\n\t\t\tt.Fatalf(\"expected a %s event, got %+v\", want, events)\n\t\t}\n\t}\n\t// The whitespace-only content block never opened.\n\tfor _, absent := range []livelog.Type{livelog.ContentStart, livelog.ContentEnd} {\n\t\tif hasType(events, absent) {\n\t\t\tt.Fatalf(\"did not expect a %s event for whitespace-only content, got %+v\", absent, events)\n\t\t}\n\t}\n\n\t// Only the reasoning line was persisted; the whitespace content was\n\t// dropped.\n\tif len(persisted) != 1 || persisted[0] != \"reasoning:thinking hard\" {\n\t\tt.Fatalf(\"persisted = %q, want only the reasoning line\", persisted)\n\t}\n}\n\n// A content block with leading whitespace opens on the first delta that\n// carries real text, and the full (untrimmed) text is persisted —\n// trimming is the renderer's job, so the live and static views agree.\nfunc TestStreamHooksOpensBlockOnFirstRealText(t *testing.T) {\n\tr, hub := streamHooksTestRunner(t)\n\n\tvar persisted []string\n\n\thooks := r.streamHooks(\"job-1\", func(stream, line string) {\n\t\tpersisted = append(persisted, stream+\":\"+line)\n\t})\n\n\tevents := collectEvents(t, hub, \"job-1\", func() {\n\t\thooks.OnContentDelta(\"  \")\n\t\thooks.OnContentDelta(\"hello\")\n\t\thooks.OnContentDelta(\" world\")\n\t\thooks.OnTurnEnd()\n\t})\n\n\t// ContentStart must not fire on the leading-whitespace delta.\n\tif events[0].Type == livelog.ContentStart {\n\t\tt.Fatalf(\"ContentStart fired on the leading-whitespace delta: %+v\", events)\n\t}\n\tif !hasType(events, livelog.ContentStart) || !hasType(events, livelog.ContentEnd) {\n\t\tt.Fatalf(\"expected a ContentStart and ContentEnd, got %+v\", events)\n\t}\n\n\t// The full text (leading whitespace included) is persisted.\n\tif len(persisted) != 1 || persisted[0] != \"content:  hello world\" {\n\t\tt.Fatalf(\"persisted = %q, want the full untrimmed content\", persisted)\n\t}\n}\n\n// A whitespace-only turn must not leak its text into the next turn's\n// block: the buffers reset at turn end, not at block open (a\n// whitespace-only turn never opens a block, so the old reset point would\n// have been skipped).\nfunc TestStreamHooksResetsBuffersBetweenTurns(t *testing.T) {\n\tr, hub := streamHooksTestRunner(t)\n\n\tvar persisted []string\n\n\thooks := r.streamHooks(\"job-1\", func(stream, line string) {\n\t\tpersisted = append(persisted, stream+\":\"+line)\n\t})\n\n\tcollectEvents(t, hub, \"job-1\", func() {\n\t\t// Turn 1: whitespace-only content.\n\t\thooks.OnContentDelta(\"   \")\n\t\thooks.OnTurnEnd()\n\n\t\t// Turn 2: real content.\n\t\thooks.OnContentDelta(\"real\")\n\t\thooks.OnTurnEnd()\n\t})\n\n\tif len(persisted) != 1 || persisted[0] != \"content:real\" {\n\t\tt.Fatalf(\"persisted = %q, want only turn 2's content (no leak from turn 1)\", persisted)\n\t}\n}\n","path":"internal/agentrun/run_test.go"}

OK

{"command":"cd /project && go test ./internal/agentrun/ -run 'TestStreamHooks' -v 2>&1 | tail -30"}

=== RUN   TestStreamHooksDropsWhitespaceOnlyBlocks
--- PASS: TestStreamHooksDropsWhitespaceOnlyBlocks (0.00s)
=== RUN   TestStreamHooksOpensBlockOnFirstRealText
--- PASS: TestStreamHooksOpensBlockOnFirstRealText (0.00s)
=== RUN   TestStreamHooksResetsBuffersBetweenTurns
--- PASS: TestStreamHooksResetsBuffersBetweenTurns (0.00s)
PASS
ok  	github.com/abrander/zoo/internal/agentrun	0.004s

{"command":"cd /project && go test ./... 2>&1 | tail -30"}

?   	github.com/abrander/zoo/cmd/zoo	[no test files]
ok  	github.com/abrander/zoo/internal/agentrun	0.007s
ok  	github.com/abrander/zoo/internal/config	0.006s
ok  	github.com/abrander/zoo/internal/forgejo	1.199s
ok  	github.com/abrander/zoo/internal/livelog	(cached)
ok  	github.com/abrander/zoo/internal/llm	0.003s
ok  	github.com/abrander/zoo/internal/scheduler	2.784s
ok  	github.com/abrander/zoo/internal/store	1.766s
ok  	github.com/abrander/zoo/internal/tools	0.003s
ok  	github.com/abrander/zoo/internal/web	(cached)

{"command":"cd /project && go vet ./... 2>&1 | tail -10 && echo \"VET_EXIT=$?\" && echo \"=== diff ===\" && git diff"}

VET_EXIT=0
=== diff ===
diff --git a/internal/agentrun/run.go b/internal/agentrun/run.go
index 486b954..c0f374b 100644
--- a/internal/agentrun/run.go
+++ b/internal/agentrun/run.go
@@ -292,23 +292,31 @@ func (r *Runner) streamHooks(jobID string, logAppend func(stream, line string))
 
 	return Hooks{
 		OnReasoningDelta: func(delta string) {
-			if !reasoningOpen {
+			reasoningBuf.WriteString(delta)
+
+			// Open the block lazily, on the first delta that gives it
+			// real text. The model routinely emits whitespace-only
+			// reasoning/content on reasoning+tool-call turns, and a
+			// whitespace-only block renders as an empty block in the
+			// live view while the static view (buildBlocks) drops it —
+			// so the two views would disagree. Gating the start on
+			// non-whitespace text keeps them in lockstep, and keeps the
+			// whitespace-only turn out of the persisted log as well.
+			if !reasoningOpen && strings.TrimSpace(reasoningBuf.String()) != "" {
 				reasoningOpen = true
-				reasoningBuf.Reset()
 				r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningStart})
 			}
 
-			reasoningBuf.WriteString(delta)
 			r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningDelta, Text: delta})
 		},
 		OnContentDelta: func(delta string) {
-			if !contentOpen {
+			contentBuf.WriteString(delta)
+
+			if !contentOpen && strings.TrimSpace(contentBuf.String()) != "" {
 				contentOpen = true
-				contentBuf.Reset()
 				r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentStart})
 			}
 
-			contentBuf.WriteString(delta)
 			r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentDelta, Text: delta})
 		},
 		OnTurnEnd: func() {
@@ -316,15 +324,21 @@ func (r *Runner) streamHooks(jobID string, logAppend func(stream, line string))
 				r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})
 				logAppend("reasoning", reasoningBuf.String())
 				r.hub.Checkpoint(jobID)
-				reasoningOpen = false
 			}
 
 			if contentOpen {
 				r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})
 				logAppend("content", contentBuf.String())
 				r.hub.Checkpoint(jobID)
-				contentOpen = false
 			}
+
+			// Each turn starts from a clean slate. The buffers were
+			// previously reset when a block opened, but with lazy open a
+			// whitespace-only turn never opens one, so reset here instead
+			// to keep one turn's text from leaking into the next.
+			reasoningOpen, contentOpen = false, false
+			reasoningBuf.Reset()
+			contentBuf.Reset()
 		},
 		OnReroll: func(name, arguments string, attempt int) {
 			// A discarded turn leaves its reasoning/content already in

{"command":"cd /project && sed -n '/func (r \\*Runner) streamHooks/,/^}/p' internal/agentrun/run.go"}

func (r *Runner) streamHooks(jobID string, logAppend func(stream, line string)) Hooks {
	var reasoningBuf, contentBuf strings.Builder

	reasoningOpen, contentOpen := false, false

	return Hooks{
		OnReasoningDelta: func(delta string) {
			reasoningBuf.WriteString(delta)

			// Open the block lazily, on the first delta that gives it
			// real text. The model routinely emits whitespace-only
			// reasoning/content on reasoning+tool-call turns, and a
			// whitespace-only block renders as an empty block in the
			// live view while the static view (buildBlocks) drops it —
			// so the two views would disagree. Gating the start on
			// non-whitespace text keeps them in lockstep, and keeps the
			// whitespace-only turn out of the persisted log as well.
			if !reasoningOpen && strings.TrimSpace(reasoningBuf.String()) != "" {
				reasoningOpen = true
				r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningStart})
			}

			r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningDelta, Text: delta})
		},
		OnContentDelta: func(delta string) {
			contentBuf.WriteString(delta)

			if !contentOpen && strings.TrimSpace(contentBuf.String()) != "" {
				contentOpen = true
				r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentStart})
			}

			r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentDelta, Text: delta})
		},
		OnTurnEnd: func() {
			if reasoningOpen {
				r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})
				logAppend("reasoning", reasoningBuf.String())
				r.hub.Checkpoint(jobID)
			}

			if contentOpen {
				r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})
				logAppend("content", contentBuf.String())
				r.hub.Checkpoint(jobID)
			}

			// Each turn starts from a clean slate. The buffers were
			// previously reset when a block opened, but with lazy open a
			// whitespace-only turn never opens one, so reset here instead
			// to keep one turn's text from leaking into the next.
			reasoningOpen, contentOpen = false, false
			reasoningBuf.Reset()
			contentBuf.Reset()
		},
		OnReroll: func(name, arguments string, attempt int) {
			// A discarded turn leaves its reasoning/content already in
			// the log, so say why the next one repeats it.
			note := fmt.Sprintf("discarded turn %d/%d: %s was called with arguments that are not valid JSON, asking again: %s",
				attempt, maxRerolls, name, arguments)

			r.hub.Publish(jobID, livelog.Event{Type: livelog.System, Text: note})
			logAppend("system", note)
			r.hub.Checkpoint(jobID)
		},
		OnTool: func(name, arguments, result string, toolErr bool) {
			r.hub.Publish(jobID, livelog.Event{
				Type:      livelog.Tool,
				Name:      name,
				Arguments: arguments,
				Result:    result,
				Error:     toolErr,
			})

			line, err := json.Marshal(store.ToolLogEntry{Name: name, Arguments: arguments, Result: result, Error: toolErr})
			if err != nil {
				r.logger.Warn("failed to marshal tool log entry", "job", jobID, "error", err)
			} else {
				logAppend("tool", string(line))
			}

			r.hub.Checkpoint(jobID)
		},
	}
}

{"command":"cd /project && go build ./... && go test ./... 2>&1 | tail -15"}

?   	github.com/abrander/zoo/cmd/zoo	[no test files]
ok  	github.com/abrander/zoo/internal/agentrun	(cached)
ok  	github.com/abrander/zoo/internal/config	(cached)
ok  	github.com/abrander/zoo/internal/forgejo	(cached)
ok  	github.com/abrander/zoo/internal/livelog	(cached)
ok  	github.com/abrander/zoo/internal/llm	(cached)
ok  	github.com/abrander/zoo/internal/scheduler	(cached)
ok  	github.com/abrander/zoo/internal/store	(cached)
ok  	github.com/abrander/zoo/internal/tools	(cached)
ok  	github.com/abrander/zoo/internal/web	(cached)

{"command":"cd /project && git add -A && git commit -q -m \"livelog: open reasoning/content blocks lazily, on first real text\n\nOn reasoning+tool-call turns the model routinely emits a whitespace-only\ncontent field. streamHooks used to open the block on the very first\ndelta, so the live view rendered a block that trimmed down to nothing —\nan empty block after every thinking block — while the static view\n(buildBlocks) dropped whitespace-only blocks entirely. The two views\ndisagreed, which is exactly what issue #62 reported.\n\nOpen the block lazily, on the first delta that gives it non-whitespace\ntext. That keeps the live view in lockstep with the static view, and\nkeeps the whitespace-only turn out of the persisted log as well. The\nbuffer reset moves to turn end (a whitespace-only turn never opens a\nblock, so the old reset point would have been skipped and one turn's\ntext could leak into the next).\n\nAdd streamHooks tests covering the whitespace-only drop, the lazy open\non first real text, and the per-turn buffer reset.\" && git log --oneline -2"}

49f034a livelog: open reasoning/content blocks lazily, on first real text
7423d86 Try to re-roll broken tool calls.

{"command":"cd /project && git push -u origin issue-62-greg 2>&1 | tail -5"}

To https://code.stdio.dk/abrander/zoo.git
 * [new branch]      issue-62-greg -> issue-62-greg
branch 'issue-62-greg' set up to track 'origin/issue-62-greg'.

{"base":"main","body":"## Summary\n\nFixes #62 — streaming a job showed empty blocks after thinking blocks, which vanished on refresh.\n\n## Root cause\n\nOn reasoning + tool-call turns, the model routinely emits a **whitespace-only** `content` field. `streamHooks` used to open the block on the very first delta, so:\n\n- **Live view:** the dashboard created a `block-content` div on `content_start`, the whitespace delta trimmed down to `\"\"` on `content_end` — leaving an empty block in the DOM.\n- **Static view (after refresh):** `buildBlocks` drops whitespace-only blocks entirely.\n\nThe two views disagreed — exactly the `thinking / empty / toolcall` pattern from the issue.\n\n## Fix\n\nOpen reasoning/content blocks **lazily, on the first delta that carries non-whitespace text** (`internal/agentrun/run.go`):\n\n- The live view now stays in lockstep with the static view — the \"is this block worth rendering\" decision lives in one place (Go), using the same `TrimSpace` rule as `buildBlocks`.\n- Whitespace-only turns no longer land in the persisted log either.\n- The buffer reset moves to turn end: with lazy open, a whitespace-only turn never opens a block, so the old reset point (on block open) would have been skipped and one turn's text could leak into the next.\n\nNo client-side change needed: the server simply never sends a `*Start` event for a block that would be empty, so the dashboard never creates one.\n\n## Tests\n\nNew `internal/agentrun/run_test.go` covers:\n- `TestStreamHooksDropsWhitespaceOnlyBlocks` — no `ContentStart`/`ContentEnd`, nothing persisted for a whitespace-only content block.\n- `TestStreamHooksOpensBlockOnFirstRealText` — block opens on the first real delta; full untrimmed text is persisted (trimming stays the renderer's job).\n- `TestStreamHooksResetsBuffersBetweenTurns` — a whitespace-only turn doesn't leak into the next turn's block.\n\nFull suite passes: `go build ./... && go test ./...` ✅","head":"issue-62-greg","title":"livelog: open reasoning/content blocks lazily, on first real text"}

Pull request opened

{"body":"Investigated and fixed — PR is up for review.\n\n**Root cause:** On reasoning + tool-call turns, the model routinely emits a *whitespace-only* `content` field. `streamHooks` opened the block on the very first delta, so the live dashboard created a `block-content` div that trimmed down to nothing — the empty block after every thinking block. The static view (`buildBlocks`) drops whitespace-only blocks, which is why they vanished on refresh.\n\n**Fix:** Open reasoning/content blocks lazily, on the first delta that carries non-whitespace text (`internal/agentrun/run.go`). The live view now stays in lockstep with the static view — the \"is this block worth rendering\" decision lives in one place, using the same `TrimSpace` rule as `buildBlocks` — and whitespace-only turns no longer land in the persisted log either. The per-turn buffer reset moved to turn end (a whitespace-only turn never opens a block, so the old reset point would have been skipped).\n\nNo client-side change needed: the server simply never sends a `*Start` event for a block that would be empty.\n\nAdded three `streamHooks` tests covering the whitespace-only drop, the lazy open on first real text, and the per-turn buffer reset. Full suite passes."}

Comment posted

{"command":"cd /project && git log --oneline -3 && echo \"---\" && git status && echo \"--- files changed ---\" && git diff --stat HEAD~1"}

49f034a livelog: open reasoning/content blocks lazily, on first real text
7423d86 Try to re-roll broken tool calls.
f58963a Merge pull request 'Jobs page: follow the live log tail, with a jump-to-bottom button' (#58) from issue-57-greg into main
---
On branch issue-62-greg
nothing to commit, working tree clean
--- files changed ---
 internal/agentrun/run.go      |  30 +++++---
 internal/agentrun/run_test.go | 159 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 181 insertions(+), 8 deletions(-)