Narration Scripts for Every Screencast
A fresh agent reads one past Gantry build and writes its anchored narration essay.
Gantry records everything a build run does — the plan, the per-chunk pipeline, the tests it ran, the work that landed — but that record is a ledger, not something you can watch. The screencast pipeline turns a run into a narrated video, and the narration needs a script: a short documentary essay that explains what the run built and how, carrying invisible comments that pin each paragraph to a moment in the footage and stage the framed panels that fade in over the terminal. Writing a good one is real work — read the subject run's artifacts, explain the mechanism, stay radically concise, and get every anchor to resolve against the run it describes.
This job produced the real scripts for the whole episode registry. It ran as a map: one fresh agent per episode, each reading a different past Gantry build and writing exactly one script for it, and each script checked by a validator before it counted as done.
Build
The decomposition is the map spec itself: one independent unit per episode, each writing a single script that the same validator both gates and skip-tests, so a stalled episode stayed a local problem and resume was cheap.
The cut here was not drawn by a planner in the usual sense — it is the map spec, which fans out one unit per row of the episode manifest. That shape fits the problem because the episodes are independent of each other: no script depends on another's content, so there is no ordering to honor and nothing to serialize. Each unit does one thing: write one anchored essay about one run. The same check, `gantry validate-script`, serves as both the gate that lands a unit and the skip-test that lets an already-valid script pass untouched. That double duty is what made the run idempotent — a script written and validated in an earlier pass is left alone rather than rewritten.
The one place the cut came under stress was the milestones episode. Its subject is the in-process rebuild of Gantry's milestone feature — the most internally structured run in the set, staged across phases with many chunks. A script for it therefore carries the most anchors and overlay directives, and the validator resolves every one of them against the run's orchestration directory. That unit failed its first execute and gate; a fix pass failed too; the whole run halted there. The difficulty lived exactly where there was the most structure to narrate correctly — the strict anchor check bites hardest on the richest subject.
What the independence bought showed up on resume. The scripts already written and valid were skipped by the skip-test rather than regenerated, the milestones episode was retried by a fresh agent and came out green, and the remaining episodes then ran straight through. A map has no review or re-plan stage to redraw a boundary under load; the boundary here was fixed by the spec, and its per-episode independence is what kept one hard unit from costing the rest.
Feature
Before this run the narrated-screencast pipeline was all machinery and no content; producing the registry's scripts was an explicit by-hand step. The run performed it, and the scripts still sit in the tree as the render step's production input.
Before this run, the narrated-screencast pipeline had the parts but nothing to narrate. The map spec, the episode manifest, and the validator existed, but the spec states plainly that generating scripts for the real registry is a curated by-hand step — the automated tests exercise the machinery only against fixtures. So the episodes had no narration: nothing a renderer could turn into a spoken track. This run was that by-hand step, carried out as an orchestrated map instead of typed by a person.
Standing in the tree today, the output is there. The scripts directory holds one Markdown essay per episode, each opening with the front matter the validator demands — the subject run's identifier, the episode number, and the timing provenance — followed by narration threaded with the invisible anchor and overlay comments that synchronize it to the footage. Each script documents a different Gantry build, so the directory taken whole is Gantry narrating its own history. The validator that gated them, `scripts/check-script.sh` wrapping `gantry validate-script`, still guards the directory.
The registry has grown since. Beside the episodes this run produced sit later additions — a menu-makeover script and a menu tour, each with its own commit history and held to the same validator. The downstream half of the pipeline is in place too: a separate map spec drives the render from these scripts to narrated video, reading each script as a fixed input it must not rewrite. What this job left is still the production source for that step, not a fixture and not a draft.