Reference Documentation Build

This sprint froze the current usage output before the refactor touched production behavior. A fresh worker only had to capture and assert the existing text, which made later changes measurable instead of interpretive. The gates stayed green, giving the milestone a byte-level baseline for every later step.

This sprint introduced the specification module and limited itself to verb identity and dispatch. That was a good clean-context unit because each row could be checked against one accepted command spelling and its aliases. The run facts show no repair pressure here, so the parser contract held while the table took shape.

This sprint moved the entry point's flag spellings and metadata into the same table model. The brief made the boundary concrete: accepted spellings, value shape, ownership by parsing site, and visible ordering. It stayed inside behaviour preservation, so the worker could prove agreement without redesigning parsing.

This sprint finished the parser agreement work by bringing the remaining driver and harness flag sites under the table. Its scope was recognition rather than display, so a fresh worker could focus on accepted spellings and ownership without touching usage text. The boundary stayed green.

This sprint collapsed the handwritten usage constants into a renderer over the table. It was sequenced last because every row of command and flag data had to exist before output could be assembled from it. The existing fixtures made the boundary exact, and the sprint passed without a repair branch.

This sprint created the reference export verb and the committed output file before the individual inventories grew large. That made determinism and drift detection the first contract, not a cleanup after content existed. The worker had a crisp proof target: same source, same dataset, readable failure when the file drifted.

This sprint added configuration settings as source-derived rows. The brief constrained it to the existing settings schema, so the worker did not need to restate documentation prose. The boundary was strong because a missing setting or stale field could be found mechanically.

This sprint consumed the table made by the previous milestone and exported command facts. Its work was intentionally downstream: prove the table can serve another reader without changing the binary. The run stayed green because the command refactor had already separated accepted behavior from presentation.

This sprint gathered the harness registry, roles, stage mapping, and environment surface into the dataset. The cut was right-sized because each fact already belonged to a registry or settings binding. The child sprint closed the milestone without recorded repair pressure.

This sprint added bundled patterns as dataset rows with their source text split into comment and code segments. That was a narrow extraction unit: it read the built-in pattern registry and proved the exported segments could reproduce the file. The clean boundary gave the later site a rendering format without asking Rails to parse pattern files.

This sprint did the same source extraction for bundled agent prompts. The brief kept authored descriptions out of the dataset and asked for file facts: identity, role, stage, full Markdown, and override order. The gate stayed green, so prompt discovery became a generated inventory without changing prompt resolution.

This sprint asked for menu rows and keybindings without depending on a terminal. That was the first root extraction unit to push against runtime assumptions, and the run facts record a failed execute attempt before the gate accepted the final work. The stress fits the boundary: turning live TUI structures into headless inventory required separating registry construction from display state.

This sprint introduced mirrored descriptions for the handover vocabulary an operator sees when a run stops or asks a question. The brief made the manual prose accountable by requiring exhaustive enum matches. The worker could focus on naming existing values and describing them, while the compiler guarded future additions.

This sprint extended the same mirrored-table pattern to run journal events, pattern events, and step phases. It was a contained vocabulary unit because the brief asked for wire names and meanings, not payload schemas. The run stayed green, which fits a repeatable pattern after the handover vocabulary proved the approach.

This sprint closed the root side by pinning narrative documents against generated inventories and documenting the maintenance loop. Its boundary was documentation correctness, not new product behavior. It stayed green because the exporter already supplied the rows the pins needed.

This sprint copied the root dataset into the app and added the identity gate before any page read it. The scope deliberately stopped at data flow, so the fresh worker did not have to design views while proving the copy contract. The ledger shows retries in the milestone wrapper, but this child unit itself passed its local boundary.

This sprint built the page catalog, shared frame, route, and hub before any specialized table page existed. That made later page sprints simple consumers of a stable reader and navigation contract. It passed without repair, giving the milestone a frame that later rows could extend rather than reargue.

This sprint is where the website work fought back. It had to render settings, environment variables, verbs, and flags from the dataset while respecting build availability and hidden surface. The run facts show repeated starts, failed and errored gates, troubleshooting, and a fix before acceptance, marking this as the main integration stress between generated rows and Rails views.

This sprint added harness, role, stage, and MCP tool pages on the frame built earlier. The brief kept the split clear: harness configuration belongs with harnesses, general environment variables stay on configuration, and tool schemas render from data. The run stayed green because it followed an established page pattern after the configuration page work settled the table conventions.

This sprint carried the section's densest table work: menus, keybindings, run-stop vocabulary, and journal events. The cut was still manageable because the previous milestone had already exported the rows and descriptions. It passed cleanly by grouping the long surfaces rather than trimming them.

This sprint built the generated page families for patterns and prompts. Its key boundary was letting the catalog derive item pages from dataset rows rather than hand-writing routes or page entries. It stayed green because the exporter had already shaped pattern segments and prompt text for direct rendering.

This final sprint proved the section as a whole instead of one page at a time. The brief asked for dataset inventory ownership, page reachability, narrative cross-links, and end-to-end closeout of earlier promises. It passed without repair, making coverage a continuing gate rather than a launch checklist.