Job cad11319-38ee-4e58-bec5-60e5eb6761ee

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

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

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

98298f6 Merge pull request 'Fix excessive vertical space in job view blocks (#53)' (#55) from issue-53-greg into main
b75b64d Fix excessive vertical space in job view blocks
10c3dce Better Docker/git inter.
315f993 Add docker image build.
5717258 Merge pull request 'forgejo: repository allowlist with wildcard patterns' (#40) from issue-39-greg into main
On branch issue-60-greg
nothing to commit, working tree clean

{"path": "internal", "recursive": true}

/project/internal/agentrun
/project/internal/agentrun/context.go
/project/internal/agentrun/docker.go
/project/internal/agentrun/docker_integration_test.go
/project/internal/agentrun/forgejo.go
/project/internal/agentrun/loop.go
/project/internal/agentrun/roster.go
/project/internal/agentrun/roster_test.go
/project/internal/agentrun/run.go
/project/internal/agentrun/sandboxgit.go
/project/internal/agentrun/sandboxgit_test.go
/project/internal/agentrun/seed_test.go
/project/internal/agentrun/system.md
/project/internal/config
/project/internal/config/config.go
/project/internal/config/config_test.go
/project/internal/forgejo
/project/internal/forgejo/client.go
/project/internal/forgejo/client_test.go
/project/internal/forgejo/event.go
/project/internal/forgejo/poll.go
/project/internal/forgejo/poll_test.go
/project/internal/forgejo/repo_filter.go
/project/internal/forgejo/repo_filter_test.go
/project/internal/forgejo/watcher.go
/project/internal/forgejo/watcher_test.go
/project/internal/forgejo/webhook.go
/project/internal/forgejo/webhook_test.go
/project/internal/livelog
/project/internal/livelog/hub.go
/project/internal/livelog/hub_test.go
/project/internal/llm
/project/internal/llm/client.go
/project/internal/llm/streamer.go
/project/internal/llm/streamer_test.go
/project/internal/llm/types.go
/project/internal/scheduler
/project/internal/scheduler/scheduler.go
/project/internal/scheduler/scheduler_test.go
/project/internal/store
/project/internal/store/schema.sql
/project/internal/store/store.go
/project/internal/store/store_test.go
/project/internal/tools
/project/internal/tools/bash.go
/project/internal/tools/context.go
/project/internal/tools/edit-file.go
/project/internal/tools/forgejo.go
/project/internal/tools/grep_search.go
/project/internal/tools/list_files.go
/project/internal/tools/move_file.go
/project/internal/tools/read_file.go
/project/internal/tools/registry.go
/project/internal/tools/remove_file.go
/project/internal/tools/shell.go
/project/internal/tools/tools_test.go
/project/internal/tools/write_file.go
/project/internal/web
/project/internal/web/templates.go
/project/internal/web/web.go
/project/internal/web/web_test.go

{"command": "cd /project && git log --oneline -15 --all"}

98298f6 Merge pull request 'Fix excessive vertical space in job view blocks (#53)' (#55) from issue-53-greg into main
b75b64d Fix excessive vertical space in job view blocks
10c3dce Better Docker/git inter.
315f993 Add docker image build.
5717258 Merge pull request 'forgejo: repository allowlist with wildcard patterns' (#40) from issue-39-greg into main
823ae62 fix(forgejo): resolve test helper collision after merging main
bccf930 Merge branch 'main' into issue-39-greg
1365ea8 Merge pull request 'Pass the agent's git credential to the sandbox, clone inside it' (#49) from issue-48-greg into main
7c60789 Remove the git tool and Context.Git per review
c3d3720 Pass the agent's git credential to the sandbox, clone inside it
f083eae Merge pull request 'Add pr:review event so agents react to PR reviews' (#37) from issue-36-greg into main
2b59027 Merge branch 'main' into issue-36-greg
c6a6304 Merge pull request 'docs: add comprehensive README for Zoo' (#44) from issue-43-anna into main
438a663 docs: clarify agents are in example config, not pre-configured
884245c Merge branch 'main' into issue-36-greg

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

{"path":"internal/web/templates.go","content":"package web\n\nconst templates = `\n{{define \"layout_head\"}}\n\u003c!doctype html\u003e\n\u003chtml lang=\"en\"\u003e\n\u003chead\u003e\n\u003cmeta charset=\"utf-8\"\u003e\n\u003cmeta name=\"viewport\" content=\"width=device-width, initial-scale=1\"\u003e\n\u003ctitle\u003ezoo\u003c/title\u003e\n\u003cstyle\u003e\n  :root {\n    --bg: #0f0f13;\n    --bg-surface: #1a1a24;\n    --bg-surface-hover: #22222e;\n    --bg-code: #12121a;\n    --border: #2a2a3a;\n    --text: #e4e4e8;\n    --text-muted: #8888a0;\n    --accent: #7c6aef;\n    --accent-glow: rgba(124, 106, 239, 0.15);\n    --radius: 12px;\n    --radius-sm: 8px;\n    --font: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;\n    --mono: 'JetBrains Mono', 'Fira Code', 'SF Mono', monospace;\n  }\n\n  * { margin: 0; padding: 0; box-sizing: border-box; }\n\n  body {\n    font-family: var(--font);\n    background: var(--bg);\n    color: var(--text);\n    line-height: 1.6;\n    min-height: 100vh;\n  }\n\n  /* ── Navigation ─────────────────────────────── */\n  nav {\n    position: sticky;\n    top: 0;\n    z-index: 100;\n    display: flex;\n    align-items: center;\n    justify-content: space-between;\n    padding: 0 2rem;\n    height: 60px;\n    background: var(--bg-surface);\n    border-bottom: 1px solid var(--border);\n    backdrop-filter: blur(12px);\n  }\n\n  nav .brand {\n    display: flex;\n    align-items: center;\n    gap: 0.6rem;\n    font-size: 1.25rem;\n    font-weight: 700;\n    color: var(--text);\n    text-decoration: none;\n    letter-spacing: -0.02em;\n  }\n\n  nav .brand .logo {\n    display: inline-flex;\n    align-items: center;\n    justify-content: center;\n    width: 32px;\n    height: 32px;\n    border-radius: var(--radius-sm);\n    background: linear-gradient(135deg, var(--accent), #a78bfa);\n    color: #fff;\n    font-size: 1rem;\n    font-weight: 800;\n  }\n\n  nav .links {\n    display: flex;\n    gap: 0.25rem;\n  }\n\n  nav .links a {\n    display: inline-flex;\n    align-items: center;\n    gap: 0.4rem;\n    padding: 0.5rem 1rem;\n    border-radius: var(--radius-sm);\n    color: var(--text-muted);\n    text-decoration: none;\n    font-size: 0.9rem;\n    font-weight: 500;\n    transition: all 0.15s ease;\n  }\n\n  nav .links a:hover {\n    color: var(--text);\n    background: var(--bg-surface-hover);\n  }\n\n  nav .links a.active {","start_line":1,"end_line":100,"total_lines":1004,"truncated":true}

{"end_line": 100, "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\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) {","start_line":1,"end_line":100,"total_lines":164,"truncated":true}

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

{"path":"internal/web/web.go","content":"// Package web is zoo's minimal server-rendered dashboard: config\n// overview, live queue/history, and a per-job log tail.\npackage web\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"html/template\"\n\t\"net/http\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n\t\"github.com/abrander/zoo/internal/forgejo\"\n\t\"github.com/abrander/zoo/internal/livelog\"\n\t\"github.com/abrander/zoo/internal/store\"\n)\n\ntype Server struct {\n\tcfg   *config.Config\n\tstore *store.Store\n\thub   *livelog.Hub\n\tfg    *forgejo.Client\n\ttmpl  *template.Template\n\n\tavatarMu    sync.Mutex\n\tavatarCache map[string]avatarCacheEntry\n}\n\n// avatarCacheTTL bounds how long a resolved avatar URL is trusted before\n// it's re-fetched from Forgejo. Avatars rarely change, but a user can\n// re-upload one (which changes its URL), so the cache expires instead of\n// living for the process lifetime.\nconst avatarCacheTTL = time.Hour\n\ntype avatarCacheEntry struct {\n\turl       string\n\tfetchedAt time.Time\n}\n\nfunc New(cfg *config.Config, st *store.Store, hub *livelog.Hub, fg *forgejo.Client) *Server {\n\treturn \u0026Server{\n\t\tcfg:         cfg,\n\t\tstore:       st,\n\t\thub:         hub,\n\t\tfg:          fg,\n\t\ttmpl:        template.Must(template.New(\"\").Parse(templates)),\n\t\tavatarCache: map[string]avatarCacheEntry{},\n\t}\n}\n\n// Handler returns the dashboard's http.Handler, gated by config.Web's\n// bearer token if one is set.\nfunc (s *Server) Handler() http.Handler {\n\tmux := http.NewServeMux()\n\n\tmux.HandleFunc(\"GET /{$}\", s.handleIndex)\n\tmux.HandleFunc(\"GET /jobs\", s.handleJobs)\n\tmux.HandleFunc(\"GET /jobs/{id}\", s.handleJobDetail)\n\tmux.HandleFunc(\"GET /jobs/{id}/events\", s.handleJobEvents)\n\n\treturn s.authMiddleware(mux)\n}\n\nfunc (s *Server) authMiddleware(next http.Handler) http.Handler {\n\tif s.cfg.Web == nil || s.cfg.Web.Token == \"\" {\n\t\treturn next\n\t}\n\n\ttoken := s.cfg.Web.Token\n\n\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\tauth := r.Header.Get(\"Authorization\")\n\t\tif auth != \"Bearer \"+token {\n\t\t\tw.Header().Set(\"WWW-Authenticate\", `Bearer realm=\"zoo\"`)\n\t\t\thttp.Error(w, \"unauthorized\", http.StatusUnauthorized)\n\n\t\t\treturn\n\t\t}\n\n\t\tnext.ServeHTTP(w, r)\n\t})\n}\n\nfunc (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {\n\t// Fetch active (pending or running) jobs for the dashboard overview.\n\t// We fetch more than we display so we can filter to just active ones.\n\tallJobs, err := s.store.ListJobs(r.Context(), 200)\n\tif err != nil {\n\t\thttp.Error(w, err.Error(), http.StatusInternalServerError)\n\t\treturn\n\t}\n\n\t// Collect unique agent names from active jobs.\n\tvar agentNames []string\n\tseenAgents := make(map[string]bool)\n\n\tvar activeJobs []activeJobRow\n\tfor _, j := range allJobs {\n\t\tif j.Status != store.JobPending \u0026\u0026 j.Status != store.JobRunning {\n\t\t\tcontinue\n\t\t}\n\t\tif !seenAgents[j.Agent] {\n\t\t\tseenAgents[j.Agent] = true\n\t\t\tagentNames = append(agentNames, j.Agent)\n\t\t}\n\t\tactiveJobs = append(activeJobs, activeJobRow{\n\t\t\tJob:       j,\n\t\t\tAvatarURL: s.avatarFor(j.Agent),\n\t\t})\n\t}\n\n\ttype indexData struct {\n\t\t*config.Config\n\t\tActiveJobs []activeJobRow\n\t}\n\n\ts.render(w, \"index\", indexData{\n\t\tConfig:     s.cfg,","start_line":1,"end_line":120,"total_lines":374,"truncated":true}

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

{"path":"internal/web/web.go","content":"\t\tConfig:     s.cfg,\n\t\tActiveJobs: activeJobs,\n\t})\n}\n\n// activeJobRow is a store.Job enriched with the agent's avatar URL.\ntype activeJobRow struct {\n\tstore.Job\n\tAvatarURL string\n}\n\n// jobRow is a store.Job plus the agent's Forgejo avatar, resolved for the\n// jobs table so it's immediately clear who is running each job.\ntype jobRow struct {\n\tstore.Job\n\tAvatarURL string\n}\n\nfunc (s *Server) handleJobs(w http.ResponseWriter, r *http.Request) {\n\tjobs, err := s.store.ListJobs(r.Context(), 200)\n\tif err != nil {\n\t\thttp.Error(w, err.Error(), http.StatusInternalServerError)\n\n\t\treturn\n\t}\n\n\trows := make([]jobRow, 0, len(jobs))\n\n\tfor _, j := range jobs {\n\t\trows = append(rows, jobRow{Job: j, AvatarURL: s.avatarFor(j.Agent)})\n\t}\n\n\ts.render(w, \"jobs\", rows)\n}\n\n// avatarFor returns the Forgejo avatar URL of the agent named username,\n// or \"\" if it can't be resolved (no Forgejo client configured, unknown\n// user, API error). The dashboard must never fail to render because of a\n// missing avatar, so every failure mode degrades to no image. Results are\n// cached per username for avatarCacheTTL so a page refresh doesn't turn\n// into one GetUserInfo call per unique agent.\nfunc (s *Server) avatarFor(username string) string {\n\tif s.fg == nil || username == \"\" {\n\t\treturn \"\"\n\t}\n\n\ts.avatarMu.Lock()\n\n\tif e, ok := s.avatarCache[username]; ok \u0026\u0026 time.Since(e.fetchedAt) \u003c avatarCacheTTL {\n\t\ts.avatarMu.Unlock()\n\n\t\treturn e.url\n\t}\n\n\ts.avatarMu.Unlock()\n\n\tprofile, err := s.fg.AgentProfile(username)\n\tif err != nil {\n\t\treturn \"\"\n\t}\n\n\ts.avatarMu.Lock()\n\ts.avatarCache[username] = avatarCacheEntry{url: profile.AvatarURL, fetchedAt: time.Now()}\n\ts.avatarMu.Unlock()\n\n\treturn profile.AvatarURL\n}\n\n// toolBlock is the parsed form of a stream=\"tool\" store.LogLine, for the\n// template to render as a single collapsed detail.\ntype toolBlock struct {\n\tName      string\n\tArguments string\n\tResult    string\n\tError     bool\n}\n\n// block is one self-contained, already-complete unit of job output: a\n// finished reasoning or assistant-message block, a finished tool call,\n// or a misc system note. Unlike the old flat log view, one store.LogLine\n// maps to exactly one block — grouping/streaming happens upstream, when\n// agentrun persists the row.\ntype block struct {\n\tKind string // \"reasoning\" | \"content\" | \"tool\" | \"system\"\n\tText string\n\tTool *toolBlock\n}\n\nfunc buildBlocks(logs []store.LogLine) []block {\n\tblocks := make([]block, 0, len(logs))\n\n\tfor _, l := range logs {\n\t\tswitch l.Stream {\n\t\tcase \"reasoning\", \"content\":\n\t\t\t// Model output routinely starts/ends with newlines. The block\n\t\t\t// body renders with white-space: pre-wrap, so those would show\n\t\t\t// up as visible blank lines inflating the block's height. Trim\n\t\t\t// them for display (internal newlines are kept) and drop\n\t\t\t// blocks that are nothing but whitespace.\n\t\t\ttext := strings.TrimSpace(l.Line)\n\t\t\tif text == \"\" {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tblocks = append(blocks, block{Kind: l.Stream, Text: text})\n\n\t\tcase \"tool\":\n\t\t\tvar entry store.ToolLogEntry\n\t\t\tif err := json.Unmarshal([]byte(l.Line), \u0026entry); err != nil {\n\t\t\t\tblocks = append(blocks, block{Kind: \"system\", Text: l.Line})\n\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tblocks = append(blocks, block{Kind: \"tool\", Tool: \u0026toolBlock{\n\t\t\t\tName:      entry.Name,\n\t\t\t\tArguments: entry.Arguments,\n\t\t\t\tResult:    entry.Result,\n\t\t\t\tError:     entry.Error,\n\t\t\t}})\n\n\t\tdefault:\n\t\t\tblocks = append(blocks, block{Kind: \"system\", Text: l.Line})\n\t\t}\n\t}\n\n\treturn blocks\n}\n\nfunc (s *Server) handleJobDetail(w http.ResponseWriter, r *http.Request) {\n\tid := r.PathValue(\"id\")\n\n\tjob, err := s.store.GetJob(r.Context(), id)\n\tif err != nil {\n\t\thttp.Error(w, \"job not found\", http.StatusNotFound)\n\n\t\treturn\n\t}\n\n\tlogs, err := s.store.TailLogs(r.Context(), id, -1)\n\tif err != nil {\n\t\thttp.Error(w, err.Error(), http.StatusInternalServerError)\n\n\t\treturn\n\t}\n\n\ts.render(w, \"job_detail\", struct {\n\t\tJob       store.Job\n\t\tBlocks    []block\n\t\tLive      bool\n\t\tAvatarURL string\n\t}{job, buildBlocks(logs), job.Status == store.JobPending || job.Status == store.JobRunning, s.avatarFor(job.Agent)})\n}\n\n// handleJobEvents streams job jobID's live output as Server-Sent\n// Events. It only ever carries events for the current, not-yet-persisted\n// block (see livelog.Hub.Checkpoint) — everything already written to\n// the store is rendered once, statically, by handleJobDetail. If the\n// job isn't live, the response just ends immediately and the client\n// falls back to the static page.\nfunc (s *Server) handleJobEvents(w http.ResponseWriter, r *http.Request) {\n\tid := r.PathValue(\"id\")\n\n\tjob, err := s.store.GetJob(r.Context(), id)\n\tif err != nil {\n\t\thttp.Error(w, \"job not found\", http.StatusNotFound)\n\n\t\treturn\n\t}\n\n\tif job.Status != store.JobPending \u0026\u0026 job.Status != store.JobRunning {\n\t\treturn\n\t}\n\n\tflusher, ok := w.(http.Flusher)\n\tif !ok {\n\t\thttp.Error(w, \"streaming unsupported\", http.StatusInternalServerError)\n\n\t\treturn\n\t}\n\n\tw.Header().Set(\"Content-Type\", \"text/event-stream\")\n\tw.Header().Set(\"Cache-Control\", \"no-cache\")\n\tw.Header().Set(\"Connection\", \"keep-alive\")\n\tw.WriteHeader(http.StatusOK)\n\n\tbuffered, ch, cancel := s.hub.Subscribe(id)\n\tdefer cancel()\n\n\twrite := func(ev livelog.Event) bool {\n\t\tdata, err := json.Marshal(ev)\n\t\tif err != nil {\n\t\t\treturn true\n\t\t}\n\n\t\tif _, err := fmt.Fprintf(w, \"data: %s\\n\\n\", data); err != nil {\n\t\t\treturn false\n\t\t}\n\n\t\tflusher.Flush()\n\n\t\treturn true\n\t}\n\n\tfor _, ev := range buffered {\n\t\tif !write(ev) {\n\t\t\treturn\n\t\t}\n\t}\n\n\theartbeat := time.NewTicker(15 * time.Second)\n\tdefer heartbeat.Stop()\n\n\tfor {\n\t\tselect {\n\t\tcase ev, ok := \u003c-ch:\n\t\t\tif !ok {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tif !write(ev) {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tif ev.Type == livelog.Status {\n\t\t\t\treturn\n\t\t\t}\n\n\t\tcase \u003c-heartbeat.C:\n\t\t\tif _, err := fmt.Fprint(w, \": heartbeat\\n\\n\"); err != nil {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tflusher.Flush()\n\n\t\tcase \u003c-r.Context().Done():\n\t\t\treturn\n\t\t}\n\t}\n}\n\nfunc (s *Server) render(w http.ResponseWriter, name string, data any) {\n\tw.Header().Set(\"Content-Type\", \"text/html; charset=utf-8\")\n\n\t// Every page here reflects live, fast-changing state (job status, log\n\t// blocks). Without this, browsers are free to serve a stale cached\n\t// copy of the job detail page on a same-URL navigation — including\n\t// the auto location.reload() a job's SSE stream triggers when it\n\t// finishes — which looks exactly like blocks that were visible while\n\t// streaming vanishing once the page reloads.\n\tw.Header().Set(\"Cache-Control\", \"no-store\")\n\n\tif err := s.tmpl.ExecuteTemplate(w, name, data); err != nil {\n\t\thttp.Error(w, err.Error(), http.StatusInternalServerError)\n\t}\n}","start_line":120,"end_line":374,"total_lines":374,"truncated":false}

{"context_after": 10, "context_before": 5, "query": "block-body"}

/project/internal/web/templates.go-444-    color: var(--text-muted);
/project/internal/web/templates.go-445-    font-weight: 600;
/project/internal/web/templates.go-446-    margin-bottom: 0.35rem;
/project/internal/web/templates.go-447-  }
/project/internal/web/templates.go-448-
/project/internal/web/templates.go:449:  .block-body {
/project/internal/web/templates.go-450-    font-family: var(--font);
/project/internal/web/templates.go-451-    font-size: 0.9rem;
/project/internal/web/templates.go-452-    line-height: 1.6;
/project/internal/web/templates.go-453-    color: var(--text);
/project/internal/web/templates.go-454-    white-space: pre-wrap;
/project/internal/web/templates.go-455-    word-break: break-word;
/project/internal/web/templates.go-456-  }
/project/internal/web/templates.go-457-
/project/internal/web/templates.go-458-  .block-reasoning,
/project/internal/web/templates.go-459-  .block-content {
--
/project/internal/web/templates.go-464-  .block-reasoning {
/project/internal/web/templates.go-465-    background: rgba(124, 106, 239, 0.06);
/project/internal/web/templates.go-466-    border-left: 3px solid var(--accent);
/project/internal/web/templates.go-467-  }
/project/internal/web/templates.go-468-
/project/internal/web/templates.go:469:  .block-reasoning .block-body {
/project/internal/web/templates.go-470-    color: var(--text-muted);
/project/internal/web/templates.go-471-    font-style: italic;
/project/internal/web/templates.go-472-  }
/project/internal/web/templates.go-473-
/project/internal/web/templates.go-474-  .block-content {
/project/internal/web/templates.go-475-    background: var(--bg-surface);
/project/internal/web/templates.go-476-    border: 1px solid var(--border);
/project/internal/web/templates.go-477-  }
/project/internal/web/templates.go-478-
/project/internal/web/templates.go-479-  .block-system {
--
/project/internal/web/templates.go-552-  }
/project/internal/web/templates.go-553-
/project/internal/web/templates.go-554-  .block-tool-error { border-left-color: #ef4444; }
/project/internal/web/templates.go-555-  .block-tool-error .tool-badge { background: rgba(239, 68, 68, 0.15); color: #ef4444; }
/project/internal/web/templates.go-556-
/project/internal/web/templates.go:557:  .block-tool .block-body {
/project/internal/web/templates.go-558-    padding: 0 1.1rem 1rem;
/project/internal/web/templates.go-559-    border-top: 1px solid var(--border);
/project/internal/web/templates.go-560-    /* Unlike a reasoning/content block, this wraps element children
/project/internal/web/templates.go-561-       (labels + <pre>s), not raw text, so it must not inherit the base
/project/internal/web/templates.go:562:       .block-body's white-space: pre-wrap — that would render the
/project/internal/web/templates.go-563-       template source's own whitespace between those child tags as
/project/internal/web/templates.go-564-       visible blank lines. */
/project/internal/web/templates.go-565-    white-space: normal;
/project/internal/web/templates.go-566-  }
/project/internal/web/templates.go-567-
/project/internal/web/templates.go-568-  .block-tool .tool-section-label {
/project/internal/web/templates.go-569-    font-size: 0.72rem;
/project/internal/web/templates.go-570-    text-transform: uppercase;
/project/internal/web/templates.go-571-    letter-spacing: 0.05em;
/project/internal/web/templates.go-572-    color: var(--text-muted);
--
/project/internal/web/templates.go-846-  <div class="log-container" id="log">
/project/internal/web/templates.go-847-    {{range .Blocks}}
/project/internal/web/templates.go-848-      {{if eq .Kind "reasoning"}}
/project/internal/web/templates.go-849-      <div class="block block-reasoning">
/project/internal/web/templates.go-850-        <div class="block-label">Thinking</div>
/project/internal/web/templates.go:851:        <div class="block-body">{{.Text}}</div>
/project/internal/web/templates.go-852-      </div>
/project/internal/web/templates.go-853-      {{else if eq .Kind "content"}}
/project/internal/web/templates.go-854-      <div class="block block-content">
/project/internal/web/templates.go:855:        <div class="block-body">{{.Text}}</div>
/project/internal/web/templates.go-856-      </div>
/project/internal/web/templates.go-857-      {{else if eq .Kind "tool"}}
/project/internal/web/templates.go-858-      <details class="block block-tool{{if .Tool.Error}} block-tool-error{{end}}">
/project/internal/web/templates.go-859-        <summary>
/project/internal/web/templates.go-860-          <span class="tool-badge">Tool</span>
/project/internal/web/templates.go-861-          <span class="tool-summary-text">
/project/internal/web/templates.go-862-            <span class="tool-name">🔧 {{.Tool.Name}}</span>
/project/internal/web/templates.go-863-            <span class="tool-args-preview">{{.Tool.Arguments}}</span>
/project/internal/web/templates.go-864-          </span>
/project/internal/web/templates.go-865-        </summary>
/project/internal/web/templates.go:866:        <div class="block-body">
/project/internal/web/templates.go-867-          <div class="tool-section-label">Arguments</div>
/project/internal/web/templates.go-868-          <pre>{{.Tool.Arguments}}</pre>
/project/internal/web/templates.go-869-          <div class="tool-section-label">Result</div>
/project/internal/web/templates.go-870-          <pre>{{.Tool.Result}}</pre>
/project/internal/web/templates.go-871-        </div>
/project/internal/web/templates.go-872-      </details>
/project/internal/web/templates.go-873-      {{else}}
/project/internal/web/templates.go-874-      <div class="block block-system">{{.Text}}</div>
/project/internal/web/templates.go-875-      {{end}}
/project/internal/web/templates.go-876-    {{end}}
--
/project/internal/web/templates.go-896-          l.className = "block-label";
/project/internal/web/templates.go-897-          l.textContent = label;
/project/internal/web/templates.go-898-          div.appendChild(l);
/project/internal/web/templates.go-899-        }
/project/internal/web/templates.go-900-        var body = document.createElement("div");
/project/internal/web/templates.go:901:        body.className = "block-body";
/project/internal/web/templates.go-902-        div.appendChild(body);
/project/internal/web/templates.go-903-        log.appendChild(div);
/project/internal/web/templates.go-904-        return body;
/project/internal/web/templates.go-905-      }
/project/internal/web/templates.go-906-
/project/internal/web/templates.go-907-      function newToolBlock(ev) {

{"end_line": 1004, "path": "internal/web/templates.go", "start_line": 820}

{"path":"internal/web/templates.go","content":"          {{.Job.Status}}\n        \u003c/span\u003e\n      \u003c/span\u003e\n    \u003c/div\u003e\n    \u003cdiv class=\"job-meta-item\"\u003e\n      \u003cspan class=\"label\"\u003eEvent\u003c/span\u003e\n      \u003cspan class=\"value\"\u003e{{.Job.EventKind}} on \u003ccode\u003e{{.Job.Owner}}/{{.Job.Repo}}#{{.Job.IssueIndex}}\u003c/code\u003e\u003c/span\u003e\n    \u003c/div\u003e\n    \u003cdiv class=\"job-meta-item\"\u003e\n      \u003cspan class=\"label\"\u003eAgent\u003c/span\u003e\n      \u003cspan class=\"value\"\u003e\n        \u003cspan class=\"agent\"\u003e\n          {{if .AvatarURL}}\u003cimg class=\"agent-avatar\" src=\"{{.AvatarURL}}\" alt=\"{{.Job.Agent}}\" title=\"{{.Job.Agent}}\"\u003e{{end}}\n          \u003cstrong\u003e{{.Job.Agent}}\u003c/strong\u003e\n        \u003c/span\u003e\n      \u003c/span\u003e\n    \u003c/div\u003e\n    {{if .Job.Error}}\n    \u003cdiv class=\"job-meta-item\"\u003e\n      \u003cspan class=\"label\"\u003eError\u003c/span\u003e\n      \u003cspan class=\"value error-text\"\u003e{{.Job.Error}}\u003c/span\u003e\n    \u003c/div\u003e\n    {{end}}\n  \u003c/div\u003e\n\n  \u003ch2\u003eLog\u003c/h2\u003e\n  \u003cdiv class=\"log-container\" id=\"log\"\u003e\n    {{range .Blocks}}\n      {{if eq .Kind \"reasoning\"}}\n      \u003cdiv class=\"block block-reasoning\"\u003e\n        \u003cdiv class=\"block-label\"\u003eThinking\u003c/div\u003e\n        \u003cdiv class=\"block-body\"\u003e{{.Text}}\u003c/div\u003e\n      \u003c/div\u003e\n      {{else if eq .Kind \"content\"}}\n      \u003cdiv class=\"block block-content\"\u003e\n        \u003cdiv class=\"block-body\"\u003e{{.Text}}\u003c/div\u003e\n      \u003c/div\u003e\n      {{else if eq .Kind \"tool\"}}\n      \u003cdetails class=\"block block-tool{{if .Tool.Error}} block-tool-error{{end}}\"\u003e\n        \u003csummary\u003e\n          \u003cspan class=\"tool-badge\"\u003eTool\u003c/span\u003e\n          \u003cspan class=\"tool-summary-text\"\u003e\n            \u003cspan class=\"tool-name\"\u003e🔧 {{.Tool.Name}}\u003c/span\u003e\n            \u003cspan class=\"tool-args-preview\"\u003e{{.Tool.Arguments}}\u003c/span\u003e\n          \u003c/span\u003e\n        \u003c/summary\u003e\n        \u003cdiv class=\"block-body\"\u003e\n          \u003cdiv class=\"tool-section-label\"\u003eArguments\u003c/div\u003e\n          \u003cpre\u003e{{.Tool.Arguments}}\u003c/pre\u003e\n          \u003cdiv class=\"tool-section-label\"\u003eResult\u003c/div\u003e\n          \u003cpre\u003e{{.Tool.Result}}\u003c/pre\u003e\n        \u003c/div\u003e\n      \u003c/details\u003e\n      {{else}}\n      \u003cdiv class=\"block block-system\"\u003e{{.Text}}\u003c/div\u003e\n      {{end}}\n    {{end}}\n  \u003c/div\u003e\n\n  {{if .Live}}\n  \u003cscript\u003e\n    (function() {\n      var jobID = {{.Job.ID}};\n      var log = document.getElementById(\"log\");\n      var reasoningBody = null;\n      var contentBody = null;\n\n      function nearBottom() {\n        return (window.innerHeight + window.scrollY) \u003e= (document.body.offsetHeight - 80);\n      }\n\n      function newBlock(kind, label) {\n        var div = document.createElement(\"div\");\n        div.className = \"block block-\" + kind;\n        if (label) {\n          var l = document.createElement(\"div\");\n          l.className = \"block-label\";\n          l.textContent = label;\n          div.appendChild(l);\n        }\n        var body = document.createElement(\"div\");\n        body.className = \"block-body\";\n        div.appendChild(body);\n        log.appendChild(div);\n        return body;\n      }\n\n      function newToolBlock(ev) {\n        var details = document.createElement(\"details\");\n        details.className = \"block block-tool\" + (ev.error ? \" block-tool-error\" : \"\");\n\n        var summary = document.createElement(\"summary\");\n\n        var badge = document.createElement(\"span\");\n        badge.className = \"tool-badge\";\n        badge.textContent = \"Tool\";\n\n        var text = document.createElement(\"span\");\n        text.className = \"tool-summary-text\";\n\n        var name = document.createElement(\"span\");\n        name.className = \"tool-name\";\n        name.textContent = \"🔧 \" + ev.name;\n\n        var preview = document.createElement(\"span\");\n        preview.className = \"tool-args-preview\";\n        preview.textContent = ev.arguments;\n\n        text.appendChild(name);\n        text.appendChild(preview);\n        summary.appendChild(badge);\n        summary.appendChild(text);\n        details.appendChild(summary);\n\n        var body = document.createElement(\"div\");\n        body.className = \"block-body\";\n\n        var argsLabel = document.createElement(\"div\");\n        argsLabel.className = \"tool-section-label\";\n        argsLabel.textContent = \"Arguments\";\n        var argsPre = document.createElement(\"pre\");\n        argsPre.textContent = ev.arguments;\n\n        var resultLabel = document.createElement(\"div\");\n        resultLabel.className = \"tool-section-label\";\n        resultLabel.textContent = \"Result\";\n        var resultPre = document.createElement(\"pre\");\n        resultPre.textContent = ev.result;\n\n        body.appendChild(argsLabel);\n        body.appendChild(argsPre);\n        body.appendChild(resultLabel);\n        body.appendChild(resultPre);\n        details.appendChild(body);\n        log.appendChild(details);\n      }\n\n      var es = new EventSource(\"/jobs/\" + jobID + \"/events\");\n\n      es.onmessage = function(e) {\n        var ev = JSON.parse(e.data);\n        var shouldScroll = nearBottom();\n\n        switch (ev.type) {\n          case \"reasoning_start\":\n            reasoningBody = newBlock(\"reasoning\", \"Thinking\");\n            break;\n          case \"reasoning_delta\":\n            if (reasoningBody) reasoningBody.textContent += ev.text;\n            break;\n          case \"reasoning_end\":\n            // Model output routinely starts/ends with newlines; drop them\n            // so the finished block matches the static (trimmed) view.\n            if (reasoningBody) reasoningBody.textContent = reasoningBody.textContent.trim();\n            reasoningBody = null;\n            break;\n          case \"content_start\":\n            contentBody = newBlock(\"content\", null);\n            break;\n          case \"content_delta\":\n            if (contentBody) contentBody.textContent += ev.text;\n            break;\n          case \"content_end\":\n            if (contentBody) contentBody.textContent = contentBody.textContent.trim();\n            contentBody = null;\n            break;\n          case \"tool\":\n            newToolBlock(ev);\n            break;\n          case \"status\":\n            es.close();\n            location.reload();\n            return;\n        }\n\n        if (shouldScroll) window.scrollTo(0, document.body.scrollHeight);\n      };\n    })();\n  \u003c/script\u003e\n  {{end}}\n\u003c/div\u003e\n\u003c/body\u003e\n\u003c/html\u003e\n{{end}}\n`","start_line":820,"end_line":1004,"total_lines":1004,"truncated":false}

{"end_line": 120, "path": "internal/agentrun/loop.go", "start_line": 1}

{"path":"internal/agentrun/loop.go","content":"package agentrun\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"io\"\n\n\t\"github.com/abrander/zoo/internal/llm\"\n\t\"github.com/abrander/zoo/internal/tools\"\n)\n\n// Hooks lets a caller observe a runLoop invocation live, as the model\n// streams and tool calls execute, in addition to the final []llm.Message\n// it returns. Any of these may be nil.\ntype Hooks struct {\n\t// OnReasoningDelta and OnContentDelta fire with just the newly\n\t// streamed text for the current turn, not the accumulated total.\n\tOnReasoningDelta func(delta string)\n\tOnContentDelta   func(delta string)\n\n\t// OnTurnEnd fires once per completed streamer round-trip, after the\n\t// model's message for that turn is fully received and before any of\n\t// its tool calls run.\n\tOnTurnEnd func()\n\n\t// OnTool fires once per tool call, after it has run.\n\tOnTool func(name, arguments, result string, toolErr bool)\n}\n\n// runLoop is a headless port of ../a's App.generate(): send messages +\n// tool defs, get a completion, run any tool_calls and append their\n// results, repeat until a plain finish or ctx is done.\nfunc runLoop(ctx context.Context, client *llm.Client, toolsCtx tools.Context, messages []llm.Message, hooks Hooks) ([]llm.Message, error) {\n\tfor {\n\t\tif err := ctx.Err(); err != nil {\n\t\t\treturn messages, err\n\t\t}\n\n\t\tstreamer, err := client.StreamChatCompletion(ctx, \u0026llm.ChatCompletionRequest{\n\t\t\tMessages: messages,\n\t\t\tStream:   true,\n\t\t\tTools:    tools.All(),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn messages, fmt.Errorf(\"chat completion: %w\", err)\n\t\t}\n\n\t\tvar completion *llm.ChatCompletion\n\n\t\tvar prevContent, prevReasoning string\n\n\t\tfor {\n\t\t\tc, err := streamer.Get()\n\t\t\tif err == io.EOF {\n\t\t\t\tbreak\n\t\t\t}\n\n\t\t\tif err != nil {\n\t\t\t\treturn messages, fmt.Errorf(\"stream completion: %w\", err)\n\t\t\t}\n\n\t\t\tcompletion = c\n\n\t\t\tif len(c.Choices) \u003e 0 {\n\t\t\t\tmsg := c.Choices[0].Message\n\n\t\t\t\tif hooks.OnReasoningDelta != nil \u0026\u0026 len(msg.ReasoningContent) \u003e len(prevReasoning) {\n\t\t\t\t\thooks.OnReasoningDelta(msg.ReasoningContent[len(prevReasoning):])\n\t\t\t\t}\n\t\t\t\tprevReasoning = msg.ReasoningContent\n\n\t\t\t\tif hooks.OnContentDelta != nil \u0026\u0026 len(msg.Content) \u003e len(prevContent) {\n\t\t\t\t\thooks.OnContentDelta(msg.Content[len(prevContent):])\n\t\t\t\t}\n\t\t\t\tprevContent = msg.Content\n\t\t\t}\n\t\t}\n\n\t\tif hooks.OnTurnEnd != nil {\n\t\t\thooks.OnTurnEnd()\n\t\t}\n\n\t\tif completion == nil || len(completion.Choices) == 0 {\n\t\t\treturn messages, fmt.Errorf(\"model returned an empty completion\")\n\t\t}\n\n\t\tchoice := completion.Choices[0]\n\t\tmessages = append(messages, choice.Message)\n\n\t\tif choice.FinishReason != \"tool_calls\" || len(choice.Message.ToolCalls) == 0 {\n\t\t\treturn messages, nil\n\t\t}\n\n\t\tfor _, tc := range choice.Message.ToolCalls {\n\t\t\tif err := ctx.Err(); err != nil {\n\t\t\t\treturn messages, err\n\t\t\t}\n\n\t\t\tresult, err := tools.Call(toolsCtx, tc.FunctionCall)\n\n\t\t\ttoolErr := err != nil\n\t\t\tif toolErr {\n\t\t\t\tresult = fmt.Sprintf(\"ERROR CALLING TOOL: %s\", err.Error())\n\t\t\t}\n\n\t\t\tif hooks.OnTool != nil {\n\t\t\t\thooks.OnTool(tc.FunctionCall.Name, tc.FunctionCall.Arguments, result, toolErr)\n\t\t\t}\n\n\t\t\tmessages = append(messages, llm.Message{\n\t\t\t\tRole:       \"tool\",\n\t\t\t\tContent:    result,\n\t\t\t\tToolCallID: tc.Id,\n\t\t\t\tName:       tc.FunctionCall.Name,\n\t\t\t})\n\t\t}\n\t}\n}","start_line":1,"end_line":118,"total_lines":118,"truncated":false}

{"end_line": 150, "path": "internal/agentrun/run.go", "start_line": 1}

{"path":"internal/agentrun/run.go","content":"// Package agentrun creates the throwaway per-job environment an agent\n// runs in: a Docker container with the agent's git working tree cloned\n// inside it (authenticated with the agent's own Forgejo token), the\n// triggering event written to /event, and the tool-calling loop\n// (internal/llm + internal/tools) driven against it.\npackage agentrun\n\nimport (\n\t\"context\"\n\t_ \"embed\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log/slog\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n\t\"github.com/abrander/zoo/internal/forgejo\"\n\t\"github.com/abrander/zoo/internal/livelog\"\n\t\"github.com/abrander/zoo/internal/llm\"\n\t\"github.com/abrander/zoo/internal/store\"\n)\n\n//go:embed system.md\nvar defaultSystemPrompt string\n\n// DefaultTimeout bounds a single agent run's wall-clock time if the\n// caller doesn't override it.\nconst DefaultTimeout = 120 * time.Minute\n\ntype Runner struct {\n\tdocker        *dockerRuntime\n\tforgejo       *forgejo.Client\n\tstore         *store.Store\n\thub           *livelog.Hub\n\tcfg           *config.Config\n\tlogger        *slog.Logger\n\ttimeout       time.Duration\n\tkeepOnFailure bool\n\n\tagentClientsMu sync.Mutex\n\tagentClients   map[string]*forgejo.Client\n}\n\nfunc NewRunner(cfg *config.Config, fg *forgejo.Client, st *store.Store, hub *livelog.Hub, logger *slog.Logger, timeout time.Duration, keepOnFailure bool) (*Runner, error) {\n\tdocker, err := newDockerRuntime()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tif timeout \u003c= 0 {\n\t\ttimeout = DefaultTimeout\n\t}\n\n\treturn \u0026Runner{\n\t\tdocker:        docker,\n\t\tforgejo:       fg,\n\t\tstore:         st,\n\t\thub:           hub,\n\t\tcfg:           cfg,\n\t\tlogger:        logger,\n\t\ttimeout:       timeout,\n\t\tkeepOnFailure: keepOnFailure,\n\t\tagentClients:  make(map[string]*forgejo.Client),\n\t}, nil\n}\n\n// forgejoAs returns a Forgejo client that authenticates as the given\n// agent (using the agent's own token from config). This lets each agent\n// act as themselves on Forgejo without needing a global token with sudo\n// privileges. Clients are built once per agent and cached, since\n// constructing one costs an extra API round trip.\n//\n// If the agent has no token configured, falls back to the shared zoo\n// identity so existing deployments without per-agent tokens still work.\nfunc (r *Runner) forgejoAs(agentName, token string) *forgejo.Client {\n\tr.agentClientsMu.Lock()\n\tdefer r.agentClientsMu.Unlock()\n\n\tif c, ok := r.agentClients[agentName]; ok {\n\t\treturn c\n\t}\n\n\tvar c *forgejo.Client\n\tif token != \"\" {\n\t\tc = r.forgejo.As(token)\n\t} else {\n\t\t// Fallback: use shared identity. Optionally log a warning\n\t\t// if we ever want to enforce per-agent tokens.\n\t\tc = r.forgejo\n\t}\n\n\tr.agentClients[agentName] = c\n\n\treturn c\n}\n\n// Run implements scheduler.Runner.\nfunc (r *Runner) Run(ctx context.Context, jobID string, agent config.AgentConfig, llmCfg config.LLM, dockerImage string, ev forgejo.Event) error {\n\tctx, cancel := context.WithTimeout(ctx, r.timeout)\n\tdefer cancel()\n\n\tlogger := r.logger.With(\"job\", jobID, \"agent\", agent.Name)\n\n\trepoInfo, err := r.forgejo.RepositoryInfo(ev.Owner, ev.Repo)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"look up repository: %w\", err)\n\t}\n\n\tworkDir, err := os.MkdirTemp(\"\", \"zoo-run-*\")\n\tif err != nil {\n\t\treturn fmt.Errorf(\"create work dir: %w\", err)\n\t}\n\n\tsucceeded := false\n\n\tdefer func() {\n\t\tif succeeded || !r.keepOnFailure {\n\t\t\tos.RemoveAll(workDir)\n\t\t} else {\n\t\t\tlogger.Warn(\"keeping work dir after failure\", \"dir\", workDir)\n\t\t}\n\t}()\n\n\t// The container bind-mounts projectDir as /project and does the\n\t// initial clone into it, so the (empty) directory must exist on the\n\t// host before the container is created — otherwise Docker would\n\t// create it itself, root-owned.\n\tprojectDir := filepath.Join(workDir, \"project\")\n\n\tif err := os.MkdirAll(projectDir, 0o755); err != nil {\n\t\treturn fmt.Errorf(\"create project dir: %w\", err)\n\t}\n\n\t// A pr:review run works on the PR's own head branch, so the agent's\n\t// commits push straight to the PR. Every other event kind branches\n\t// off the default branch as usual.\n\tvar review *forgejo.ReviewDetail\n\tbranch := fmt.Sprintf(\"issue-%d-%s\", ev.Index, agent.Name)\n\n\tif ev.Kind == forgejo.EventPRReview {\n\t\t// Always fetch the current head ref, not just when the event\n\t\t// lacks one (the polling path doesn't carry it): the webhook's\n\t\t// copy could be stale if the PR's head branch was renamed since\n\t\t// the review, and the push target depends on it.\n\t\theadRef := ev.HeadRef\n","start_line":1,"end_line":150,"total_lines":437,"truncated":true}

{"end_line": 437, "path": "internal/agentrun/run.go", "start_line": 150}

{"path":"internal/agentrun/run.go","content":"\n\t\tif prInfo, err := r.forgejo.PullRequestInfo(ev.Owner, ev.Repo, ev.Index); err != nil {\n\t\t\tlogger.Warn(\"fetch pull request head failed; falling back to the event's head ref\", \"error\", err)\n\t\t} else if prInfo.HeadRef != \"\" {\n\t\t\theadRef = prInfo.HeadRef\n\t\t}\n\n\t\tif headRef == \"\" {\n\t\t\treturn fmt.Errorf(\"pr:review event has no pull request head branch to check out\")\n\t\t}\n\n\t\tbranch = headRef\n\n\t\t// Fetch the full review (verdict, body, inline comments) so the\n\t\t// agent sees all the feedback, not just the triggering event. A\n\t\t// failure degrades to no review detail rather than failing the\n\t\t// run: the agent can still do its job, just without the inline\n\t\t// comments.\n\t\treview, err = r.forgejo.ReviewDetail(ev.Owner, ev.Repo, ev.Index, ev.ReviewID)\n\t\tif err != nil {\n\t\t\tlogger.Warn(\"fetch review detail failed; agent will not see inline review comments\", \"error\", err)\n\t\t\treview = nil\n\t\t}\n\t}\n\n\troster := buildRoster(r.forgejo, r.cfg.Agents, logger)\n\tgitName, gitEmail := gitIdentity(agent.Name, roster)\n\n\t// The credential the sandbox's git uses for remote operations: the\n\t// agent's own Forgejo token when configured, so its git activity is\n\t// attributed to its own account, falling back to the shared zoo\n\t// identity for deployments without per-agent tokens (mirroring\n\t// forgejoAs).\n\tgitUser, gitToken := \"zoo\", r.forgejo.Token()\n\n\tif agent.Token != \"\" {\n\t\tgitUser, gitToken = agent.Name, agent.Token\n\t}\n\n\teventPath := filepath.Join(workDir, \"event.json\")\n\tif err := os.WriteFile(eventPath, ev.Raw, 0o644); err != nil {\n\t\treturn fmt.Errorf(\"write event file: %w\", err)\n\t}\n\n\tcontainerID, err := r.docker.createContainer(ctx, dockerImage, []string{\n\t\tprojectDir + \":/project\",\n\t\teventPath + \":/event:ro\",\n\t}, fmt.Sprintf(\"zoo-issue-%d-%s\", ev.Index, agent.Name))\n\tif err != nil {\n\t\treturn fmt.Errorf(\"start container: %w\", err)\n\t}\n\n\tdefer func() {\n\t\tcleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 30*time.Second)\n\t\tdefer cleanupCancel()\n\t\tif err := r.docker.remove(cleanupCtx, containerID); err != nil {\n\t\t\tlogger.Warn(\"failed to remove container\", \"container\", containerID, \"error\", err)\n\t\t}\n\t}()\n\n\t// Git must simply work inside the sandbox: safe.directory, commit\n\t// identity, and the remote credential all go into the container's\n\t// system gitconfig (see configureSandboxGit).\n\tif err := configureSandboxGit(ctx, r.docker, containerID, repoInfo.CloneURL, gitUser, gitToken, gitName, gitEmail); err != nil {\n\t\treturn fmt.Errorf(\"configure git in container: %w\", err)\n\t}\n\n\t// The initial clone happens inside the sandbox, so the working tree\n\t// is owned by the container's user and git never runs on the host.\n\tif ev.Kind == forgejo.EventPRReview {\n\t\tif err := clonePRHead(ctx, r.docker, containerID, repoInfo.CloneURL, repoInfo.DefaultBranch, branch, ev.Index); err != nil {\n\t\t\treturn fmt.Errorf(\"prepare git working tree: %w\", err)\n\t\t}\n\t} else {\n\t\tif err := cloneAndBranch(ctx, r.docker, containerID, repoInfo.CloneURL, repoInfo.DefaultBranch, branch); err != nil {\n\t\t\treturn fmt.Errorf(\"prepare git working tree: %w\", err)\n\t\t}\n\t}\n\n\tlogAppend := func(stream, line string) {\n\t\tif err := r.store.AppendLog(context.Background(), jobID, stream, line); err != nil {\n\t\t\tlogger.Warn(\"failed to append log\", \"error\", err)\n\t\t}\n\t}\n\n\trunCtx := \u0026runContext{\n\t\tdocker:      r.docker,\n\t\tcontainerID: containerID,\n\t\tforgejo: \u0026runForgejoActions{\n\t\t\tclient: r.forgejoAs(agent.Name, agent.Token),\n\t\t\towner:  ev.Owner,\n\t\t\trepo:   ev.Repo,\n\t\t\tindex:  ev.Index,\n\t\t\tlogger: logger,\n\t\t},\n\t}\n\n\tllmClient := llm.NewClient(llmCfg)\n\n\tsystemPrompt := defaultSystemPrompt + identitySection(agent.Name, roster)\n\n\tinstructions := r.cfg.EventInstructions(ev.Kind)\n\n\t// Fetch the full comment thread so the agent sees everything that's\n\t// been said on the issue/PR, not just the triggering event (which\n\t// only carries the latest comment, if any). A failure degrades to\n\t// no comments rather than failing the run: the agent can still do\n\t// its job, just without prior context.\n\tcomments, err := r.forgejo.ListIssueComments(ev.Owner, ev.Repo, ev.Index)\n\tif err != nil {\n\t\tlogger.Warn(\"fetch issue comments failed; agent will not see prior comments\", \"error\", err)\n\t\tcomments = nil\n\t}\n\n\tmessages := []llm.Message{\n\t\t{Role: \"system\", Content: systemPrompt},\n\t\t{Role: \"user\", Content: seedMessage(ev, branch, repoInfo.DefaultBranch, instructions, comments, review)},\n\t}\n\n\thooks := r.streamHooks(jobID, logAppend)\n\n\t_, err = runLoop(ctx, llmClient, runCtx, messages, hooks)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"agent loop: %w\", err)\n\t}\n\n\tsucceeded = true\n\n\treturn nil\n}\n\n// streamHooks builds the Hooks a single Run passes to runLoop: every\n// delta is published live to the hub for connected dashboard viewers,\n// and once a reasoning/content block or tool call is complete, it's\n// persisted to the store as one row and the hub's replay buffer for\n// jobID is checkpointed — so a viewer connecting from this point on\n// sees it via the persisted history instead of a live replay, and is\n// never shown it twice.\nfunc (r *Runner) streamHooks(jobID string, logAppend func(stream, line string)) Hooks {\n\tvar reasoningBuf, contentBuf strings.Builder\n\n\treasoningOpen, contentOpen := false, false\n\n\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},\n\t\tOnTool: func(name, arguments, result string, toolErr bool) {\n\t\t\tr.hub.Publish(jobID, livelog.Event{\n\t\t\t\tType:      livelog.Tool,\n\t\t\t\tName:      name,\n\t\t\t\tArguments: arguments,\n\t\t\t\tResult:    result,\n\t\t\t\tError:     toolErr,\n\t\t\t})\n\n\t\t\tline, err := json.Marshal(store.ToolLogEntry{Name: name, Arguments: arguments, Result: result, Error: toolErr})\n\t\t\tif err != nil {\n\t\t\t\tr.logger.Warn(\"failed to marshal tool log entry\", \"job\", jobID, \"error\", err)\n\t\t\t} else {\n\t\t\t\tlogAppend(\"tool\", string(line))\n\t\t\t}\n\n\t\t\tr.hub.Checkpoint(jobID)\n\t\t},\n\t}\n}\n\nfunc seedMessage(ev forgejo.Event, branch, defaultBranch, instructions string, comments []forgejo.IssueComment, review *forgejo.ReviewDetail) string {\n\traw, _ := json.MarshalIndent(json.RawMessage(ev.Raw), \"\", \"  \")\n\n\tvar instructionsSection string\n\tif instructions != \"\" {\n\t\tinstructionsSection = fmt.Sprintf(\"Instructions for this event, from zoo.hcl:\\n%s\\n\\n\", instructions)\n\t}\n\n\t// A pr:review run works on the PR's own head branch, not a fresh\n\t// branch off the default branch.\n\tbranchLine := fmt.Sprintf(\"Your working branch is %q, checked out from the default branch %q.\\n\\n\", branch, defaultBranch)\n\tif ev.Kind == forgejo.EventPRReview {\n\t\tbranchLine = 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)\n\t}\n\n\tvar reviewSection string\n\tif review != nil {\n\t\treviewSection = renderReviewSection(review)\n\t}\n\n\tvar commentsSection string\n\tif len(comments) \u003e 0 {\n\t\tvar b strings.Builder\n\t\tfmt.Fprintf(\u0026b, \"Comments (%d):\\n\\n\", len(comments))\n\n\t\tfor i, c := range comments {\n\t\t\tfmt.Fprintf(\u0026b, \"%d. %s (%s):\\n%s\\n\\n\", i+1, c.Author, c.Created.Format(time.RFC3339), c.Body)\n\t\t}\n\n\t\tcommentsSection = b.String()\n\t}\n\n\treturn fmt.Sprintf(\n\t\t\"You were triggered by a %q event on %s/%s.\\n\\n\"+\n\t\t\t\"%s%s\"+\n\t\t\t\"%sTitle: %s\\n\\nBody:\\n%s\\n\\n%sFull event payload:\\n```json\\n%s\\n```\",\n\t\tev.Kind, ev.Owner, ev.Repo, instructionsSection, branchLine, reviewSection, ev.Title, ev.Body, commentsSection, raw)\n}\n\n// renderReviewSection renders the submitted review as a briefing\n// section: the verdict, the review body, and each inline comment with\n// its location and id (the id lets the agent refer to a specific\n// comment in its reply).\nfunc renderReviewSection(review *forgejo.ReviewDetail) string {\n\tvar b strings.Builder\n\n\tfmt.Fprintf(\u0026b, \"Review submitted by %s:\\n\", review.Reviewer)\n\tfmt.Fprintf(\u0026b, \"  Verdict: %s\\n\", humanReviewState(review.State))\n\n\tif review.Body != \"\" {\n\t\tb.WriteString(\"  Review body:\\n\")\n\t\tfor _, line := range strings.Split(review.Body, \"\\n\") {\n\t\t\tfmt.Fprintf(\u0026b, \"  %s\\n\", line)\n\t\t}\n\t}\n\n\tif len(review.Comments) \u003e 0 {\n\t\tfmt.Fprintf(\u0026b, \"  Inline comments (%d):\\n\", len(review.Comments))\n\n\t\tfor i, c := range review.Comments {\n\t\t\twhere := c.Path\n\t\t\tif c.Line \u003e 0 {\n\t\t\t\twhere = fmt.Sprintf(\"%s:%d\", c.Path, c.Line)\n\t\t\t}\n\n\t\t\tfmt.Fprintf(\u0026b, \"  %d. [%s] %s (comment id %d):\\n\", i+1, where, c.Author, c.ID)\n\t\t\tfor _, line := range strings.Split(c.Body, \"\\n\") {\n\t\t\t\tfmt.Fprintf(\u0026b, \"     %s\\n\", line)\n\t\t\t}\n\t\t}\n\t}\n\n\treturn b.String() + \"\\n\"\n}\n\n// humanReviewState maps a Forgejo review state to a readable verdict.\nfunc humanReviewState(state string) string {\n\tswitch state {\n\tcase \"APPROVED\":\n\t\treturn \"approved\"\n\tcase \"REQUEST_CHANGES\":\n\t\treturn \"changes requested\"\n\tcase \"COMMENT\":\n\t\treturn \"comment\"\n\tdefault:\n\t\treturn state\n\t}\n}","start_line":150,"end_line":437,"total_lines":437,"truncated":false}

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

{"path":"internal/livelog/hub.go","content":"func (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":100,"end_line":164,"total_lines":164,"truncated":false}

{"command": "cd /project && git show b75b64d --stat && git show b75b64d | head -200"}

commit b75b64d1995a088c2c1427f8a6e965b449d14884
Author: Greg Coolio <greg@example.com>
Date:   Tue Aug 25 21:44:52 2026 +0000

    Fix excessive vertical space in job view blocks
    
    Model reasoning/content output routinely starts/ends with newlines,
    which white-space: pre-wrap in .block-body renders as visible blank
    lines, inflating each block's height.
    
    Trim leading/trailing whitespace for display in buildBlocks (internal
    newlines are preserved; whitespace-only blocks are dropped entirely),
    and trim the accumulated text in the live SSE view when a block ends
    so it matches the static view. The stored log keeps the raw model
    output; this is a display-layer fix, so existing jobs are covered too.
    
    Fixes #53

 internal/web/templates.go |  4 ++++
 internal/web/web.go       | 12 +++++++++++-
 internal/web/web_test.go  | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 62 insertions(+), 1 deletion(-)
commit b75b64d1995a088c2c1427f8a6e965b449d14884
Author: Greg Coolio <greg@example.com>
Date:   Tue Aug 25 21:44:52 2026 +0000

    Fix excessive vertical space in job view blocks
    
    Model reasoning/content output routinely starts/ends with newlines,
    which white-space: pre-wrap in .block-body renders as visible blank
    lines, inflating each block's height.
    
    Trim leading/trailing whitespace for display in buildBlocks (internal
    newlines are preserved; whitespace-only blocks are dropped entirely),
    and trim the accumulated text in the live SSE view when a block ends
    so it matches the static view. The stored log keeps the raw model
    output; this is a display-layer fix, so existing jobs are covered too.
    
    Fixes #53

diff --git a/internal/web/templates.go b/internal/web/templates.go
index dd63248..c64e61b 100644
--- a/internal/web/templates.go
+++ b/internal/web/templates.go
@@ -968,6 +968,9 @@ const templates = `
             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":
@@ -977,6 +980,7 @@ const templates = `
             if (contentBody) contentBody.textContent += ev.text;
             break;
           case "content_end":
+            if (contentBody) contentBody.textContent = contentBody.textContent.trim();
             contentBody = null;
             break;
           case "tool":
diff --git a/internal/web/web.go b/internal/web/web.go
index eeec747..55ab97f 100644
--- a/internal/web/web.go
+++ b/internal/web/web.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"html/template"
 	"net/http"
+	"strings"
 	"sync"
 	"time"
 
@@ -210,7 +211,16 @@ func buildBlocks(logs []store.LogLine) []block {
 	for _, l := range logs {
 		switch l.Stream {
 		case "reasoning", "content":
-			blocks = append(blocks, block{Kind: l.Stream, Text: l.Line})
+			// 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
diff --git a/internal/web/web_test.go b/internal/web/web_test.go
index 88974a8..ded09b2 100644
--- a/internal/web/web_test.go
+++ b/internal/web/web_test.go
@@ -104,6 +104,53 @@ func TestJobsAndDetail(t *testing.T) {
 	}
 }
 
+// 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)
+	}
+}
+
 func TestAuthGate(t *testing.T) {
 	st, err := store.Open(filepath.Join(t.TempDir(), "zoo.db"))
 	if err != nil {

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

{"path":"internal/scheduler/scheduler.go","content":"// Package scheduler resolves incoming Forgejo events to configured\n// agents and runs them, bounded by max_live_agents.\npackage scheduler\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"log/slog\"\n\t\"sync\"\n\n\t\"github.com/google/uuid\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n\t\"github.com/abrander/zoo/internal/forgejo\"\n\t\"github.com/abrander/zoo/internal/livelog\"\n\t\"github.com/abrander/zoo/internal/store\"\n)\n\n// forgejoActions is the narrow slice of Client the scheduler needs for\n// its own failure-reporting side effects (defined here, not in\n// internal/forgejo, so tests can inject a fake).\ntype forgejoActions interface {\n\tCreateIssueComment(owner, repo string, index int64, body string) error\n\tAddLabel(owner, repo string, index int64, name string) error\n}\n\n// FailureLabel is applied to the triggering issue/PR, alongside a\n// comment, whenever an agent run fails or times out.\nconst FailureLabel = \"zoo:failed\"\n\n// Runner runs a single agent invocation to completion. Implemented by\n// internal/agentrun.Run; a narrow interface here so the scheduler is\n// testable without Docker.\ntype Runner interface {\n\tRun(ctx context.Context, jobID string, agent config.AgentConfig, llm config.LLM, dockerImage string, ev forgejo.Event) error\n}\n\ntype Scheduler struct {\n\tcfg     *config.Config\n\tstore   *store.Store\n\tforgejo forgejoActions\n\trunner  Runner\n\thub     *livelog.Hub\n\tlogger  *slog.Logger\n\n\tsem chan struct{}\n\twg  sync.WaitGroup\n}\n\nfunc New(cfg *config.Config, st *store.Store, fg forgejoActions, runner Runner, hub *livelog.Hub, logger *slog.Logger) *Scheduler {\n\treturn \u0026Scheduler{\n\t\tcfg:     cfg,\n\t\tstore:   st,\n\t\tforgejo: fg,\n\t\trunner:  runner,\n\t\thub:     hub,\n\t\tlogger:  logger,\n\t\tsem:     make(chan struct{}, cfg.Environment.MaxLive),\n\t}\n}\n\n// resolveAgent returns the name of the agent that should handle ev, if\n// any. Two kinds resolve dynamically: issue:assigned to the agent whose\n// config label matches the Forgejo assignee's username, and pr:review to\n// the agent whose config label matches the pull request author's\n// username (the agent that opened the PR reacts to the review of it).\n// Every other event kind uses the static event-\u003eagent mapping from\n// config.\nfunc resolveAgent(cfg *config.Config, ev forgejo.Event) (string, bool) {\n\tswitch ev.Kind {\n\tcase config.EventIssueAssigned:\n\t\tif _, ok := cfg.AgentByName(ev.Assignee); ok {\n\t\t\treturn ev.Assignee, true\n\t\t}\n\n\t\treturn \"\", false\n\n\tcase config.EventPRReview:\n\t\tif _, ok := cfg.AgentByName(ev.PRAuthor); ok {\n\t\t\treturn ev.PRAuthor, true\n\t\t}\n\n\t\treturn \"\", false\n\t}\n\n\treturn cfg.EventAgent(ev.Kind)\n}\n\n// Run consumes events until ctx is canceled or the channel closes,\n// dispatching each to its resolved agent and blocking on the\n// max_live_agents semaphore before starting a run.\nfunc (s *Scheduler) Run(ctx context.Context, events \u003c-chan forgejo.Event) {\n\tfor {\n\t\tselect {\n\t\tcase \u003c-ctx.Done():\n\t\t\treturn\n\n\t\tcase ev, ok := \u003c-events:\n\t\t\tif !ok {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\ts.handle(ctx, ev)\n\t\t}\n\t}\n}\n\nfunc (s *Scheduler) handle(ctx context.Context, ev forgejo.Event) {\n\tagentName, ok := resolveAgent(s.cfg, ev)\n\tif !ok {\n\t\ts.logger.Debug(\"no agent resolved for event, dropping\", \"kind\", ev.Kind, \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index)\n\t\treturn\n\t}\n\n\t// An agent's own actions (e.g. a comment posted via the `comment`\n\t// tool, authenticated with its own per-agent token) can themselves\n\t// show up as new events. Don't let an agent trigger itself off its\n\t// own activity — that's a self-reinforcing loop, not new work.\n\tif ev.Author != \"\" \u0026\u0026 ev.Author == agentName {","start_line":1,"end_line":120,"total_lines":252,"truncated":true}

{"end_line": 252, "path": "internal/scheduler/scheduler.go", "start_line": 120}

{"path":"internal/scheduler/scheduler.go","content":"\tif ev.Author != \"\" \u0026\u0026 ev.Author == agentName {\n\t\ts.logger.Debug(\"dropping event authored by the agent it would trigger\", \"kind\", ev.Kind, \"agent\", agentName, \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index)\n\t\treturn\n\t}\n\n\tagent, ok := s.cfg.AgentByName(agentName)\n\tif !ok {\n\t\ts.logger.Error(\"resolved agent not declared in config\", \"agent\", agentName)\n\t\treturn\n\t}\n\n\tllm, ok := s.cfg.LLMByName(agent.LLM)\n\tif !ok {\n\t\ts.logger.Error(\"agent references undeclared llm\", \"agent\", agentName, \"llm\", agent.LLM)\n\t\treturn\n\t}\n\n\tjobID := uuid.NewString()\n\n\tif err := s.store.CreateJob(ctx, store.Job{\n\t\tID:         jobID,\n\t\tEventKind:  ev.Kind,\n\t\tAgent:      agentName,\n\t\tOwner:      ev.Owner,\n\t\tRepo:       ev.Repo,\n\t\tIssueIndex: ev.Index,\n\t\tTitle:      ev.Title,\n\t}); err != nil {\n\t\ts.logger.Error(\"failed to record job\", \"job\", jobID, \"error\", err)\n\t\treturn\n\t}\n\n\tselect {\n\tcase s.sem \u003c- struct{}{}:\n\n\tcase \u003c-ctx.Done():\n\t\treturn\n\t}\n\n\ts.wg.Add(1)\n\n\tgo func() {\n\t\tdefer s.wg.Done()\n\t\tdefer func() { \u003c-s.sem }()\n\n\t\ts.run(ctx, jobID, agent, llm, ev)\n\t}()\n}\n\nfunc (s *Scheduler) run(ctx context.Context, jobID string, agent config.AgentConfig, llm config.LLM, ev forgejo.Event) {\n\tlogger := s.logger.With(\"job\", jobID, \"agent\", agent.Name, \"event\", ev.Kind, \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index)\n\n\t// Job status writes use a context detached from ctx, not ctx itself:\n\t// ctx is canceled on daemon shutdown to unwind the in-flight run, and\n\t// an already-canceled ctx would make these UPDATEs fail instantly,\n\t// leaving the job stuck at \"running\" forever even though the process\n\t// has exited.\n\tif err := s.store.MarkJobStarted(context.Background(), jobID); err != nil {\n\t\tlogger.Error(\"failed to mark job started\", \"error\", err)\n\t}\n\n\tlogger.Info(\"agent run starting\")\n\n\terr := s.runner.Run(ctx, jobID, agent, llm, s.cfg.Environment.DockerImage, ev)\n\n\tstatus := store.JobSucceeded\n\terrMsg := \"\"\n\n\tif err != nil {\n\t\terrMsg = err.Error()\n\t\t// The daemon-wide ctx passed in here isn't what times a run out\n\t\t// (agentrun.Runner.Run applies its own per-run deadline\n\t\t// internally); a timed-out run surfaces as a wrapped\n\t\t// context.DeadlineExceeded in the returned error instead.\n\t\tif errors.Is(err, context.DeadlineExceeded) {\n\t\t\tstatus = store.JobTimedOut\n\t\t} else {\n\t\t\tstatus = store.JobFailed\n\t\t}\n\n\t\tlogger.Error(\"agent run failed\", \"status\", status, \"error\", err)\n\t\ts.reportFailure(ev, status, err)\n\t} else {\n\t\tlogger.Info(\"agent run succeeded\")\n\t}\n\n\tif err := s.store.MarkJobFinished(context.Background(), jobID, status, errMsg); err != nil {\n\t\tlogger.Error(\"failed to mark job finished\", \"error\", err)\n\t}\n\n\t// Closing the hub here, only after the terminal status is durably\n\t// written, is what lets a dashboard tab's auto-reload (triggered by\n\t// this Close) see the finished status immediately. Closing it inside\n\t// Runner.Run instead — before this status write — raced a fast\n\t// reload against MarkJobFinished: the reloaded page could still see\n\t// \"running\", open a fresh SSE subscription against a hub entry that\n\t// no longer exists, and be stuck showing a stale status forever.\n\ts.hub.Close(jobID)\n}\n\n// reportFailure implements the locked-in failure policy: comment on the\n// triggering issue/PR with an error summary, and apply FailureLabel.\nfunc (s *Scheduler) reportFailure(ev forgejo.Event, status store.JobStatus, runErr error) {\n\tbody := fmt.Sprintf(\"zoo agent run %s: %s\", status, runErr.Error())\n\n\tif err := s.forgejo.CreateIssueComment(ev.Owner, ev.Repo, ev.Index, body); err != nil {\n\t\ts.logger.Error(\"failed to post failure comment\", \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index, \"error\", err)\n\t}\n\n\tif err := s.forgejo.AddLabel(ev.Owner, ev.Repo, ev.Index, FailureLabel); err != nil {\n\t\ts.logger.Error(\"failed to add failure label\", \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index, \"error\", err)\n\t}\n}\n\n// Shutdown stops accepting new work is the caller's responsibility (stop\n// feeding Run's channel); Shutdown just waits for in-flight runs, up to\n// ctx's deadline.\nfunc (s *Scheduler) Shutdown(ctx context.Context) error {\n\tdone := make(chan struct{})\n\n\tgo func() {\n\t\ts.wg.Wait()\n\t\tclose(done)\n\t}()\n\n\tselect {\n\tcase \u003c-done:\n\t\treturn nil\n\n\tcase \u003c-ctx.Done():\n\t\treturn ctx.Err()\n\t}\n}","start_line":120,"end_line":252,"total_lines":252,"truncated":false}

{"end_line": 120, "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": 120, "path": "internal/llm/types.go", "start_line": 1}

{"path":"internal/llm/types.go","content":"// Package llm is an OpenAI-compatible chat completions client with\n// streaming and tool-call support, ported from ../a's llamacpp package.\npackage llm\n\nimport \"fmt\"\n\ntype Message struct {\n\tContent          string     `json:\"content\"`\n\tRole             string     `json:\"role\"`\n\tReasoningContent string     `json:\"reasoning_content,omitempty\"`\n\tToolCalls        []ToolCall `json:\"tool_calls,omitempty\"`\n\tToolCallID       string     `json:\"tool_call_id,omitempty\"`\n\tName             string     `json:\"name,omitempty\"`\n}\n\nfunc (m *Message) String() string {\n\tstr := fmt.Sprintf(\"Role: %s, Content: %s ReasoningContent: %s\", m.Role, m.Content, m.ReasoningContent)\n\n\tfor _, call := range m.ToolCalls {\n\t\tstr += fmt.Sprintf(\"\\n  ToolCall: %s\", call.String())\n\t}\n\n\treturn str\n}\n\n// Merge folds a streamed delta into the accumulated message.\nfunc (m *Message) Merge(next *Message) {\n\tm.Content += next.Content\n\n\tif next.Role != \"\" {\n\t\tm.Role = next.Role\n\t}\n\n\tm.ReasoningContent += next.ReasoningContent\n\n\tminLength := 0\n\tfor _, choice := range next.ToolCalls {\n\t\tif choice.Index+1 \u003e minLength {\n\t\t\tminLength = choice.Index + 1\n\t\t}\n\t}\n\n\tif len(m.ToolCalls) \u003c minLength {\n\t\tnewToolCalls := make([]ToolCall, minLength)\n\t\tcopy(newToolCalls, m.ToolCalls)\n\t\tm.ToolCalls = newToolCalls\n\t}\n\n\tfor _, nextChoice := range next.ToolCalls {\n\t\tm.ToolCalls[nextChoice.Index].Merge(\u0026nextChoice)\n\t}\n}\n\ntype FunctionCall struct {\n\tName      string `json:\"name\"`\n\tArguments string `json:\"arguments\"`\n}\n\ntype ToolCall struct {\n\tType         string       `json:\"type\"`\n\tId           string       `json:\"id\"`\n\tIndex        int          `json:\"index\"`\n\tName         string       `json:\"name\"`\n\tFunctionCall FunctionCall `json:\"function\"`\n}\n\nfunc (t *ToolCall) String() string {\n\treturn fmt.Sprintf(\"Type: %s, Id: %s, Index: %d, Name: %s, FunctionCall: {Name: %s, Arguments: %s}\",\n\t\tt.Type, t.Id, t.Index, t.Name, t.FunctionCall.Name, t.FunctionCall.Arguments)\n}\n\nfunc (t *ToolCall) Merge(next *ToolCall) {\n\tif next.Type != \"\" {\n\t\tt.Type = next.Type\n\t}\n\n\tif next.Id != \"\" {\n\t\tt.Id = next.Id\n\t}\n\n\tif next.Name != \"\" {\n\t\tt.Name = next.Name\n\t}\n\n\tt.Index = next.Index\n\n\tif next.FunctionCall.Name != \"\" {\n\t\tt.FunctionCall.Name = next.FunctionCall.Name\n\t}\n\n\tt.FunctionCall.Arguments += next.FunctionCall.Arguments\n}\n\ntype Property struct {\n\tType        string    `json:\"type\"`\n\tDescription string    `json:\"description,omitempty\"`\n\tEnum        []string  `json:\"enum,omitempty\"`\n\tItems       *Property `json:\"items,omitempty\"`\n}\n\ntype Parameters struct {\n\tType       string              `json:\"type\"` // object\n\tProperties map[string]Property `json:\"properties,omitempty\"`\n\tRequired   []string            `json:\"required,omitempty\"`\n}\n\ntype Function struct {\n\tName        string     `json:\"name\"`\n\tDescription string     `json:\"description,omitempty\"`\n\tParameters  Parameters `json:\"parameters,omitempty\"`\n\tStrict      bool       `json:\"strict\"`\n}\n\ntype Tool struct {\n\tType     string   `json:\"type\"`\n\tFunction Function `json:\"function\"`\n}\n\nfunc NewTool(name, description string) Tool {\n\treturn Tool{","start_line":1,"end_line":120,"total_lines":267,"truncated":true}

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

{"path":"internal/livelog/hub_test.go","content":"package livelog\n\nimport (\n\t\"testing\"\n\t\"time\"\n)\n\nfunc recv(t *testing.T, ch \u003c-chan Event) Event {\n\tt.Helper()\n\n\tselect {\n\tcase ev, ok := \u003c-ch:\n\t\tif !ok {\n\t\t\tt.Fatal(\"channel closed unexpectedly\")\n\t\t}\n\n\t\treturn ev\n\tcase \u003c-time.After(time.Second):\n\t\tt.Fatal(\"timed out waiting for event\")\n\t}\n\n\treturn Event{}\n}\n\nfunc TestSubscribeReplaysBufferedEvents(t *testing.T) {\n\th := NewHub()\n\n\th.Publish(\"job-1\", Event{Type: ContentStart})\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\n\tbuffered, ch, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif len(buffered) != 2 {\n\t\tt.Fatalf(\"expected 2 buffered events, got %d\", len(buffered))\n\t}\n\tif buffered[1].Text != \"hi\" {\n\t\tt.Fatalf(\"unexpected buffered event: %+v\", buffered[1])\n\t}\n\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \" there\"})\n\n\tev := recv(t, ch)\n\tif ev.Text != \" there\" {\n\t\tt.Fatalf(\"expected live delta %q, got %+v\", \" there\", ev)\n\t}\n}\n\nfunc TestCheckpointClearsBuffer(t *testing.T) {\n\th := NewHub()\n\n\th.Publish(\"job-1\", Event{Type: ContentStart})\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\th.Checkpoint(\"job-1\")\n\n\tbuffered, _, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif len(buffered) != 0 {\n\t\tt.Fatalf(\"expected empty buffer after checkpoint, got %d events\", len(buffered))\n\t}\n}\n\nfunc TestCloseTerminatesSubscribers(t *testing.T) {\n\th := NewHub()\n\n\t_, ch, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\th.Close(\"job-1\")\n\n\tev := recv(t, ch)\n\tif ev.Type != Status {\n\t\tt.Fatalf(\"expected terminal status event, got %+v\", ev)\n\t}\n\n\tselect {\n\tcase _, ok := \u003c-ch:\n\t\tif ok {\n\t\t\tt.Fatal(\"expected channel to be closed after status event\")\n\t\t}\n\tcase \u003c-time.After(time.Second):\n\t\tt.Fatal(\"timed out waiting for channel close\")\n\t}\n}\n\nfunc TestSubscribeAfterCloseGetsEmptyBuffer(t *testing.T) {\n\th := NewHub()\n\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\th.Close(\"job-1\")\n\n\tbuffered, ch, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif len(buffered) != 0 {\n\t\tt.Fatalf(\"expected fresh empty state for a job re-subscribed after close, got %d events\", len(buffered))\n\t}\n\n\tselect {\n\tcase ev := \u003c-ch:\n\t\tt.Fatalf(\"did not expect any live event, got %+v\", ev)\n\tcase \u003c-time.After(50 * time.Millisecond):\n\t}\n}\n\nfunc TestCancelUnregistersSubscriber(t *testing.T) {\n\th := NewHub()\n\n\t_, ch, cancel := h.Subscribe(\"job-1\")\n\tcancel()\n\n\tselect {\n\tcase _, ok := \u003c-ch:\n\t\tif ok {\n\t\t\tt.Fatal(\"expected channel to be closed after cancel\")\n\t\t}\n\tcase \u003c-time.After(time.Second):\n\t\tt.Fatal(\"timed out waiting for channel close after cancel\")\n\t}\n\n\t// Publishing after cancel must not panic or block.\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n}","start_line":1,"end_line":124,"total_lines":124,"truncated":false}

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

{"path":"internal/web/web_test.go","content":"package web\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n\t\"github.com/abrander/zoo/internal/forgejo\"\n\t\"github.com/abrander/zoo/internal/livelog\"\n\t\"github.com/abrander/zoo/internal/store\"\n)\n\nfunc testServer(t *testing.T) (*Server, *store.Store) {\n\tt.Helper()\n\n\tst, err := store.Open(filepath.Join(t.TempDir(), \"zoo.db\"))\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\tt.Cleanup(func() { st.Close() })\n\n\tcfg := \u0026config.Config{\n\t\tLLMs:        []config.LLM{{Name: \"qwen\", OpenAI: \"https://example.com\", Model: \"qwen3\"}},\n\t\tAgents:      []config.Agent{{Name: \"leon\", LLM: \"qwen\"}},\n\t\tEvents:      []config.Event{{Kind: config.EventIssueNew, Agent: \"leon\"}},\n\t\tEnvironment: config.Environment{DockerImage: \"debian:unstable\", MaxLive: 2},\n\t}\n\n\t// No Forgejo client: pages render without avatars.\n\treturn New(cfg, st, livelog.NewHub(), nil), st\n}\n\nfunc TestIndexRenders(t *testing.T) {\n\ts, _ := testServer(t)\n\n\trr := httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/\", nil))\n\n\tif rr.Code != http.StatusOK {\n\t\tt.Fatalf(\"expected 200, got %d: %s\", rr.Code, rr.Body.String())\n\t}\n\tif !strings.Contains(rr.Body.String(), \"leon\") {\n\t\tt.Fatalf(\"expected agent name in output, got %s\", rr.Body.String())\n\t}\n}\n\nfunc TestJobsAndDetail(t *testing.T) {\n\ts, st := testServer(t)\n\tctx := context.Background()\n\n\tif err := st.CreateJob(ctx, store.Job{ID: \"job-1\", EventKind: \"issue:new\", Agent: \"leon\", Owner: \"acme\", Repo: \"widgets\", IssueIndex: 1}); err != nil {\n\t\tt.Fatal(err)\n\t}\n\tif err := st.AppendLog(ctx, \"job-1\", \"stdout\", \"hello\"); err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\trr := httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs\", nil))\n\tif rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), \"job-1\") {\n\t\tt.Fatalf(\"unexpected jobs page: %d %s\", rr.Code, rr.Body.String())\n\t}\n\n\trr = httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs/job-1\", nil))\n\tif rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), \"hello\") {\n\t\tt.Fatalf(\"unexpected job detail page: %d %s\", rr.Code, rr.Body.String())\n\t}\n\n\t// job-1 was never marked started/finished, so it's still \"live\":\n\t// hitting /events should stream whatever's currently buffered in the\n\t// hub (not yet checkpointed/persisted) and then wait for more, until\n\t// the request context is done.\n\ts.hub.Publish(\"job-1\", livelog.Event{Type: livelog.ContentDelta, Text: \"streaming\"})\n\n\tevCtx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)\n\tdefer cancel()\n\n\trr = httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs/job-1/events\", nil).WithContext(evCtx))\n\tif rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), \"streaming\") {\n\t\tt.Fatalf(\"unexpected events response: %d %s\", rr.Code, rr.Body.String())\n\t}\n\n\t// A finished job isn't live: /events should return immediately with\n\t// nothing to stream, so the client falls back to the static page.\n\tif err := st.CreateJob(ctx, store.Job{ID: \"job-2\", EventKind: \"issue:new\", Agent: \"leon\", Owner: \"acme\", Repo: \"widgets\", IssueIndex: 2}); err != nil {\n\t\tt.Fatal(err)\n\t}\n\tif err := st.MarkJobFinished(ctx, \"job-2\", store.JobSucceeded, \"\"); err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\trr = httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs/job-2/events\", nil))\n\tif rr.Code != http.StatusOK || rr.Body.Len() != 0 {\n\t\tt.Fatalf(\"expected empty response for a non-live job, got %d %q\", rr.Code, rr.Body.String())\n\t}\n}\n\n// TestJobDetailTrimsBlockWhitespace verifies that reasoning/content\n// blocks are rendered without the leading/trailing newlines the model\n// routinely emits: the block body uses white-space: pre-wrap, so those\n// would show up as visible blank lines inflating the block's height\n// (issue #53). Internal newlines must be preserved.\nfunc TestJobDetailTrimsBlockWhitespace(t *testing.T) {\n\ts, st := testServer(t)\n\tctx := context.Background()\n\n\tif err := st.CreateJob(ctx, store.Job{ID: \"job-1\", EventKind: \"issue:new\", Agent: \"leon\", Owner: \"acme\", Repo: \"widgets\", IssueIndex: 1}); err != nil {\n\t\tt.Fatal(err)\n\t}\n\tif err := st.MarkJobFinished(ctx, \"job-1\", store.JobSucceeded, \"\"); err != nil {\n\t\tt.Fatal(err)\n\t}\n\tif err := st.AppendLog(ctx, \"job-1\", \"content\", \"\\nNow the remaining tool callers:\\n\\n\\n\"); err != nil {\n\t\tt.Fatal(err)\n\t}\n\t// A block that is nothing but whitespace should not render at all.\n\tif err := st.AppendLog(ctx, \"job-1\", \"content\", \"   \\n\\t  \"); err != nil {\n\t\tt.Fatal(err)\n\t}\n\tif err := st.AppendLog(ctx, \"job-1\", \"reasoning\", \"  \\ninner\\nlines\\nkept\\n  \"); err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\tr := httptest.NewRecorder()\n\ts.Handler().ServeHTTP(r, httptest.NewRequest(http.MethodGet, \"/jobs/job-1\", nil))\n\tif r.Code != http.StatusOK {\n\t\tt.Fatalf(\"expected 200, got %d: %s\", r.Code, r.Body.String())\n\t}\n\n\tbody := r.Body.String()\n\tif !strings.Contains(body, `\u003cdiv class=\"block-body\"\u003eNow the remaining tool callers:\u003c/div\u003e`) {\n\t\tt.Fatalf(\"expected trimmed content block, got: %s\", body)\n\t}\n\tif strings.Contains(body, \"\u003cdiv class=\\\"block-body\\\"\u003e\\n\") {\n\t\tt.Fatalf(\"block body still starts with a newline: %s\", body)\n\t}\n\tif got := strings.Count(body, `class=\"block block-content\"`); got != 1 {\n\t\tt.Fatalf(\"expected exactly one content block (whitespace-only one dropped), got %d: %s\", got, body)\n\t}\n\tif !strings.Contains(body, \"inner\\nlines\\nkept\") {\n\t\tt.Fatalf(\"expected internal newlines to be preserved, got: %s\", body)\n\t}\n}\n\nfunc TestAuthGate(t *testing.T) {\n\tst, err := store.Open(filepath.Join(t.TempDir(), \"zoo.db\"))\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\tdefer st.Close()\n","start_line":1,"end_line":160,"total_lines":253,"truncated":true}

{"end_line": 253, "path": "internal/web/web_test.go", "start_line": 160}

{"path":"internal/web/web_test.go","content":"\n\tcfg := \u0026config.Config{Web: \u0026config.Web{Token: \"secret\"}}\n\ts := New(cfg, st, livelog.NewHub(), nil)\n\n\trr := httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs\", nil))\n\tif rr.Code != http.StatusUnauthorized {\n\t\tt.Fatalf(\"expected 401 without token, got %d\", rr.Code)\n\t}\n\n\treq := httptest.NewRequest(http.MethodGet, \"/jobs\", nil)\n\treq.Header.Set(\"Authorization\", \"Bearer secret\")\n\trr = httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, req)\n\tif rr.Code != http.StatusOK {\n\t\tt.Fatalf(\"expected 200 with correct token, got %d\", rr.Code)\n\t}\n}\n\n// TestJobsShowAgentAvatars verifies the jobs pages render each agent's\n// Forgejo avatar, and that an unresolvable avatar (unknown user) degrades\n// to no image instead of breaking the page.\nfunc TestJobsShowAgentAvatars(t *testing.T) {\n\t// Minimal in-test Forgejo API: the version probe the SDK makes when\n\t// the client is constructed, plus per-user profile lookups.\n\tavatars := map[string]string{\n\t\t\"leon\": \"https://forgejo.example/avatars/leon\",\n\t}\n\n\tapi := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\tif r.URL.Path == \"/api/v1/version\" {\n\t\t\tw.Header().Set(\"Content-Type\", \"application/json\")\n\t\t\tfmt.Fprint(w, `{\"version\":\"1.23.0\"}`)\n\n\t\t\treturn\n\t\t}\n\n\t\tif user, ok := strings.CutPrefix(r.URL.Path, \"/api/v1/users/\"); ok {\n\t\t\tif url, ok := avatars[user]; ok {\n\t\t\t\tw.Header().Set(\"Content-Type\", \"application/json\")\n\t\t\t\tfmt.Fprintf(w, `{\"login_name\":%q,\"avatar_url\":%q}`, user, url)\n\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\n\t\thttp.NotFound(w, r)\n\t}))\n\tt.Cleanup(api.Close)\n\n\tfg, err := forgejo.NewClient(config.Forgejo{URL: api.URL, Token: \"test\"})\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\tst, err := store.Open(filepath.Join(t.TempDir(), \"zoo.db\"))\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\tt.Cleanup(func() { st.Close() })\n\n\ts := New(\u0026config.Config{}, st, livelog.NewHub(), fg)\n\n\tctx := context.Background()\n\n\tif err := st.CreateJob(ctx, store.Job{ID: \"job-1\", EventKind: \"issue:new\", Agent: \"leon\", Owner: \"acme\", Repo: \"widgets\", IssueIndex: 1}); err != nil {\n\t\tt.Fatal(err)\n\t}\n\t// \"ghost\" doesn't exist on the mock Forgejo: the page must still\n\t// render, just without an avatar for that job.\n\tif err := st.CreateJob(ctx, store.Job{ID: \"job-2\", EventKind: \"issue:new\", Agent: \"ghost\", Owner: \"acme\", Repo: \"widgets\", IssueIndex: 2}); err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\trr := httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs\", nil))\n\tif rr.Code != http.StatusOK {\n\t\tt.Fatalf(\"expected 200, got %d: %s\", rr.Code, rr.Body.String())\n\t}\n\n\tbody := rr.Body.String()\n\tif !strings.Contains(body, `src=\"https://forgejo.example/avatars/leon\"`) {\n\t\tt.Fatalf(\"expected leon's avatar on the jobs page, got: %s\", body)\n\t}\n\tif !strings.Contains(body, \"job-2\") {\n\t\tt.Fatalf(\"expected the unknown-agent job to still render, got: %s\", body)\n\t}\n\n\trr = httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs/job-1\", nil))\n\tif rr.Code != http.StatusOK || !strings.Contains(rr.Body.String(), `src=\"https://forgejo.example/avatars/leon\"`) {\n\t\tt.Fatalf(\"expected leon's avatar on the job detail page, got %d: %s\", rr.Code, rr.Body.String())\n\t}\n}","start_line":160,"end_line":253,"total_lines":253,"truncated":false}

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

ok  	github.com/abrander/zoo/internal/livelog	0.052s
ok  	github.com/abrander/zoo/internal/web	1.006s
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
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

{"context_after": 2, "context_before": 2, "query": "\\.Subscribe\\(|livelog\\.Event\\{"}

/project/internal/web/web_test.go-78-	// hub (not yet checkpointed/persisted) and then wait for more, until
/project/internal/web/web_test.go-79-	// the request context is done.
/project/internal/web/web_test.go:80:	s.hub.Publish("job-1", livelog.Event{Type: livelog.ContentDelta, Text: "streaming"})
/project/internal/web/web_test.go-81-
/project/internal/web/web_test.go-82-	evCtx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
--
/project/internal/web/web.go-303-	w.WriteHeader(http.StatusOK)
/project/internal/web/web.go-304-
/project/internal/web/web.go:305:	buffered, ch, cancel := s.hub.Subscribe(id)
/project/internal/web/web.go-306-	defer cancel()
/project/internal/web/web.go-307-
--
/project/internal/livelog/hub_test.go-29-	h.Publish("job-1", Event{Type: ContentDelta, Text: "hi"})
/project/internal/livelog/hub_test.go-30-
/project/internal/livelog/hub_test.go:31:	buffered, ch, cancel := h.Subscribe("job-1")
/project/internal/livelog/hub_test.go-32-	defer cancel()
/project/internal/livelog/hub_test.go-33-
--
/project/internal/livelog/hub_test.go-54-	h.Checkpoint("job-1")
/project/internal/livelog/hub_test.go-55-
/project/internal/livelog/hub_test.go:56:	buffered, _, cancel := h.Subscribe("job-1")
/project/internal/livelog/hub_test.go-57-	defer cancel()
/project/internal/livelog/hub_test.go-58-
--
/project/internal/livelog/hub_test.go-65-	h := NewHub()
/project/internal/livelog/hub_test.go-66-
/project/internal/livelog/hub_test.go:67:	_, ch, cancel := h.Subscribe("job-1")
/project/internal/livelog/hub_test.go-68-	defer cancel()
/project/internal/livelog/hub_test.go-69-
--
/project/internal/livelog/hub_test.go-91-	h.Close("job-1")
/project/internal/livelog/hub_test.go-92-
/project/internal/livelog/hub_test.go:93:	buffered, ch, cancel := h.Subscribe("job-1")
/project/internal/livelog/hub_test.go-94-	defer cancel()
/project/internal/livelog/hub_test.go-95-
--
/project/internal/livelog/hub_test.go-108-	h := NewHub()
/project/internal/livelog/hub_test.go-109-
/project/internal/livelog/hub_test.go:110:	_, ch, cancel := h.Subscribe("job-1")
/project/internal/livelog/hub_test.go-111-	cancel()
/project/internal/livelog/hub_test.go-112-
--
/project/internal/agentrun/run.go-296-				reasoningOpen = true
/project/internal/agentrun/run.go-297-				reasoningBuf.Reset()
/project/internal/agentrun/run.go:298:				r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningStart})
/project/internal/agentrun/run.go-299-			}
/project/internal/agentrun/run.go-300-
/project/internal/agentrun/run.go-301-			reasoningBuf.WriteString(delta)
/project/internal/agentrun/run.go:302:			r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningDelta, Text: delta})
/project/internal/agentrun/run.go-303-		},
/project/internal/agentrun/run.go-304-		OnContentDelta: func(delta string) {
--
/project/internal/agentrun/run.go-306-				contentOpen = true
/project/internal/agentrun/run.go-307-				contentBuf.Reset()
/project/internal/agentrun/run.go:308:				r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentStart})
/project/internal/agentrun/run.go-309-			}
/project/internal/agentrun/run.go-310-
/project/internal/agentrun/run.go-311-			contentBuf.WriteString(delta)
/project/internal/agentrun/run.go:312:			r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentDelta, Text: delta})
/project/internal/agentrun/run.go-313-		},
/project/internal/agentrun/run.go-314-		OnTurnEnd: func() {
/project/internal/agentrun/run.go-315-			if reasoningOpen {
/project/internal/agentrun/run.go:316:				r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})
/project/internal/agentrun/run.go-317-				logAppend("reasoning", reasoningBuf.String())
/project/internal/agentrun/run.go-318-				r.hub.Checkpoint(jobID)
--
/project/internal/agentrun/run.go-321-
/project/internal/agentrun/run.go-322-			if contentOpen {
/project/internal/agentrun/run.go:323:				r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})
/project/internal/agentrun/run.go-324-				logAppend("content", contentBuf.String())
/project/internal/agentrun/run.go-325-				r.hub.Checkpoint(jobID)
--
/project/internal/agentrun/run.go-328-		},
/project/internal/agentrun/run.go-329-		OnTool: func(name, arguments, result string, toolErr bool) {
/project/internal/agentrun/run.go:330:			r.hub.Publish(jobID, livelog.Event{
/project/internal/agentrun/run.go-331-				Type:      livelog.Tool,
/project/internal/agentrun/run.go-332-				Name:      name,

{"find": "type 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\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", "path": "internal/livelog/hub.go", "replace": "type 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\tStatus         Type = \"status\"\n\n\t// Resync is never published through Publish; the web layer sends it\n\t// as the first message of a subscription that starts with an empty\n\t// replay buffer, carrying the job's current sequence number, so the\n\t// client can tell whether it missed events since its last\n\t// (re)connect.\n\tResync Type = \"resync\"\n)\n\ntype Event struct {\n\tType Type `json:\"type\"`\n\t// Seq is the job's monotonically increasing sequence number,\n\t// assigned by Publish. Clients use it to detect dropped events\n\t// (gaps in the sequence) and fall back to the static page, which\n\t// is always complete.\n\tSeq       uint64 `json:\"seq,omitempty\"`\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 is recoverable rather than silent:\n// every event carries a monotonically increasing Seq, so a client that\n// misses one detects the gap in the sequence and falls back to the\n// static page instead of rendering a desynced (empty or truncated)\n// block.\nconst subChanBuffer = 256"}

1 occurrences replaced

{"find": "type stream struct {\n\tmu   sync.Mutex\n\tbuf  []Event\n\tsubs map[chan Event]struct{}\n}", "path": "internal/livelog/hub.go", "replace": "type stream struct {\n\tmu   sync.Mutex\n\tbuf  []Event\n\tsubs map[chan Event]struct{}\n\tseq  uint64\n}"}

1 occurrences replaced

{"find": "// 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)", "path": "internal/livelog/hub.go", "replace": "// 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 (the client detects the resulting gap in\n// Seq and falls back to the static page).\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.seq++\n\tev.Seq = s.seq\n\n\ts.buf = append(s.buf, ev)"}

1 occurrences replaced

{"find": "// 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 <-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)", "path": "internal/livelog/hub.go", "replace": "// Subscribe returns the events currently buffered for jobID (i.e. not\n// yet checkpointed), the job's current sequence number (the Seq of the\n// most recently published event, 0 if none), and a channel of\n// everything published from this point on. The buffer snapshot and the\n// seq are taken under one lock, so the seq is always >= every buffered\n// event's Seq. The returned cancel func must be called when the caller\n// is done reading, to unregister and close the channel.\nfunc (h *Hub) Subscribe(jobID string) (buffered []Event, seq uint64, ch <-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\tseq = s.seq\n\n\tc := make(chan Event, subChanBuffer)"}

1 occurrences replaced

{"find": "\tbuffered, ch, cancel := s.hub.Subscribe(id)\n\tdefer cancel()\n\n\twrite := func(ev livelog.Event) bool {\n\t\tdata, err := json.Marshal(ev)\n\t\tif err != nil {\n\t\t\treturn true\n\t\t}\n\n\t\tif _, err := fmt.Fprintf(w, \"data: %s\\n\\n\", data); err != nil {\n\t\t\treturn false\n\t\t}\n\n\t\tflusher.Flush()\n\n\t\treturn true\n\t}\n\n\tfor _, ev := range buffered {\n\t\tif !write(ev) {\n\t\t\treturn\n\t\t}\n\t}", "path": "internal/web/web.go", "replace": "\tbuffered, seq, ch, cancel := s.hub.Subscribe(id)\n\tdefer cancel()\n\n\twrite := func(ev livelog.Event) bool {\n\t\tdata, err := json.Marshal(ev)\n\t\tif err != nil {\n\t\t\treturn true\n\t\t}\n\n\t\tif _, err := fmt.Fprintf(w, \"data: %s\\n\\n\", data); err != nil {\n\t\t\treturn false\n\t\t}\n\n\t\tflusher.Flush()\n\n\t\treturn true\n\t}\n\n\t// If there is nothing to replay, tell the client where the hub is\n\t// at: if the hub is ahead of the client's last rendered event, the\n\t// client missed events that are no longer replayable and must fall\n\t// back to the static page. If there is something to replay, no\n\t// marker is needed — the replayed events' Seqs are the continuity\n\t// check (the client renders them if contiguous with what it has\n\t// and reloads otherwise).\n\tif len(buffered) == 0 {\n\t\tif !write(livelog.Event{Type: livelog.Resync, Seq: seq}) {\n\t\t\treturn\n\t\t}\n\t}\n\n\tfor _, ev := range buffered {\n\t\tif !write(ev) {\n\t\t\treturn\n\t\t}\n\t}"}

1 occurrences replaced

{"end_line": 1004, "path": "internal/web/templates.go", "start_line": 879}

{"path":"internal/web/templates.go","content":"  {{if .Live}}\n  \u003cscript\u003e\n    (function() {\n      var jobID = {{.Job.ID}};\n      var log = document.getElementById(\"log\");\n      var reasoningBody = null;\n      var contentBody = null;\n\n      function nearBottom() {\n        return (window.innerHeight + window.scrollY) \u003e= (document.body.offsetHeight - 80);\n      }\n\n      function newBlock(kind, label) {\n        var div = document.createElement(\"div\");\n        div.className = \"block block-\" + kind;\n        if (label) {\n          var l = document.createElement(\"div\");\n          l.className = \"block-label\";\n          l.textContent = label;\n          div.appendChild(l);\n        }\n        var body = document.createElement(\"div\");\n        body.className = \"block-body\";\n        div.appendChild(body);\n        log.appendChild(div);\n        return body;\n      }\n\n      function newToolBlock(ev) {\n        var details = document.createElement(\"details\");\n        details.className = \"block block-tool\" + (ev.error ? \" block-tool-error\" : \"\");\n\n        var summary = document.createElement(\"summary\");\n\n        var badge = document.createElement(\"span\");\n        badge.className = \"tool-badge\";\n        badge.textContent = \"Tool\";\n\n        var text = document.createElement(\"span\");\n        text.className = \"tool-summary-text\";\n\n        var name = document.createElement(\"span\");\n        name.className = \"tool-name\";\n        name.textContent = \"🔧 \" + ev.name;\n\n        var preview = document.createElement(\"span\");\n        preview.className = \"tool-args-preview\";\n        preview.textContent = ev.arguments;\n\n        text.appendChild(name);\n        text.appendChild(preview);\n        summary.appendChild(badge);\n        summary.appendChild(text);\n        details.appendChild(summary);\n\n        var body = document.createElement(\"div\");\n        body.className = \"block-body\";\n\n        var argsLabel = document.createElement(\"div\");\n        argsLabel.className = \"tool-section-label\";\n        argsLabel.textContent = \"Arguments\";\n        var argsPre = document.createElement(\"pre\");\n        argsPre.textContent = ev.arguments;\n\n        var resultLabel = document.createElement(\"div\");\n        resultLabel.className = \"tool-section-label\";\n        resultLabel.textContent = \"Result\";\n        var resultPre = document.createElement(\"pre\");\n        resultPre.textContent = ev.result;\n\n        body.appendChild(argsLabel);\n        body.appendChild(argsPre);\n        body.appendChild(resultLabel);\n        body.appendChild(resultPre);\n        details.appendChild(body);\n        log.appendChild(details);\n      }\n\n      var es = new EventSource(\"/jobs/\" + jobID + \"/events\");\n\n      es.onmessage = function(e) {\n        var ev = JSON.parse(e.data);\n        var shouldScroll = nearBottom();\n\n        switch (ev.type) {\n          case \"reasoning_start\":\n            reasoningBody = newBlock(\"reasoning\", \"Thinking\");\n            break;\n          case \"reasoning_delta\":\n            if (reasoningBody) reasoningBody.textContent += ev.text;\n            break;\n          case \"reasoning_end\":\n            // Model output routinely starts/ends with newlines; drop them\n            // so the finished block matches the static (trimmed) view.\n            if (reasoningBody) reasoningBody.textContent = reasoningBody.textContent.trim();\n            reasoningBody = null;\n            break;\n          case \"content_start\":\n            contentBody = newBlock(\"content\", null);\n            break;\n          case \"content_delta\":\n            if (contentBody) contentBody.textContent += ev.text;\n            break;\n          case \"content_end\":\n            if (contentBody) contentBody.textContent = contentBody.textContent.trim();\n            contentBody = null;\n            break;\n          case \"tool\":\n            newToolBlock(ev);\n            break;\n          case \"status\":\n            es.close();\n            location.reload();\n            return;\n        }\n\n        if (shouldScroll) window.scrollTo(0, document.body.scrollHeight);\n      };\n    })();\n  \u003c/script\u003e\n  {{end}}\n\u003c/div\u003e\n\u003c/body\u003e\n\u003c/html\u003e\n{{end}}\n`","start_line":879,"end_line":1004,"total_lines":1004,"truncated":false}

{"find": "      var jobID = {{.Job.ID}};\n      var log = document.getElementById(\"log\");\n      var reasoningBody = null;\n      var contentBody = null;\n\n      function nearBottom() {", "path": "internal/web/templates.go", "replace": "      var jobID = {{.Job.ID}};\n      var log = document.getElementById(\"log\");\n\n      // Per-block-kind rendering state: the open block's body (null\n      // while none is open) and a buffer of deltas received before the\n      // block was created. Model output routinely starts with\n      // newlines, and a block that ends up whitespace-only must not\n      // render at all (the static view drops those blocks too), so a\n      // block is created lazily on its first non-whitespace text\n      // instead of on the *_start event — that's what keeps a\n      // whitespace-only turn from flashing an empty block shell\n      // (issue #60).\n      var blocks = {\n        reasoning: {body: null, buf: \"\"},\n        content:   {body: null, buf: \"\"}\n      };\n\n      // lastSeq is the sequence number of the last event rendered. The\n      // server numbers every event per job and sends a \"resync\" marker\n      // (with the hub's current number) when a subscription starts with\n      // nothing to replay. Any break in the sequence — a gap from\n      // dropped events, or a replay of an event we already rendered —\n      // means the block state above can no longer be trusted, so we\n      // fall back to the static page, which is always complete.\n      var lastSeq = 0;\n\n      function nearBottom() {"}

1 occurrences replaced

{"find": "        body.appendChild(argsLabel);\n        body.appendChild(argsPre);\n        body.appendChild(resultLabel);\n        body.appendChild(resultPre);\n        details.appendChild(body);\n        log.appendChild(details);\n      }\n\n      var es = new EventSource(\"/jobs/\" + jobID + \"/events\");\n\n      es.onmessage = function(e) {\n        var ev = JSON.parse(e.data);\n        var shouldScroll = nearBottom();\n\n        switch (ev.type) {\n          case \"reasoning_start\":\n            reasoningBody = newBlock(\"reasoning\", \"Thinking\");\n            break;\n          case \"reasoning_delta\":\n            if (reasoningBody) reasoningBody.textContent += ev.text;\n            break;\n          case \"reasoning_end\":\n            // Model output routinely starts/ends with newlines; drop them\n            // so the finished block matches the static (trimmed) view.\n            if (reasoningBody) reasoningBody.textContent = reasoningBody.textContent.trim();\n            reasoningBody = null;\n            break;\n          case \"content_start\":\n            contentBody = newBlock(\"content\", null);\n            break;\n          case \"content_delta\":\n            if (contentBody) contentBody.textContent += ev.text;\n            break;\n          case \"content_end\":\n            if (contentBody) contentBody.textContent = contentBody.textContent.trim();\n            contentBody = null;\n            break;\n          case \"tool\":\n            newToolBlock(ev);\n            break;\n          case \"status\":\n            es.close();\n            location.reload();\n            return;\n        }\n\n        if (shouldScroll) window.scrollTo(0, document.body.scrollHeight);\n      };\n    })();", "path": "internal/web/templates.go", "replace": "        body.appendChild(argsLabel);\n        body.appendChild(argsPre);\n        body.appendChild(resultLabel);\n        body.appendChild(resultPre);\n        details.appendChild(body);\n        log.appendChild(details);\n      }\n\n      function resyncPage() {\n        es.close();\n        location.reload();\n      }\n\n      function onDelta(kind, delta) {\n        var b = blocks[kind];\n        if (b.body) {\n          b.body.textContent += delta;\n          return;\n        }\n        b.buf += delta;\n        if (b.buf.trim() === \"\") return; // whitespace so far: no block yet\n        b.body = newBlock(kind, kind === \"reasoning\" ? \"Thinking\" : null);\n        b.body.textContent = b.buf;\n        b.buf = \"\";\n      }\n\n      function onEnd(kind) {\n        var b = blocks[kind];\n        if (b.body) {\n          // Model output routinely starts/ends with newlines; drop them\n          // so the finished block matches the static (trimmed) view,\n          // and drop the block entirely if nothing is left.\n          b.body.textContent = b.body.textContent.trim();\n          if (b.body.textContent === \"\") b.body.parentElement.remove();\n          b.body = null;\n        }\n        b.buf = \"\";\n      }\n\n      var es = new EventSource(\"/jobs/\" + jobID + \"/events\");\n\n      es.onmessage = function(e) {\n        var ev = JSON.parse(e.data);\n\n        if (ev.type === \"resync\") {\n          // The subscription started with nothing to replay, and the\n          // hub is at seq ev.seq. If we last rendered something else,\n          // we missed events that are no longer replayable.\n          if (lastSeq !== 0 && (typeof ev.seq !== \"number\" || ev.seq !== lastSeq)) {\n            resyncPage();\n          }\n          return;\n        }\n\n        if (typeof ev.seq === \"number\") {\n          if (lastSeq === 0) {\n            lastSeq = ev.seq; // first event: fresh page, or joining a replay\n          } else if (ev.seq === lastSeq + 1) {\n            lastSeq = ev.seq; // contiguous: render\n          } else {\n            resyncPage(); // gap (dropped events) or duplicate replay\n            return;\n          }\n        }\n\n        var shouldScroll = nearBottom();\n\n        switch (ev.type) {\n          case \"reasoning_start\":\n            blocks.reasoning.body = null;\n            blocks.reasoning.buf = \"\";\n            break;\n          case \"reasoning_delta\":\n            onDelta(\"reasoning\", ev.text);\n            break;\n          case \"reasoning_end\":\n            onEnd(\"reasoning\");\n            break;\n          case \"content_start\":\n            blocks.content.body = null;\n            blocks.content.buf = \"\";\n            break;\n          case \"content_delta\":\n            onDelta(\"content\", ev.text);\n            break;\n          case \"content_end\":\n            onEnd(\"content\");\n            break;\n          case \"tool\":\n            newToolBlock(ev);\n            break;\n          case \"status\":\n            resyncPage();\n            return;\n        }\n\n        if (shouldScroll) window.scrollTo(0, document.body.scrollHeight);\n      };\n    })();"}

1 occurrences replaced

{"find": "\th.Publish(\"job-1\", Event{Type: ContentStart})\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\n\tbuffered, ch, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif len(buffered) != 2 {\n\t\tt.Fatalf(\"expected 2 buffered events, got %d\", len(buffered))\n\t}\n\tif buffered[1].Text != \"hi\" {\n\t\tt.Fatalf(\"unexpected buffered event: %+v\", buffered[1])\n\t}\n\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \" there\"})\n\n\tev := recv(t, ch)\n\tif ev.Text != \" there\" {\n\t\tt.Fatalf(\"expected live delta %q, got %+v\", \" there\", ev)\n\t}\n}", "path": "internal/livelog/hub_test.go", "replace": "\th.Publish(\"job-1\", Event{Type: ContentStart})\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\n\tbuffered, seq, ch, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif len(buffered) != 2 {\n\t\tt.Fatalf(\"expected 2 buffered events, got %d\", len(buffered))\n\t}\n\tif buffered[1].Text != \"hi\" {\n\t\tt.Fatalf(\"unexpected buffered event: %+v\", buffered[1])\n\t}\n\tif seq != 2 {\n\t\tt.Fatalf(\"expected current seq 2, got %d\", seq)\n\t}\n\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \" there\"})\n\n\tev := recv(t, ch)\n\tif ev.Text != \" there\" {\n\t\tt.Fatalf(\"expected live delta %q, got %+v\", \" there\", ev)\n\t}\n\tif ev.Seq != 3 {\n\t\tt.Fatalf(\"expected live delta to carry seq 3, got %+v\", ev)\n\t}\n}\n\n// TestPublishAssignsMonotonicSeqs verifies that every published event\n// gets the job's next sequence number, and that seqs are per-job: a\n// client uses them to detect dropped events (gaps) and fall back to\n// the static page (issue #60).\nfunc TestPublishAssignsMonotonicSeqs(t *testing.T) {\n\th := NewHub()\n\n\th.Publish(\"job-1\", Event{Type: ContentStart})\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\th.Publish(\"job-2\", Event{Type: ContentStart})\n\n\tbuffered, seq, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif seq != 2 {\n\t\tt.Fatalf(\"expected job-1's current seq to be 2, got %d\", seq)\n\t}\n\tfor i, ev := range buffered {\n\t\tif ev.Seq != uint64(i+1) {\n\t\t\tt.Fatalf(\"expected buffered event %d to have seq %d, got %+v\", i, i+1, ev)\n\t\t}\n\t}\n\n\t// job-2 has its own seq space, independent of job-1's.\n\tbuffered2, seq2, cancel2 := h.Subscribe(\"job-2\")\n\tdefer cancel2()\n\n\tif seq2 != 1 || len(buffered2) != 1 || buffered2[0].Seq != 1 {\n\t\tt.Fatalf(\"expected job-2 to have its own seq space, got seq=%d buffered=%+v\", seq2, buffered2)\n\t}\n}\n\n// TestSubscribeSeqTracksLatestPublished verifies that the seq returned\n// by Subscribe is 0 for a fresh job and follows publishes, so the web\n// layer can send a resync marker that lets a reconnecting client tell\n// whether it missed events.\nfunc TestSubscribeSeqTracksLatestPublished(t *testing.T) {\n\th := NewHub()\n\n\t_, seq, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif seq != 0 {\n\t\tt.Fatalf(\"expected seq 0 for a fresh job, got %d\", seq)\n\t}\n\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\n\t_, seq, _ = h.Subscribe(\"job-1\")\n\tif seq != 1 {\n\t\tt.Fatalf(\"expected seq 1 after one publish, got %d\", seq)\n\t}\n}"}

1 occurrences replaced

{"find": "\th.Checkpoint(\"job-1\")\n\n\tbuffered, _, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()", "path": "internal/livelog/hub_test.go", "replace": "\th.Checkpoint(\"job-1\")\n\n\tbuffered, _, _, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()"}

1 occurrences replaced

{"find": "func TestCloseTerminatesSubscribers(t *testing.T) {\n\th := NewHub()\n\n\t_, ch, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()", "path": "internal/livelog/hub_test.go", "replace": "func TestCloseTerminatesSubscribers(t *testing.T) {\n\th := NewHub()\n\n\t_, _, ch, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()"}

1 occurrences replaced

{"find": "\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\th.Close(\"job-1\")\n\n\tbuffered, ch, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()", "path": "internal/livelog/hub_test.go", "replace": "\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\th.Close(\"job-1\")\n\n\tbuffered, _, ch, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()"}

1 occurrences replaced

{"find": "func TestCancelUnregistersSubscriber(t *testing.T) {\n\th := NewHub()\n\n\t_, ch, cancel := h.Subscribe(\"job-1\")\n\tcancel()", "path": "internal/livelog/hub_test.go", "replace": "func TestCancelUnregistersSubscriber(t *testing.T) {\n\th := NewHub()\n\n\t_, _, ch, cancel := h.Subscribe(\"job-1\")\n\tcancel()"}

1 occurrences replaced

{"find": "// TestJobDetailTrimsBlockWhitespace verifies that reasoning/content\n// blocks are rendered without the leading/trailing newlines the model\n// routinely emits: the block body uses white-space: pre-wrap, so those\n// would show up as visible blank lines inflating the block's height\n// (issue #53). Internal newlines must be preserved.", "path": "internal/web/web_test.go", "replace": "// TestJobEventsSequenceNumbers verifies that the SSE stream numbers\n// every event (per job, monotonically) and opens with a resync marker\n// carrying the hub's current seq when there is nothing to replay, so a\n// client can detect dropped events and fall back to the static page\n// (issue #60).\nfunc TestJobEventsSequenceNumbers(t *testing.T) {\n\ts, st := testServer(t)\n\tctx := context.Background()\n\n\tif err := st.CreateJob(ctx, store.Job{ID: \"job-1\", EventKind: \"issue:new\", Agent: \"leon\", Owner: \"acme\", Repo: \"widgets\", IssueIndex: 1}); err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\t// Nothing buffered: the stream must open with a resync marker\n\t// carrying the hub's current seq (0 for a fresh job, so omitted).\n\tevCtx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)\n\tdefer cancel()\n\n\trr := httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs/job-1/events\", nil).WithContext(evCtx))\n\tif rr.Code != http.StatusOK {\n\t\tt.Fatalf(\"expected 200, got %d: %s\", rr.Code, rr.Body.String())\n\t}\n\tif !strings.HasPrefix(rr.Body.String(), `data: {\"type\":\"resync\"}`) {\n\t\tt.Fatalf(\"expected stream to open with a resync marker, got: %s\", rr.Body.String())\n\t}\n\n\t// After a block is published, a new subscriber gets the buffered\n\t// events numbered contiguously from 1, with no resync marker: the\n\t// replayed seqs are the continuity check.\n\ts.hub.Publish(\"job-1\", livelog.Event{Type: livelog.ContentStart})\n\ts.hub.Publish(\"job-1\", livelog.Event{Type: livelog.ContentDelta, Text: \"hi\"})\n\n\tevCtx2, cancel2 := context.WithTimeout(context.Background(), 100*time.Millisecond)\n\tdefer cancel2()\n\n\trr = httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs/job-1/events\", nil).WithContext(evCtx2))\n\tbody := rr.Body.String()\n\n\tif !strings.Contains(body, `{\"type\":\"content_start\",\"seq\":1}`) ||\n\t\t!strings.Contains(body, `{\"type\":\"content_delta\",\"seq\":2,\"text\":\"hi\"}`) {\n\t\tt.Fatalf(\"expected buffered events numbered 1 and 2, got: %s\", body)\n\t}\n\tif strings.Contains(body, \"resync\") {\n\t\tt.Fatalf(\"did not expect a resync marker with a non-empty buffer, got: %s\", body)\n\t}\n}\n\n// TestJobDetailTrimsBlockWhitespace verifies that reasoning/content\n// blocks are rendered without the leading/trailing newlines the model\n// routinely emits: the block body uses white-space: pre-wrap, so those\n// would show up as visible blank lines inflating the block's height\n// (issue #53). Internal newlines must be preserved."}

1 occurrences replaced

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

{"path":"internal/livelog/hub.go","content":"\tdefer s.mu.Unlock()\n\n\tbuffered = append([]Event(nil), s.buf...)\n\tseq = s.seq\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","start_line":140,"end_line":175,"total_lines":188,"truncated":true}

{"find": "\treturn buffered, c, cancelFn\n}", "path": "internal/livelog/hub.go", "replace": "\treturn buffered, seq, c, cancelFn\n}"}

1 occurrences replaced

{"end_line": 75, "path": "internal/livelog/hub_test.go", "start_line": 55}

{"path":"internal/livelog/hub_test.go","content":"// TestPublishAssignsMonotonicSeqs verifies that every published event\n// gets the job's next sequence number, and that seqs are per-job: a\n// client uses them to detect dropped events (gaps) and fall back to\n// the static page (issue #60).\nfunc TestPublishAssignsMonotonicSeqs(t *testing.T) {\n\th := NewHub()\n\n\th.Publish(\"job-1\", Event{Type: ContentStart})\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\th.Publish(\"job-2\", Event{Type: ContentStart})\n\n\tbuffered, seq, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif seq != 2 {\n\t\tt.Fatalf(\"expected job-1's current seq to be 2, got %d\", seq)\n\t}\n\tfor i, ev := range buffered {\n\t\tif ev.Seq != uint64(i+1) {\n\t\t\tt.Fatalf(\"expected buffered event %d to have seq %d, got %+v\", i, i+1, ev)\n\t\t}","start_line":55,"end_line":75,"total_lines":184,"truncated":true}

{"find": "\tbuffered, seq, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif seq != 2 {\n\t\tt.Fatalf(\"expected job-1's current seq to be 2, got %d\", seq)\n\t}", "path": "internal/livelog/hub_test.go", "replace": "\tbuffered, seq, _, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif seq != 2 {\n\t\tt.Fatalf(\"expected job-1's current seq to be 2, got %d\", seq)\n\t}"}

1 occurrences replaced

{"find": "\tbuffered2, seq2, cancel2 := h.Subscribe(\"job-2\")\n\tdefer cancel2()", "path": "internal/livelog/hub_test.go", "replace": "\tbuffered2, seq2, _, cancel2 := h.Subscribe(\"job-2\")\n\tdefer cancel2()"}

1 occurrences replaced

{"find": "\t_, seq, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif seq != 0 {\n\t\tt.Fatalf(\"expected seq 0 for a fresh job, got %d\", seq)\n\t}\n\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\n\t_, seq, _ = h.Subscribe(\"job-1\")\n\tif seq != 1 {\n\t\tt.Fatalf(\"expected seq 1 after one publish, got %d\", seq)\n\t}", "path": "internal/livelog/hub_test.go", "replace": "\t_, seq, _, cancel := h.Subscribe(\"job-1\")\n\tdefer cancel()\n\n\tif seq != 0 {\n\t\tt.Fatalf(\"expected seq 0 for a fresh job, got %d\", seq)\n\t}\n\n\th.Publish(\"job-1\", Event{Type: ContentDelta, Text: \"hi\"})\n\n\t_, seq, _, _ = h.Subscribe(\"job-1\")\n\tif seq != 1 {\n\t\tt.Fatalf(\"expected seq 1 after one publish, got %d\", seq)\n\t}"}

1 occurrences replaced

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

ok  	github.com/abrander/zoo/internal/livelog	0.052s
ok  	github.com/abrander/zoo/internal/web	1.362s

{"command": "which node || which nodejs || echo \"no node\""}

no node

{"context_after": 1, "query": "func \\(s \\*Store\\) MarkJob"}

/project/internal/store/store.go:243:func (s *Store) MarkJobStarted(ctx context.Context, id string) error {
/project/internal/store/store.go-244-	_, err := s.db.ExecContext(ctx,
--
/project/internal/store/store.go:256:func (s *Store) MarkJobFinished(ctx context.Context, id string, status JobStatus, errMsg string) error {
/project/internal/store/store.go-257-	_, err := s.db.ExecContext(ctx,

{"find": "// TestJobDetailTrimsBlockWhitespace verifies that reasoning/content\n// blocks are rendered without the leading/trailing newlines the model\n// routinely emits: the block body uses white-space: pre-wrap, so those\n// would show up as visible blank lines inflating the block's height\n// (issue #53). Internal newlines must be preserved.", "path": "internal/web/web_test.go", "replace": "// TestJobDetailLiveScript verifies the live view's script creates\n// reasoning/content blocks lazily (on the first non-whitespace delta,\n// not on the *_start event) and enforces event-sequence continuity, so\n// a whitespace-only turn leaves no empty block shell and dropped\n// events trigger a fallback to the static page (issue #60).\nfunc TestJobDetailLiveScript(t *testing.T) {\n\ts, st := testServer(t)\n\tctx := context.Background()\n\n\tif err := st.CreateJob(ctx, store.Job{ID: \"job-1\", EventKind: \"issue:new\", Agent: \"leon\", Owner: \"acme\", Repo: \"widgets\", IssueIndex: 1}); err != nil {\n\t\tt.Fatal(err)\n\t}\n\tif err := st.MarkJobStarted(ctx, \"job-1\"); err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\trr := httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs/job-1\", nil))\n\tif rr.Code != http.StatusOK {\n\t\tt.Fatalf(\"expected 200, got %d: %s\", rr.Code, rr.Body.String())\n\t}\n\n\tbody := rr.Body.String()\n\n\tfor _, want := range []string{\n\t\t`var lastSeq = 0;`,\n\t\t`if (ev.type === \"resync\")`,\n\t\t`ev.seq === lastSeq + 1`,\n\t\t`if (b.buf.trim() === \"\") return;`,\n\t\t`if (b.body.textContent === \"\") b.body.parentElement.remove();`,\n\t} {\n\t\tif !strings.Contains(body, want) {\n\t\t\tt.Fatalf(\"expected live script to contain %q\", want)\n\t\t}\n\t}\n}\n\n// TestJobDetailTrimsBlockWhitespace verifies that reasoning/content\n// blocks are rendered without the leading/trailing newlines the model\n// routinely emits: the block body uses white-space: pre-wrap, so those\n// would show up as visible blank lines inflating the block's height\n// (issue #53). Internal newlines must be preserved."}

1 occurrences replaced

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

ok  	github.com/abrander/zoo/internal/livelog	(cached)
ok  	github.com/abrander/zoo/internal/web	1.527s

{"content": "package web\n\nimport (\n\t\"context\"\n\t\"net/http\"\n\t\"net/http/httptest\"\n\t\"regexp\"\n\t\"testing\"\n\n\t\"github.com/abrander/zoo/internal/store\"\n)\n\nfunc TestDumpLiveScript(t *testing.T) {\n\ts, st := testServer(t)\n\tctx := context.Background()\n\n\tif err := st.CreateJob(ctx, store.Job{ID: \"job-1\", EventKind: \"issue:new\", Agent: \"leon\", Owner: \"acme\", Repo: \"widgets\", IssueIndex: 1}); err != nil {\n\t\tt.Fatal(err)\n\t}\n\tif err := st.MarkJobStarted(ctx, \"job-1\"); err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\trr := httptest.NewRecorder()\n\ts.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, \"/jobs/job-1\", nil))\n\n\tre := regexp.MustCompile(`(?s)<script>(.*)</script>`)\n\tm := re.FindStringSubmatch(rr.Body.String())\n\tif len(m) != 2 {\n\t\tt.Fatal(\"no script found\")\n\t}\n\tt.Logf(\"SCRIPT_START\\n%s\\nSCRIPT_END\", m[1])\n}\n", "path": "internal/web/dump_test.go"}

OK

{"command": "cd /project && go test ./internal/web/ -run TestDumpLiveScript -v 2>&1 | sed -n '/SCRIPT_START/,/SCRIPT_END/p'"}

    dump_test.go:32: SCRIPT_START
        
            (function() {
              var jobID = "job-1";
              var log = document.getElementById("log");
        
              
              
              
              
              
              
              
              
              
              var blocks = {
                reasoning: {body: null, buf: ""},
                content:   {body: null, buf: ""}
              };
        
              
              
              
              
              
              
              
              var lastSeq = 0;
        
              function nearBottom() {
                return (window.innerHeight + window.scrollY) >= (document.body.offsetHeight - 80);
              }
        
              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);
              }
        
              function resyncPage() {
                es.close();
                location.reload();
              }
        
              function onDelta(kind, delta) {
                var b = blocks[kind];
                if (b.body) {
                  b.body.textContent += delta;
                  return;
                }
                b.buf += delta;
                if (b.buf.trim() === "") return; 
                b.body = newBlock(kind, kind === "reasoning" ? "Thinking" : null);
                b.body.textContent = b.buf;
                b.buf = "";
              }
        
              function onEnd(kind) {
                var b = blocks[kind];
                if (b.body) {
                  
                  
                  
                  b.body.textContent = b.body.textContent.trim();
                  if (b.body.textContent === "") b.body.parentElement.remove();
                  b.body = null;
                }
                b.buf = "";
              }
        
              var es = new EventSource("/jobs/" + jobID + "/events");
        
              es.onmessage = function(e) {
                var ev = JSON.parse(e.data);
        
                if (ev.type === "resync") {
                  
                  
                  
                  if (lastSeq !== 0 && (typeof ev.seq !== "number" || ev.seq !== lastSeq)) {
                    resyncPage();
                  }
                  return;
                }
        
                if (typeof ev.seq === "number") {
                  if (lastSeq === 0) {
                    lastSeq = ev.seq; 
                  } else if (ev.seq === lastSeq + 1) {
                    lastSeq = ev.seq; 
                  } else {
                    resyncPage(); 
                    return;
                  }
                }
        
                var shouldScroll = nearBottom();
        
                switch (ev.type) {
                  case "reasoning_start":
                    blocks.reasoning.body = null;
                    blocks.reasoning.buf = "";
                    break;
                  case "reasoning_delta":
                    onDelta("reasoning", ev.text);
                    break;
                  case "reasoning_end":
                    onEnd("reasoning");
                    break;
                  case "content_start":
                    blocks.content.body = null;
                    blocks.content.buf = "";
                    break;
                  case "content_delta":
                    onDelta("content", ev.text);
                    break;
                  case "content_end":
                    onEnd("content");
                    break;
                  case "tool":
                    newToolBlock(ev);
                    break;
                  case "status":
                    resyncPage();
                    return;
                }
        
                if (shouldScroll) window.scrollTo(0, document.body.scrollHeight);
              };
            })();
          
        SCRIPT_END

{"command": "cd /project && sed -n '880,905p' internal/web/templates.go | cat -A | head -30"}

  <script>$
    (function() {$
      var jobID = {{.Job.ID}};$
      var log = document.getElementById("log");$
$
      // Per-block-kind rendering state: the open block's body (null$
      // while none is open) and a buffer of deltas received before the$
      // block was created. Model output routinely starts with$
      // newlines, and a block that ends up whitespace-only must not$
      // render at all (the static view drops those blocks too), so a$
      // block is created lazily on its first non-whitespace text$
      // instead of on the *_start event M-bM-^@M-^T that's what keeps a$
      // whitespace-only turn from flashing an empty block shell$
      // (issue #60).$
      var blocks = {$
        reasoning: {body: null, buf: ""},$
        content:   {body: null, buf: ""}$
      };$
$
      // lastSeq is the sequence number of the last event rendered. The$
      // server numbers every event per job and sends a "resync" marker$
      // (with the hub's current number) when a subscription starts with$
      // nothing to replay. Any break in the sequence M-bM-^@M-^T a gap from$
      // dropped events, or a replay of an event we already rendered M-bM-^@M-^T$
      // means the block state above can no longer be trusted, so we$
      // fall back to the static page, which is always complete.$

{"command": "cd /tmp && mkdir -p tpltest && cd tpltest && cat > main.go <<'EOF'\npackage main\n\nimport (\n\t\"html/template\"\n\t\"os\"\n)\n\nfunc main() {\n\tt := template.Must(template.New(\"x\").Parse(`<script>\nvar a = 1; // comment\nvar b = 2;\n/* block comment */\nvar c = 3;\n</script>`))\n\tt.Execute(os.Stdout, nil)\n}\nEOF\ngo mod init tpltest >/dev/null 2>&1; go run main.go"}

<script>
var a = 1; 
var b = 2;
 
var c = 3;
</script>

{"command": "cd /project && go test ./internal/web/ -run TestDumpLiveScript -v 2>&1 | sed -n '/SCRIPT_START/,/SCRIPT_END/p' | sed '1d;$d' > /tmp/live.js && python3 - <<'EOF'\nimport re\nsrc = open('/tmp/live.js').read()\n# strip string literals and line comments (none left) before counting\nstripped = re.sub(r'\"(?:[^\"\\\\]|\\\\.)*\"', '\"\"', src)\nfor o, c in [('{','}'), ('(',')'), ('[',']')]:\n    print(o, stripped.count(o), c, stripped.count(c), 'OK' if stripped.count(o)==stripped.count(c) else 'MISMATCH')\n# check semicolon-terminated statements look sane: count 'function' declarations\nprint('functions:', re.findall(r'function (\\w+)', stripped))\nEOF"}

{ 21 } 21 OK
( 73 ) 73 OK
[ 2 ] 2 OK
functions: ['nearBottom', 'newBlock', 'newToolBlock', 'resyncPage', 'onDelta', 'onEnd']

{"command": "cat > /tmp/sim.py <<'EOF'\n# Simulation of the rendered JS client logic (issue #60 fix).\nclass Client:\n    def __init__(self):\n        self.blocks = {\"reasoning\": {\"body\": None, \"buf\": \"\"},\n                       \"content\":   {\"body\": None, \"buf\": \"\"}}\n        self.lastSeq = 0\n        self.dom = []          # list of (kind, text) blocks in DOM\n        self.reloads = 0\n\n    def resyncPage(self):\n        self.reloads += 1\n\n    def newBlock(self, kind, label):\n        body = {\"kind\": kind, \"label\": label, \"text\": \"\"}\n        self.dom.append(body)\n        return body\n\n    def onDelta(self, kind, delta):\n        b = self.blocks[kind]\n        if b[\"body\"]:\n            b[\"body\"][\"text\"] += delta\n            return\n        b[\"buf\"] += delta\n        if b[\"buf\"].strip() == \"\":\n            return\n        b[\"body\"] = self.newBlock(kind, \"Thinking\" if kind == \"reasoning\" else None)\n        b[\"body\"][\"text\"] = b[\"buf\"]\n        b[\"buf\"] = \"\"\n\n    def onEnd(self, kind):\n        b = self.blocks[kind]\n        if b[\"body\"]:\n            b[\"body\"][\"text\"] = b[\"body\"][\"text\"].strip()\n            if b[\"body\"][\"text\"] == \"\":\n                self.dom.remove(b[\"body\"])\n            b[\"body\"] = None\n        b[\"buf\"] = \"\"\n\n    def onmessage(self, ev):\n        if ev[\"type\"] == \"resync\":\n            if self.lastSeq != 0 and (not isinstance(ev.get(\"seq\"), int) or ev[\"seq\"] != self.lastSeq):\n                self.resyncPage()\n            return\n        if isinstance(ev.get(\"seq\"), int):\n            if self.lastSeq == 0:\n                self.lastSeq = ev[\"seq\"]\n            elif ev[\"seq\"] == self.lastSeq + 1:\n                self.lastSeq = ev[\"seq\"]\n            else:\n                self.resyncPage()\n                return\n        t = ev[\"type\"]\n        if t == \"reasoning_start\":\n            self.blocks[\"reasoning\"] = {\"body\": None, \"buf\": \"\"}\n        elif t == \"reasoning_delta\":\n            self.onDelta(\"reasoning\", ev[\"text\"])\n        elif t == \"reasoning_end\":\n            self.onEnd(\"reasoning\")\n        elif t == \"content_start\":\n            self.blocks[\"content\"] = {\"body\": None, \"buf\": \"\"}\n        elif t == \"content_delta\":\n            self.onDelta(\"content\", ev[\"text\"])\n        elif t == \"content_end\":\n            self.onEnd(\"content\")\n        elif t == \"tool\":\n            pass\n        elif t == \"status\":\n            self.resyncPage()\n            return\n\ndef feed(c, events):\n    for ev in events:\n        c.onmessage(ev)\n\ndef check(name, cond):\n    print((\"PASS\" if cond else \"FAIL\"), name)\n    return cond\n\nok = True\n\n# 1. Whitespace-only content turn: no block shell at all.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1},\n         {\"type\":\"content_delta\",\"seq\":2,\"text\":\"\\n\"},\n         {\"type\":\"content_end\",\"seq\":3}])\nok &= check(\"whitespace-only turn leaves no block\", c.dom == [] and c.reloads == 0)\n\n# 2. Normal content turn with leading/trailing newlines: one trimmed block.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1},\n         {\"type\":\"content_delta\",\"seq\":2,\"text\":\"\\n\"},\n         {\"type\":\"content_delta\",\"seq\":3,\"text\":\"Let me check the tools package\"},\n         {\"type\":\"content_delta\",\"seq\":4,\"text\":\" (for testability).\"},\n         {\"type\":\"content_end\",\"seq\":5}])\nok &= check(\"normal turn -> one trimmed block\",\n            c.dom == [{\"kind\":\"content\",\"label\":None,\"text\":\"Let me check the tools package (for testability).\"}] and c.reloads == 0)\n\n# 3. Gap: dropped delta (seq jump) -> reload.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1},\n         {\"type\":\"content_delta\",\"seq\":2,\"text\":\"He\"},\n         # seq 3 dropped\n         {\"type\":\"content_delta\",\"seq\":4,\"text\":\"llo\"},\n         {\"type\":\"content_end\",\"seq\":5}])\nok &= check(\"gap triggers reload\", c.reloads == 1)\n\n# 4. Reconnect, empty buffer, hub ahead -> resync triggers reload.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1}, {\"type\":\"content_delta\",\"seq\":2,\"text\":\"hi\"}])\nfeed(c, [{\"type\":\"resync\",\"seq\":7}])\nok &= check(\"resync ahead of lastSeq triggers reload\", c.reloads == 1)\n\n# 5. Reconnect, empty buffer, hub exactly at lastSeq -> in sync, no reload.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1}, {\"type\":\"content_delta\",\"seq\":2,\"text\":\"hi\"}])\nfeed(c, [{\"type\":\"resync\",\"seq\":2}])\nok &= check(\"resync in sync does not reload\", c.reloads == 0)\n\n# 6. Fresh page joins mid-replay (buffered block): renders, no reload.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":10},\n         {\"type\":\"content_delta\",\"seq\":11,\"text\":\"\\n\"},\n         {\"type\":\"content_delta\",\"seq\":12,\"text\":\"Hello\"},\n         {\"type\":\"content_end\",\"seq\":13}])\nok &= check(\"fresh page renders replayed block\",\n            c.dom == [{\"kind\":\"content\",\"label\":None,\"text\":\"Hello\"}] and c.reloads == 0)\n\n# 7. Reconnect with duplicate replay (already rendered) -> safe reload.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1}, {\"type\":\"content_delta\",\"seq\":2,\"text\":\"hi\"}])\nfeed(c, [{\"type\":\"content_start\",\"seq\":1}, {\"type\":\"content_delta\",\"seq\":2,\"text\":\"hi\"}])\nok &= check(\"duplicate replay triggers reload (safe)\", c.reloads == 1)\n\n# 8. Reconnect where replay heals: in-flight events still in buffer, contiguous.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1}, {\"type\":\"content_delta\",\"seq\":2,\"text\":\"He\"}])\n# connection dropped; buffer replays from checkpoint (seq 1) incl. in-flight:\nfeed(c, [{\"type\":\"content_start\",\"seq\":1},\n         {\"type\":\"content_delta\",\"seq\":2,\"text\":\"He\"},\n         {\"type\":\"content_delta\",\"seq\":3,\"text\":\"llo\"},\n         {\"type\":\"content_end\",\"seq\":4}])\nok &= check(\"healing replay: first dup triggers reload (safe, no corruption)\", c.reloads == 1)\n\n# 9. Reasoning lazy creation + trim.\nc = Client()\nfeed(c, [{\"type\":\"reasoning_start\",\"seq\":1},\n         {\"type\":\"reasoning_delta\",\"seq\":2,\"text\":\"  \\n\"},\n         {\"type\":\"reasoning_delta\",\"seq\":3,\"text\":\"Thinking...\"},\n         {\"type\":\"reasoning_end\",\"seq\":4}])\nok &= check(\"reasoning block lazy-created and trimmed\",\n            c.dom == [{\"kind\":\"reasoning\",\"label\":\"Thinking\",\"text\":\"Thinking...\"}] and c.reloads == 0)\n\n# 10. Tool event mid-stream does not disturb block state.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1},\n         {\"type\":\"content_delta\",\"seq\":2,\"text\":\"Using a tool\"},\n         {\"type\":\"tool\",\"seq\":3,\"name\":\"bash\"},\n         {\"type\":\"content_end\",\"seq\":4}])\nok &= check(\"tool event coexists with open block\",\n            c.dom == [{\"kind\":\"content\",\"label\":None,\"text\":\"Using a tool\"}] and c.reloads == 0)\n\n# 11. status event -> reload.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1}, {\"type\":\"content_delta\",\"seq\":2,\"text\":\"x\"}])\nfeed(c, [{\"type\":\"status\",\"seq\":3,\"status\":\"done\"}])\nok &= check(\"status triggers reload\", c.reloads == 1)\n\n# 12. Two consecutive turns: blocks close and reopen cleanly.\nc = Client()\nfeed(c, [{\"type\":\"content_start\",\"seq\":1},\n         {\"type\":\"content_delta\",\"seq\":2,\"text\":\"First\"},\n         {\"type\":\"content_end\",\"seq\":3},\n         {\"type\":\"content_start\",\"seq\":4},\n         {\"type\":\"content_delta\",\"seq\":5,\"text\":\"Second\"},\n         {\"type\":\"content_end\",\"seq\":6}])\nok &= check(\"consecutive turns -> two blocks\",\n            [b[\"text\"] for b in c.dom] == [\"First\", \"Second\"] and c.reloads == 0)\n\nprint(\"ALL PASS\" if ok else \"SOME FAILED\")\nEOF\npython3 /tmp/sim.py"}

PASS whitespace-only turn leaves no block
PASS normal turn -> one trimmed block
FAIL gap triggers reload
PASS resync ahead of lastSeq triggers reload
PASS resync in sync does not reload
PASS fresh page renders replayed block
FAIL duplicate replay triggers reload (safe)
FAIL healing replay: first dup triggers reload (safe, no corruption)
PASS reasoning block lazy-created and trimmed
PASS tool event coexists with open block
PASS status triggers reload
PASS consecutive turns -> two blocks
SOME FAILED

{"command": "cd /tmp && sed -i 's/ok &= check(\"gap triggers reload\", c.reloads == 1)/ok \\&= check(\"gap triggers reload\", c.reloads >= 1)/; s/ok &= check(\"duplicate replay triggers reload (safe)\", c.reloads == 1)/ok \\&= check(\"duplicate replay triggers reload (safe)\", c.reloads >= 1)/; s/ok &= check(\"healing replay: first dup triggers reload (safe, no corruption)\", c.reloads == 1)/ok \\&= check(\"healing replay: first dup triggers reload (safe, no corruption)\", c.reloads >= 1)/' sim.py && python3 sim.py"}

PASS whitespace-only turn leaves no block
PASS normal turn -> one trimmed block
PASS gap triggers reload
PASS resync ahead of lastSeq triggers reload
PASS resync in sync does not reload
PASS fresh page renders replayed block
PASS duplicate replay triggers reload (safe)
PASS healing replay: first dup triggers reload (safe, no corruption)
PASS reasoning block lazy-created and trimmed
PASS tool event coexists with open block
PASS status triggers reload
PASS consecutive turns -> two blocks
ALL PASS

{"path": "internal/web/dump_test.go"}

File removed successfully

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

?   	github.com/abrander/zoo/cmd/zoo	[no test files]
ok  	github.com/abrander/zoo/internal/agentrun	0.004s
ok  	github.com/abrander/zoo/internal/config	0.006s
ok  	github.com/abrander/zoo/internal/forgejo	1.241s
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.756s
ok  	github.com/abrander/zoo/internal/store	1.668s
ok  	github.com/abrander/zoo/internal/tools	0.003s
ok  	github.com/abrander/zoo/internal/web	(cached)

{"command": "cd /project && git diff --stat && git diff"}

 internal/livelog/hub.go      | 42 +++++++++++++++----
 internal/livelog/hub_test.go | 70 ++++++++++++++++++++++++++++---
 internal/web/templates.go    | 99 +++++++++++++++++++++++++++++++++++++-------
 internal/web/web.go          | 15 ++++++-
 internal/web/web_test.go     | 86 ++++++++++++++++++++++++++++++++++++++
 5 files changed, 283 insertions(+), 29 deletions(-)
diff --git a/internal/livelog/hub.go b/internal/livelog/hub.go
index 8f58356..20274f5 100644
--- a/internal/livelog/hub.go
+++ b/internal/livelog/hub.go
@@ -18,10 +18,22 @@ const (
 	ContentEnd     Type = "content_end"
 	Tool           Type = "tool"
 	Status         Type = "status"
+
+	// Resync is never published through Publish; the web layer sends it
+	// as the first message of a subscription that starts with an empty
+	// replay buffer, carrying the job's current sequence number, so the
+	// client can tell whether it missed events since its last
+	// (re)connect.
+	Resync Type = "resync"
 )
 
 type Event struct {
-	Type      Type   `json:"type"`
+	Type Type `json:"type"`
+	// Seq is the job's monotonically increasing sequence number,
+	// assigned by Publish. Clients use it to detect dropped events
+	// (gaps in the sequence) and fall back to the static page, which
+	// is always complete.
+	Seq       uint64 `json:"seq,omitempty"`
 	Text      string `json:"text,omitempty"`
 	Name      string `json:"name,omitempty"`
 	Arguments string `json:"arguments,omitempty"`
@@ -32,8 +44,11 @@ type Event struct {
 
 // subChanBuffer bounds how many events a slow subscriber can lag behind
 // by before new events are dropped for it. Generous for a single-user
-// local dashboard; a dropped event just means a subscriber's browser
-// tab misses a chunk and catches up on the next one, never a hang.
+// local dashboard. A dropped event is recoverable rather than silent:
+// every event carries a monotonically increasing Seq, so a client that
+// misses one detects the gap in the sequence and falls back to the
+// static page instead of rendering a desynced (empty or truncated)
+// block.
 const subChanBuffer = 256
 
 // maxBufferedEvents caps the per-job replay buffer as a safety net
@@ -45,6 +60,7 @@ type stream struct {
 	mu   sync.Mutex
 	buf  []Event
 	subs map[chan Event]struct{}
+	seq  uint64
 }
 
 // Hub fans out per-job Events to any number of live subscribers.
@@ -72,13 +88,17 @@ func (h *Hub) get(jobID string) *stream {
 
 // Publish appends ev to jobID's replay buffer and fans it out to every
 // current subscriber. Never blocks: a subscriber whose channel is full
-// simply misses this event.
+// simply misses this event (the client detects the resulting gap in
+// Seq and falls back to the static page).
 func (h *Hub) Publish(jobID string, ev Event) {
 	s := h.get(jobID)
 
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
+	s.seq++
+	ev.Seq = s.seq
+
 	s.buf = append(s.buf, ev)
 	if len(s.buf) > maxBufferedEvents {
 		s.buf = s.buf[len(s.buf)-maxBufferedEvents:]
@@ -107,16 +127,20 @@ func (h *Hub) Checkpoint(jobID string) {
 }
 
 // Subscribe returns the events currently buffered for jobID (i.e. not
-// yet checkpointed) plus a channel of everything published from this
-// point on. The returned cancel func must be called when the caller is
-// done reading, to unregister and close the channel.
-func (h *Hub) Subscribe(jobID string) (buffered []Event, ch <-chan Event, cancel func()) {
+// yet checkpointed), the job's current sequence number (the Seq of the
+// most recently published event, 0 if none), and a channel of
+// everything published from this point on. The buffer snapshot and the
+// seq are taken under one lock, so the seq is always >= every buffered
+// event's Seq. The returned cancel func must be called when the caller
+// is done reading, to unregister and close the channel.
+func (h *Hub) Subscribe(jobID string) (buffered []Event, seq uint64, ch <-chan Event, cancel func()) {
 	s := h.get(jobID)
 
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	buffered = append([]Event(nil), s.buf...)
+	seq = s.seq
 
 	c := make(chan Event, subChanBuffer)
 	s.subs[c] = struct{}{}
@@ -135,7 +159,7 @@ func (h *Hub) Subscribe(jobID string) (buffered []Event, ch <-chan Event, cancel
 		})
 	}
 
-	return buffered, c, cancelFn
+	return buffered, seq, c, cancelFn
 }
 
 // Close publishes a terminal Status event, disconnects every current
diff --git a/internal/livelog/hub_test.go b/internal/livelog/hub_test.go
index 2c980cc..07a9060 100644
--- a/internal/livelog/hub_test.go
+++ b/internal/livelog/hub_test.go
@@ -28,7 +28,7 @@ func TestSubscribeReplaysBufferedEvents(t *testing.T) {
 	h.Publish("job-1", Event{Type: ContentStart})
 	h.Publish("job-1", Event{Type: ContentDelta, Text: "hi"})
 
-	buffered, ch, cancel := h.Subscribe("job-1")
+	buffered, seq, ch, cancel := h.Subscribe("job-1")
 	defer cancel()
 
 	if len(buffered) != 2 {
@@ -37,6 +37,9 @@ func TestSubscribeReplaysBufferedEvents(t *testing.T) {
 	if buffered[1].Text != "hi" {
 		t.Fatalf("unexpected buffered event: %+v", buffered[1])
 	}
+	if seq != 2 {
+		t.Fatalf("expected current seq 2, got %d", seq)
+	}
 
 	h.Publish("job-1", Event{Type: ContentDelta, Text: " there"})
 
@@ -44,6 +47,63 @@ func TestSubscribeReplaysBufferedEvents(t *testing.T) {
 	if ev.Text != " there" {
 		t.Fatalf("expected live delta %q, got %+v", " there", ev)
 	}
+	if ev.Seq != 3 {
+		t.Fatalf("expected live delta to carry seq 3, got %+v", ev)
+	}
+}
+
+// TestPublishAssignsMonotonicSeqs verifies that every published event
+// gets the job's next sequence number, and that seqs are per-job: a
+// client uses them to detect dropped events (gaps) and fall back to
+// the static page (issue #60).
+func TestPublishAssignsMonotonicSeqs(t *testing.T) {
+	h := NewHub()
+
+	h.Publish("job-1", Event{Type: ContentStart})
+	h.Publish("job-1", Event{Type: ContentDelta, Text: "hi"})
+	h.Publish("job-2", Event{Type: ContentStart})
+
+	buffered, seq, _, cancel := h.Subscribe("job-1")
+	defer cancel()
+
+	if seq != 2 {
+		t.Fatalf("expected job-1's current seq to be 2, got %d", seq)
+	}
+	for i, ev := range buffered {
+		if ev.Seq != uint64(i+1) {
+			t.Fatalf("expected buffered event %d to have seq %d, got %+v", i, i+1, ev)
+		}
+	}
+
+	// job-2 has its own seq space, independent of job-1's.
+	buffered2, seq2, _, cancel2 := h.Subscribe("job-2")
+	defer cancel2()
+
+	if seq2 != 1 || len(buffered2) != 1 || buffered2[0].Seq != 1 {
+		t.Fatalf("expected job-2 to have its own seq space, got seq=%d buffered=%+v", seq2, buffered2)
+	}
+}
+
+// TestSubscribeSeqTracksLatestPublished verifies that the seq returned
+// by Subscribe is 0 for a fresh job and follows publishes, so the web
+// layer can send a resync marker that lets a reconnecting client tell
+// whether it missed events.
+func TestSubscribeSeqTracksLatestPublished(t *testing.T) {
+	h := NewHub()
+
+	_, seq, _, cancel := h.Subscribe("job-1")
+	defer cancel()
+
+	if seq != 0 {
+		t.Fatalf("expected seq 0 for a fresh job, got %d", seq)
+	}
+
+	h.Publish("job-1", Event{Type: ContentDelta, Text: "hi"})
+
+	_, seq, _, _ = h.Subscribe("job-1")
+	if seq != 1 {
+		t.Fatalf("expected seq 1 after one publish, got %d", seq)
+	}
 }
 
 func TestCheckpointClearsBuffer(t *testing.T) {
@@ -53,7 +113,7 @@ func TestCheckpointClearsBuffer(t *testing.T) {
 	h.Publish("job-1", Event{Type: ContentDelta, Text: "hi"})
 	h.Checkpoint("job-1")
 
-	buffered, _, cancel := h.Subscribe("job-1")
+	buffered, _, _, cancel := h.Subscribe("job-1")
 	defer cancel()
 
 	if len(buffered) != 0 {
@@ -64,7 +124,7 @@ func TestCheckpointClearsBuffer(t *testing.T) {
 func TestCloseTerminatesSubscribers(t *testing.T) {
 	h := NewHub()
 
-	_, ch, cancel := h.Subscribe("job-1")
+	_, _, ch, cancel := h.Subscribe("job-1")
 	defer cancel()
 
 	h.Close("job-1")
@@ -90,7 +150,7 @@ func TestSubscribeAfterCloseGetsEmptyBuffer(t *testing.T) {
 	h.Publish("job-1", Event{Type: ContentDelta, Text: "hi"})
 	h.Close("job-1")
 
-	buffered, ch, cancel := h.Subscribe("job-1")
+	buffered, _, ch, cancel := h.Subscribe("job-1")
 	defer cancel()
 
 	if len(buffered) != 0 {
@@ -107,7 +167,7 @@ func TestSubscribeAfterCloseGetsEmptyBuffer(t *testing.T) {
 func TestCancelUnregistersSubscriber(t *testing.T) {
 	h := NewHub()
 
-	_, ch, cancel := h.Subscribe("job-1")
+	_, _, ch, cancel := h.Subscribe("job-1")
 	cancel()
 
 	select {
diff --git a/internal/web/templates.go b/internal/web/templates.go
index c64e61b..e2f336f 100644
--- a/internal/web/templates.go
+++ b/internal/web/templates.go
@@ -881,8 +881,29 @@ const templates = `
     (function() {
       var jobID = {{.Job.ID}};
       var log = document.getElementById("log");
-      var reasoningBody = null;
-      var contentBody = null;
+
+      // Per-block-kind rendering state: the open block's body (null
+      // while none is open) and a buffer of deltas received before the
+      // block was created. Model output routinely starts with
+      // newlines, and a block that ends up whitespace-only must not
+      // render at all (the static view drops those blocks too), so a
+      // block is created lazily on its first non-whitespace text
+      // instead of on the *_start event — that's what keeps a
+      // whitespace-only turn from flashing an empty block shell
+      // (issue #60).
+      var blocks = {
+        reasoning: {body: null, buf: ""},
+        content:   {body: null, buf: ""}
+      };
+
+      // lastSeq is the sequence number of the last event rendered. The
+      // server numbers every event per job and sends a "resync" marker
+      // (with the hub's current number) when a subscription starts with
+      // nothing to replay. Any break in the sequence — a gap from
+      // dropped events, or a replay of an event we already rendered —
+      // means the block state above can no longer be trusted, so we
+      // fall back to the static page, which is always complete.
+      var lastSeq = 0;
 
       function nearBottom() {
         return (window.innerHeight + window.scrollY) >= (document.body.offsetHeight - 80);
@@ -954,41 +975,91 @@ const templates = `
         log.appendChild(details);
       }
 
+      function resyncPage() {
+        es.close();
+        location.reload();
+      }
+
+      function onDelta(kind, delta) {
+        var b = blocks[kind];
+        if (b.body) {
+          b.body.textContent += delta;
+          return;
+        }
+        b.buf += delta;
+        if (b.buf.trim() === "") return; // whitespace so far: no block yet
+        b.body = newBlock(kind, kind === "reasoning" ? "Thinking" : null);
+        b.body.textContent = b.buf;
+        b.buf = "";
+      }
+
+      function onEnd(kind) {
+        var b = blocks[kind];
+        if (b.body) {
+          // Model output routinely starts/ends with newlines; drop them
+          // so the finished block matches the static (trimmed) view,
+          // and drop the block entirely if nothing is left.
+          b.body.textContent = b.body.textContent.trim();
+          if (b.body.textContent === "") b.body.parentElement.remove();
+          b.body = null;
+        }
+        b.buf = "";
+      }
+
       var es = new EventSource("/jobs/" + jobID + "/events");
 
       es.onmessage = function(e) {
         var ev = JSON.parse(e.data);
+
+        if (ev.type === "resync") {
+          // The subscription started with nothing to replay, and the
+          // hub is at seq ev.seq. If we last rendered something else,
+          // we missed events that are no longer replayable.
+          if (lastSeq !== 0 && (typeof ev.seq !== "number" || ev.seq !== lastSeq)) {
+            resyncPage();
+          }
+          return;
+        }
+
+        if (typeof ev.seq === "number") {
+          if (lastSeq === 0) {
+            lastSeq = ev.seq; // first event: fresh page, or joining a replay
+          } else if (ev.seq === lastSeq + 1) {
+            lastSeq = ev.seq; // contiguous: render
+          } else {
+            resyncPage(); // gap (dropped events) or duplicate replay
+            return;
+          }
+        }
+
         var shouldScroll = nearBottom();
 
         switch (ev.type) {
           case "reasoning_start":
-            reasoningBody = newBlock("reasoning", "Thinking");
+            blocks.reasoning.body = null;
+            blocks.reasoning.buf = "";
             break;
           case "reasoning_delta":
-            if (reasoningBody) reasoningBody.textContent += ev.text;
+            onDelta("reasoning", 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;
+            onEnd("reasoning");
             break;
           case "content_start":
-            contentBody = newBlock("content", null);
+            blocks.content.body = null;
+            blocks.content.buf = "";
             break;
           case "content_delta":
-            if (contentBody) contentBody.textContent += ev.text;
+            onDelta("content", ev.text);
             break;
           case "content_end":
-            if (contentBody) contentBody.textContent = contentBody.textContent.trim();
-            contentBody = null;
+            onEnd("content");
             break;
           case "tool":
             newToolBlock(ev);
             break;
           case "status":
-            es.close();
-            location.reload();
+            resyncPage();
             return;
         }
 
diff --git a/internal/web/web.go b/internal/web/web.go
index 55ab97f..1a850f9 100644
--- a/internal/web/web.go
+++ b/internal/web/web.go
@@ -302,7 +302,7 @@ func (s *Server) handleJobEvents(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Connection", "keep-alive")
 	w.WriteHeader(http.StatusOK)
 
-	buffered, ch, cancel := s.hub.Subscribe(id)
+	buffered, seq, ch, cancel := s.hub.Subscribe(id)
 	defer cancel()
 
 	write := func(ev livelog.Event) bool {
@@ -320,6 +320,19 @@ func (s *Server) handleJobEvents(w http.ResponseWriter, r *http.Request) {
 		return true
 	}
 
+	// If there is nothing to replay, tell the client where the hub is
+	// at: if the hub is ahead of the client's last rendered event, the
+	// client missed events that are no longer replayable and must fall
+	// back to the static page. If there is something to replay, no
+	// marker is needed — the replayed events' Seqs are the continuity
+	// check (the client renders them if contiguous with what it has
+	// and reloads otherwise).
+	if len(buffered) == 0 {
+		if !write(livelog.Event{Type: livelog.Resync, Seq: seq}) {
+			return
+		}
+	}
+
 	for _, ev := range buffered {
 		if !write(ev) {
 			return
diff --git a/internal/web/web_test.go b/internal/web/web_test.go
index ded09b2..7e60664 100644
--- a/internal/web/web_test.go
+++ b/internal/web/web_test.go
@@ -104,6 +104,92 @@ func TestJobsAndDetail(t *testing.T) {
 	}
 }
 
+// TestJobEventsSequenceNumbers verifies that the SSE stream numbers
+// every event (per job, monotonically) and opens with a resync marker
+// carrying the hub's current seq when there is nothing to replay, so a
+// client can detect dropped events and fall back to the static page
+// (issue #60).
+func TestJobEventsSequenceNumbers(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)
+	}
+
+	// Nothing buffered: the stream must open with a resync marker
+	// carrying the hub's current seq (0 for a fresh job, so omitted).
+	evCtx, cancel := context.WithTimeout(context.Background(), 100*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 {
+		t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
+	}
+	if !strings.HasPrefix(rr.Body.String(), `data: {"type":"resync"}`) {
+		t.Fatalf("expected stream to open with a resync marker, got: %s", rr.Body.String())
+	}
+
+	// After a block is published, a new subscriber gets the buffered
+	// events numbered contiguously from 1, with no resync marker: the
+	// replayed seqs are the continuity check.
+	s.hub.Publish("job-1", livelog.Event{Type: livelog.ContentStart})
+	s.hub.Publish("job-1", livelog.Event{Type: livelog.ContentDelta, Text: "hi"})
+
+	evCtx2, cancel2 := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel2()
+
+	rr = httptest.NewRecorder()
+	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs/job-1/events", nil).WithContext(evCtx2))
+	body := rr.Body.String()
+
+	if !strings.Contains(body, `{"type":"content_start","seq":1}`) ||
+		!strings.Contains(body, `{"type":"content_delta","seq":2,"text":"hi"}`) {
+		t.Fatalf("expected buffered events numbered 1 and 2, got: %s", body)
+	}
+	if strings.Contains(body, "resync") {
+		t.Fatalf("did not expect a resync marker with a non-empty buffer, got: %s", body)
+	}
+}
+
+// TestJobDetailLiveScript verifies the live view's script creates
+// reasoning/content blocks lazily (on the first non-whitespace delta,
+// not on the *_start event) and enforces event-sequence continuity, so
+// a whitespace-only turn leaves no empty block shell and dropped
+// events trigger a fallback to the static page (issue #60).
+func TestJobDetailLiveScript(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.MarkJobStarted(ctx, "job-1"); err != nil {
+		t.Fatal(err)
+	}
+
+	rr := httptest.NewRecorder()
+	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs/job-1", nil))
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
+	}
+
+	body := rr.Body.String()
+
+	for _, want := range []string{
+		`var lastSeq = 0;`,
+		`if (ev.type === "resync")`,
+		`ev.seq === lastSeq + 1`,
+		`if (b.buf.trim() === "") return;`,
+		`if (b.body.textContent === "") b.body.parentElement.remove();`,
+	} {
+		if !strings.Contains(body, want) {
+			t.Fatalf("expected live script to contain %q", want)
+		}
+	}
+}
+
 // 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

{"command": "cd /project && gofmt -l . && echo \"---gofmt clean---\" && go build ./... && go test ./... 2>&1 | tail -12"}

---gofmt clean---
?   	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 -m \"Fix empty block bodies in the live job log view\n\nThe live (SSE) view could render a .block-body with no text in it,\nwhile the stored log had the text — or the block was missing entirely.\nTwo causes:\n\n1. Whitespace-only model output. The live JS created a block on\n   content_start/reasoning_start and trimmed it on *_end; when the\n   model's message was whitespace-only (e.g. a bare newline, common on\n   tool-call turns), an empty shell was left in the DOM. The static\n   view drops such blocks (buildBlocks), so the shell vanished on\n   reload.\n\n2. Dropped SSE events. The hub deliberately drops events for slow\n   subscribers (full channel), and the client's start/delta/end state\n   machine could not recover from a gap: dropped deltas left empty or\n   truncated blocks, and a dropped *_end left an untrimmed (over-\n   padded) block that the next turn then orphaned.\n\nFix:\n- Create reasoning/content blocks lazily, on the first non-whitespace\n  delta, and drop the block on *_end if nothing is left — the live\n  view now matches the static view for whitespace-only turns.\n- Number every hub event with a per-job monotonically increasing Seq;\n  when a subscription starts with an empty replay buffer, the SSE\n  handler sends a \\\"resync\\\" marker with the hub's current seq. The\n  client enforces sequence continuity and falls back to the static\n  page (which is always complete) on any gap or duplicate replay.\n\nFixes #60\" && git push origin issue-60-greg 2>&1 | tail -3"}

[issue-60-greg e24ca15] Fix empty block bodies in the live job log view
 5 files changed, 283 insertions(+), 29 deletions(-)
To https://code.stdio.dk/abrander/zoo.git
 * [new branch]      issue-60-greg -> issue-60-greg

{"base": "main", "body": "## What was wrong\n\nThe empty `block-body` divs are a **live (SSE) view** artifact — the static view (old logs) can't produce them: `buildBlocks` trims block text and drops whitespace-only blocks entirely, and the static template always renders `block-body` inline with its (non-empty) text. The issue's empty example is also unindented JS-created DOM, not the static template.\n\nTwo root causes:\n\n1. **Whitespace-only model output → empty block shell.** The live JS created a block on `content_start`/`reasoning_start` and trimmed the accumulated text on `*_end`. When the model emits a message whose content is only whitespace (e.g. a bare `\"\\n\"` — common on tool-call turns), the block was left as an empty shell in the DOM. The static view drops such blocks, so the shell vanished on reload — which is why it looked like \"maybe just when streaming\".\n2. **Dropped SSE events desync the live view.** `livelog.Hub` deliberately drops events for slow subscribers (full 256-slot channel — background tab, network stall). The client's start/delta/end state machine can't recover from a gap: dropped deltas → empty or truncated block (\"there should be some text in there\"); dropped `*_end` → untrimmed block with excess vertical space (the issue's second example) that the next turn then orphans.\n\n## The fix\n\n- **Lazy block creation** (`internal/web/templates.go`): reasoning/content blocks are now created on the first *non-whitespace* delta instead of on the `*_start` event, and dropped on `*_end` if nothing is left. A whitespace-only turn no longer produces an empty shell at all, and the live view matches the static view.\n- **Event sequence numbers** (`internal/livelog/hub.go`, `internal/web/web.go`): every published event gets a per-job monotonically increasing `Seq`. When a subscription starts with an empty replay buffer, the SSE handler sends a `resync` marker carrying the hub's current seq. The client enforces strict sequence continuity and falls back to the static page — which is always complete — on any gap or duplicate replay, instead of rendering a desynced block.\n\n## Tests\n\n- `livelog`: seqs are monotonic and per-job; `Subscribe` returns the current seq atomically with the buffer snapshot.\n- `web`: the SSE stream opens with a `resync` marker when there's nothing to replay, and buffered events are numbered contiguously; the live script contains the lazy-creation and continuity logic.\n- The client state machine was additionally verified against 12 scenarios (whitespace-only turns, gaps, reconnects with/without replay, duplicate replays, consecutive turns, tool events, status) via a simulation of the rendered JS — all pass.\n\n`go build`, `go vet`, and the full test suite are green.\n\nFixes #60", "head": "issue-60-greg", "title": "Fix empty block bodies in the live job log view"}

Pull request opened

{"body": "Investigated — the empty `block-body` divs are a **live (streaming) view** artifact, not a problem with the stored log. The static view (old logs) can't produce them: `buildBlocks` trims block text and drops whitespace-only blocks entirely, and the static template always renders the body inline with its (non-empty) text. Your empty example is also unindented JS-created DOM, not the static template — consistent with \"maybe just when streaming\".\n\n**Two root causes:**\n\n1. **Whitespace-only model output → empty block shell.** The live JS created a block on `content_start`/`reasoning_start` and trimmed the accumulated text on `*_end`. When the model emits a message whose content is only whitespace (e.g. a bare `\"\\n\"` — common on tool-call turns), the block was left as an empty shell in the DOM. The static view drops such blocks, so the shell vanished on reload.\n2. **Dropped SSE events desync the live view.** The `livelog` hub deliberately drops events for slow subscribers (full 256-event channel — background tab, network stall). The client's start/delta/end state machine can't recover from a gap: dropped deltas → empty or truncated block (\"there should be some text in there\"); a dropped `*_end` → untrimmed block with excess vertical space (your second example) that the next turn then orphans.\n\n**The fix (PR opened):**\n\n- Reasoning/content blocks are now created **lazily, on the first non-whitespace delta**, and dropped on `*_end` if nothing is left — a whitespace-only turn no longer produces an empty shell at all, and the live view matches the static view.\n- Every hub event now carries a **per-job sequence number**; when a subscription starts with an empty replay buffer the server sends a `resync` marker with the hub's current seq. The client enforces strict sequence continuity and **falls back to the static page (always complete) on any gap or duplicate replay**, instead of rendering a desynced block.\n\nTests added for the seq/resync contract and the live script; the client state machine was also verified against 12 scenarios (whitespace-only turns, gaps, reconnects with/without replay, consecutive turns, tool events, status). Full suite green."}

Comment posted

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

On branch issue-60-greg
nothing to commit, working tree clean
e24ca15 Fix empty block bodies in the live job log view
98298f6 Merge pull request 'Fix excessive vertical space in job view blocks (#53)' (#55) from issue-53-greg into main