The screens a run puts in front of you

What you look at Shipped

A run is not a progress bar and a wall of text at the end. It opens a live site you can watch it think in, writes a self-contained HTML dashboard into its own repo, and narrates itself in the terminal while it goes.

Three surfaces, and they answer different questions. The live site answers "what is it doing right now", the dashboard answers "what did that run conclude", and the terminal answers "is this still moving". The written reports underneath them are for the questions you ask days later.

The live progress site

Screenshot pendingThe live run site: a five-column streaming transcript — Time, Specialist, Actor, Action, Log line — under a status chip reading "N events", with the provenance bar showing project, branch, commits and run id.

Opens by itself at the start of a run, at a local HTTPS address printed to stderr. It replays the run history from the run database, then streams events over a WebSocket and reconnects with backoff if you close the laptop lid. --no-progress turns the whole thing off — no probe, no serve, no browser.

What is on it

A five-column transcript — time, specialist, actor, action, log line — that you can drag to resize.
A provenance bar: project, branch, commit count, the change under review, and the run id.
A collapsible commit panel, rendered only when the run actually has commits — a research run does not get a dead "0 commits" box.
A floating pill counting how many lines have arrived beneath you, shown only once you scroll up off the tail — so reading back through history does not fight the stream.

The run dashboard

Screenshot pendingThe generated index.html: a ready/not-ready banner, chip counts for total, distinct, duplicate, recommend-fix and advisory findings, a severity-ranked findings table, and by-specialist and by-specialty breakdowns.

Every run writes an index.html into its own output repository — no external assets, no server, openable from disk a year later. The merge-readiness banner is written by the gate, not by the model that wrote the prose.

The terminal

Screenshot pendingA run in progress in a terminal: the starting banner naming the models and effort level, then per-specialist milestone lines, a findings ticker, and the coloured merge-readiness verdict at the end.

A scrolling narrative rather than a spinner — every line is teed to review.log, so what you watched is exactly what you can grep afterwards.

What gets written down

Artifact	What it is for
index.html	The skimmable dashboard for one run
report-*.md	The narrative review: gate, summary, findings by severity
review.log	The raw run transcript, exactly as it scrolled past
merge-readiness.json	The gate's verdict, machine-readable
failure-report.md	Written when a run dies — what happened, and how to resume it

It commits its own output

The run directory is a git repository, and it is committed and pushed at every write point rather than once at the end. A run that crashes halfway still leaves everything it had produced up to that moment, plus a failure report whose factual half is deterministic and written even when the model that was supposed to narrate it is the thing that failed.