Filming a Gantry Run End to End
Turn a live Gantry build into a watchable, unattended screencast
Gantry builds ambitious plans by running fresh agents in a git worktree, and the clearest way to show someone how that looks is a video of a real run. But a run does not film itself. The event stream a run records plays back at machine speed, far too fast to watch; capturing a live terminal has to happen unattended, without a person waiting to press a key when it finishes; and once you have many recordings you need some way to organize them into episodes and produce the metadata each one needs to be published.
This job built that whole path. It added timing profiles that reshape a raw event stream into a paced, watchable timeline and an unattended replay mode that exits on its own after holding the final frame. It defined an episode manifest format and a generator that scans Gantry's build registry to discover what is worth recording. It wrote a headless per-window recorder script, and a pipeline that uses Gantry's own map driver to film many episodes in parallel and emit per-episode publishing metadata.
Build
Four milestones stacked bottom-up from replay timing to the parallel recording pipeline, with each milestone's plan formed after the previous one finished so a discovered constraint could be carried to the layers that depended on it.
The work was cut into four milestones in dependency order: replay timing and unattended exit first, then the episode manifest model and its generator, then the headless recording harness, and finally the map pipeline that drives many recordings at once. The order is what made each piece buildable and testable alone. You cannot film a run until replay plays at a watchable speed and can exit without a person present, so timing came first. You cannot enumerate episodes until a manifest format exists, so the data model came before the recorder that consumes it. The pipeline that fans recordings out across the map driver sits on top of all three.
No gate ever sent a sprint back, and no sprint was retried — the run stayed green from the first milestone to the last. For a clean run the question is whether the decomposition dissolved the difficulty before it could surface, and here the milestone boundaries are where that shows. Each milestone was planned after the previous one completed, and two of those completions recorded a constraint the next milestone had to honour. Building the timing layer established that unattended auto-exit is opt-in: replay given a timing profile alone still waits for a keypress, so the recording and map milestones had to request the hold-then-exit behaviour explicitly. Building the manifest established that it names timing profiles by selector while the timing layer takes a single profile file by path, and that no such profile files existed yet — so the harness milestone had to commit them and the map generator had to reconcile the name against the path.
Those two mismatches are the load the cut actually carried. They surfaced at a milestone boundary, where the plan for the next milestone could absorb them, rather than inside a gate as a failed build. That is why the pipeline on top did not fault: the interface disagreements between layers were found and written down at the point where one layer handed off to the next.
Feature
Gantry gained a full screencast path — timing-shaped replay, an episode manifest and generator, a headless recorder, and a map-driven parallel filming pipeline — and the engine modules and scripts are all still present at HEAD.
Before this job, Gantry could build and replay a run but had no way to turn one into a video someone would watch. A replay played back at machine speed, there was no format for grouping recordings into episodes, and nothing automated capturing them or producing what a published clip needs.
The design answers that in layers that are all present in the tree today. A timing layer loads TOML profiles and reshapes an event stream into a paced timeline, wired into the replay engine behind a timing flag with an unattended mode that holds the final frame and then exits. An episode manifest model and its generator scan the build registry to discover episode candidates and serialize them. A headless per-window script records a replay to video, and a map-spec generator turns a manifest into individual rows the map driver films in parallel, emitting the publishing metadata for each. The timing, shaping, manifest, enumeration, generator, and map modules under the engine are all live at HEAD, as are the recorder and map scripts and the screencast runbook.
The profile files the harness committed are still there, and a further profile has since been added alongside them. The visible drift is in the tests: the three top-level integration files this job wrote — the record-replay smoke and sandbox checks and the map-spec test — are no longer at the top of the tests directory. They were folded into a reorganized integration tree, where the same coverage now lives under the end-to-end and default groupings rather than as standalone files.