Milestone and Sprint Patterns
Patterns Split Into Authored Halves
The build pattern gained discovery-time inclusion, then used it to ship milestone and sprint as separate files.
2 milestones 7 tasks 20 agents
7 plan 7 execute 9 review 2 fix
401k peak context
228k median execute
13h 15m total 27m 17s per task
16m 10s plan 3h 25m execute 54m 53s review
161 edits 1.2k commands
claude harness
196.7M tokens in 915.4k tokens out
$154.12 nominal cost
This run changed the way Gantry authors its own default build pattern. The first milestone added discovery-time inclusion to the pattern language, a composition form that merges files before validation so the interpreter still sees one pattern. The second milestone used that form to split the old shared inner unit into the shipped milestone and sprint pair, then proved that old recordings and live documentation still made sense after the rename.
The current tree still carries that shape. Build and design patterns invoke milestone, milestone includes sprint, and sprint declares itself included-only material. The split is not a runtime child boundary: the composed pattern shares branches, channels, counters, and the completion contract, while docs and tests describe how a project can override either half.
How this walkthrough is structured
Feature
What did the run build and ship?
Gantry now has an include form for authored pattern fragments and a bundled milestone and sprint pair that compose into the build pipeline.
Build
How did Gantry structure the work?
The cut separated a new composition mechanism from the shipped pattern migration, with early gate repairs confined to inclusion and merge stress arriving after the run was otherwise green.
Milestone 1
Pattern Discovery
3 tasks 11 agents 2h 53m wall time 287k peak context $56.26 nominal cost
The current pattern language still exposes include as discovery-time composition. Included blocks, rules, counters, channels, and the inner unit contract merge into the includer, while header identity stays with the including pattern. Branch targets can cross the authored file boundary, cycles are refused across both composition forms, and a load path with no resolver refuses half-composed material instead of silently dropping it.
This milestone carried the language mechanism before any shipped pattern depended on it. Its sprints moved from composition itself, to frozen run reads, to the normative specification, which let each fresh agent work against a narrow contract. The first two implementation units hit red gates and were repaired, locating the hard part in getting every reader to compose the same raw closure. The documentation unit then stayed green because behavior had already been settled.
Pattern Language Integration
3 agents 1h 16m wall time 287k peak context 136.3k tokens out $25.25 nominal cost 1 fix
The language module now has an include step, a composed-pattern loader, direct reference discovery, and explicit errors for uncomposed inclusions and collisions. The implementation parses included material, substitutes only declared parameters, merges the material, and replaces the include site with a branch into the included entry. Tests keep the form exercised on fixtures rather than on the shipped pair alone.
This sprint built the core include form without touching the bundled pattern set. The brief asked for syntax, recursive composition, parameter substitution, collision refusals, cross-file branch validation, and run-local override resolution all at once. Its gate went red and needed a repair, which fits a boundary where parser, resolver, substitution, and validation assumptions all met. Once fixed, it left the following sprint a callable composition entry point instead of an idea in a plan.
Capture and Restore State
3 agents 1h wall time 228k peak context 121.3k tokens out $17.36 nominal cost 1 fix
Runs now freeze included pattern source as raw closure entries and later compose from the frozen map. Resume does not consult the live registry for included bytes, prompt and inline script discovery can see material from included files, and diagram surfaces render the composed definition. The run identity story remains raw-source based, so a pattern with no inclusion keeps its previous identity behavior.
This sprint moved inclusion from discovery into the run lifecycle. The agent was asked to make frozen closures contain included files and to make resume, runtime invocation, prompt discovery, script materialization, and diagram reads compose from those frozen bytes. The gate went red after review and was repaired, showing that the boundary was not syntax but every secondary reader of pattern source. The sprint still finished without a retry, leaving a stable run pin for shipped inclusion to rely on.
Specify Pattern Form
2 agents 15m 41s wall time 93k peak context 28.1k tokens out $4.12 nominal cost
The specification now describes include syntax, merge rules, parameter refusals, shared namespaces, branch resolution, closure freezing, resume behavior, and the distinction from runtime sub-patterns. The manual also points authors to the second composition form. Later documentation expanded the shipped pair, but the normative include section still carries the rules an independent author would need.
This sprint deliberately carried documentation only after the runtime behavior had been proven. Its brief told the worker to read the code as built, reconcile older claims about private namespaces, and leave conformance slicing intact. The unit stayed green, which matches a task whose risk was precision rather than integration. It closed the milestone by turning the implementation into the language contract the next milestone could cite.
Milestone 2
Pattern Migration
4 tasks 11 agents 2h 36m wall time 401k peak context $82.92 nominal cost
The shipped pattern set now names the reusable build unit as milestone and sprint. The milestone file owns planning, gate authoring, the sprint loop, and recovery; the sprint file owns the per-sprint execute, gate, repair, review, and commit pipeline. Registry surfaces understand included-only material, historical names resolve through one compatibility mapping, and the manual documents how overriding either half changes the composed run.
This milestone consumed the inclusion mechanism and applied it to Gantry's own build pattern. Its sprints first prepared registry surfaces and a parity baseline, then split the files, then proved old recordings, then swept prose and retired the plan. The leaf gates stayed green, so the main stress appeared at integration: the final merge needed conflict resolution after broad live-tree edits. That is the boundary a vocabulary and pattern migration naturally creates, where many surfaces agree on one new naming scheme.
Fragment Patterns and Parity
2 agents 29m 45s wall time 213k peak context 79.5k tokens out $14.38 nominal cost
Pattern headers can now declare included-only material, and registry entries carry that fact without loading the fragment. Human listings can describe the entry, while surfaces that must render runnable patterns skip it by rule. The tree also keeps a pre-split structural baseline for the retired build unit, so the split is measured against a generated record rather than memory.
This sprint prepared the tree for a fragment before the real fragment existed. The worker had to teach registry-listing, rendering, diagram, and selectable-pattern surfaces that a registry entry can be included-only material, then capture the old build unit as a structural baseline. Its green run meant the later split could change files against a recorded fixed point rather than inventing policy mid-migration. The scope was intentionally fixture-driven, keeping the shipped set untouched.
Ship Milestone and Sprint
2 agents 59m 31s wall time 401k peak context 163.1k tokens out $37.49 nominal cost
The current bundled patterns include milestone and sprint, with no active bundled pattern under the retired name. Build, design, and redesign invoke milestone, and milestone includes sprint through a loop-body wrapper. The sprint half is marked included-only and declares the shared completion and channel contract; the milestone half supplies planning, baseline grounding, and escalation blocks.
This sprint did the actual split after the fragment policy and parity baseline were in place. The brief constrained the agent to a renaming and refiling change: move the per-sprint pipeline into sprint, keep planning and recovery in milestone, preserve behavior, and prove equivalence with the wrapper block inclusion introduces. It stayed green, which is the important signal for a mechanical-looking but high-blast-radius move. Compatibility proof and prose were left for later sprints rather than folded into this central edit.
Handle Legacy Runs
2 agents 27m 17s wall time 236k peak context 78.3k tokens out $14.31 nominal cost
The pattern language now has a single historical-name resolver that maps the retired build-unit name to milestone when a reader only has the recorded name. Replay and record-maintenance coverage read a fixture that still contains the old pattern file and old level labels. Resume remains grounded in the frozen run material rather than the live registry, preserving the exact recorded view of an interrupted run.
This sprint handled recorded and resumable runs after the live registry had changed. Its task was to read the real replay, reconstruction, repair, and resume paths before adding tests, because some paths use frozen material while others hold only a historical name. The unit stayed green, showing the compatibility story could be pinned without adding a second alias path. It also copied a real pre-rename recording as evidence instead of fabricating one from the new tree.
Documentation and Prose Sweep
2 agents 24m 10s wall time 205k peak context 70.1k tokens out $11.17 nominal cost
The manual now describes the shipped milestone and sprint pair, their two-way contract, and the override surface for replacing either half. The specification names the pair in the shipped material section, live docs use the new vocabulary, and the completed plan has moved out of the active queue. Remaining occurrences of the retired name are deliberate historical records, compatibility fixtures, or tests whose subject is that historical name.
This final sprint made the written tree match the built tree. The brief asked for the manual, specification, live docs, prompt references, code identifiers, generated artifacts, and the live plan queue to be swept under a clear historical-record boundary. It stayed green, so the only remaining run stress was outside the sprint, in merge conflict resolution after the broad rename crossed other work. The unit was last because it depended on the exact contracts and compatibility fixtures written by the earlier migration sprints.