Runs That Build Until a Goal Passes

This sprint removed duplicated tiny key-value parsing before goal front matter depended on it. The brief gave a fresh agent a compatibility task with a clear boundary: move existing consumers to one parser while preserving old edge cases. It passed without a recorded repair, which fits a refactor whose proof was byte-for-byte behavior.

This sprint gave later agents a real verdict to pass around instead of asking them to encode unfinished work as failure text. The scope stopped at types, serialization, history, and attach transport, so it could be proven before any producer existed. Its boundary stayed green because the sprint was explicitly required not to make existing jobs emit amber.

After transport could carry amber, this sprint owned the observable side. Its task was small enough for a clean agent because it dealt with replay, headless output, JSON, and TUI presentation for a synthetic state, not with goal execution. The gate stayed green, so amber rendering was proven before any real run emitted it.

This sprint turned command checking into a polarity-aware operation. A fresh agent could hold it because the work was the shared command core, not the drivers that would later schedule campaigns or iterations. The green boundary mattered: existing gate baseline behavior had to remain the same while goal polarity became available.

This sprint finished the reusable goal module without exposing goal mode at the CLI. The boundary was concrete: parse the new keys, preserve existing sprint metadata, and freeze the goal command Gantry can freeze. It remained green, giving later driver work a tested anti-cheat rule to rely on.

This sprint extracted the reusable middle of a milestone-planned build from run setup and final landing. It was a manageable cut because existing milestone behavior supplied the regression oracle while the new primitive ran under a caller-supplied orchestration area. A replan ran after review, showing that this seam affected how remaining work should be described even though the gate itself stayed green.

This sprint separated the user's run identity from a plan file synthesized inside the orchestration area. A fresh agent could verify that without needing the future goal loop: synthesized plans only had to feed the campaign primitive while resume continued to resolve through the original invocation. The run recorded no stress at this boundary.

This sprint moved partial merge from a map-only check into a per-driver capability. The work was bounded by keeping map behavior as the only active yes while every other driver still refused honestly. That made the future goal and loop opt-in a small interface decision rather than a rewrite of merge safety.

This is where the refactor milestone pushed back. The first attempt failed and was re-scoped to a rendering seam only, with live event, codec, journal, and replay wiring explicitly moved into the goal milestone. That made the retry small enough for a fresh agent: prove all existing surfaces can render one descriptor type without yet changing the event source.

This sprint unified review prompts by making altitude an explicit parameter. The boundary stayed clear because sprint review could keep edit-capable behavior while milestone review remained read-only, both using one trailer parser. The run recorded a green result, giving later cycle and run review work a shared review surface.

This sprint changed the public starting surface while preserving legacy resume. It was deliberately mechanical: hide the forced flat-build front door, warn for deprecated aliases, and keep the flat pipeline as internal machinery. The green boundary meant later drivers could assume milestone planning was the normal entry path.

This sprint inherited the unfinished half of the progress descriptor seam. It had to move descriptors through live events, durable history, attach, replay, and front-end folds without changing legacy progress text. The run facts show repeated errored replan attempts attached to this sprint after it completed, which marks live progress as the hardest boundary in the goal driver.

This sprint established the goal job identity before any cycle work existed. Its boundary crossed flag parsing, mutual exclusion, baseline test and goal verification, job persistence, and frozen snapshots. The first gate went red and a fix pass was needed, which locates startup validation as real integration work rather than pure wiring.

This sprint made each goal cycle feed the normal milestone planner with a synthesized plan. The unit was small enough because it did not execute the campaign; it only composed, stored, and reused the cycle plan from goal prose, captured output, and previous cycle context. Its green boundary gave the next sprint a deterministic plan artifact to build.

This sprint proved that a cycle is one ordinary campaign, not a parallel execution model. Its responsibility was to run the synthesized plan through nested cycle, milestone, and sprint ledgers with coherent events and resume behavior. The gate stayed green, so the later loop could add termination policy around a trusted inner campaign.

This sprint wrapped the single cycle with goal checks and stop reasons. The work was bounded around termination: green goal, still-amber continuation, empty-plan discrepancy, ceiling, and campaign failure. A replan ran after this unit, showing that the successful cycle loop changed how the remaining review and surface work had to proceed.

This sprint made the long-running goal mode operational. It had to derive resume and partial merge decisions from durable cycle artifacts, not live preannounced rows, because the live roster could name work before it existed on disk. A gate failure after review required a fix, which is consistent with a boundary involving persisted state and merge safety.

This sprint placed the shared reviewer at the new goal boundaries. It separated cycle review from whole-run review and made scheduling depend on completed cycle outcomes rather than preannounced rows. The run stayed green here, which suggests the earlier altitude reviewer seam did what this driver needed.

This sprint closed the goal driver by wiring it into CLI help, status, list, replay, headless, JSON, attach, and an end-to-end throwaway-repo scenario. Because the engine work already existed, the sprint's boundary was mostly surface coherence and broad integration proof. It stayed green, making the milestone publishable as a complete job type.

This sprint established the loop job contract before any iteration body existed. It reused the shared goal machinery for optional frozen goals and baseline polarity while adding loop-specific validation and durable job identity. The gate stayed green, so later iteration work could assume startup and resume routing were already settled.

This sprint implemented the normal iteration path before any red recovery or stop policy. The cut was a single green loop body: fresh agent, invariant test, commit, ledger row, and iteration-shaped progress. Its green boundary gave the next sprint a known-good state transition to defend against regressions.

This sprint added the safety policy for bad iterations after the green path existed. A fresh agent could focus on bounded repair, revert, red ledger rows, and systemic halt without also inventing iteration execution. The run stayed green, showing the policy composed cleanly over the previous unit.

This sprint attached the frozen goal check to the green iteration path. The invariant test remained the per-iteration safety check, while the goal became the run terminator after committed work. The boundary stayed green because red and empty-diff behavior had already defined when not to spend another goal check.

This sprint added the non-goal termination ladder. It was deliberately separate from goal cadence so open-ended loops could be bounded by sentinels, empty-diff quiescence, ceilings, and discrepancy stops without confusing those outcomes with success. The run recorded no repair here.

This sprint made loop state durable enough for interruption and partial landing. The brief tied resume to persisted rows and repository state rather than live-only memory, which kept the task scoped for a fresh agent. The green run boundary meant iteration recovery and termination state could be reconstructed from disk.

This sprint made loop completion pass through the same review discipline as other successful runs and carried loop-specific progress through operator surfaces. A replan ran after the sprint, and the top ledger records its plan impact: remaining public copy had to say final merge follows a usable clean run-level review. That feedback directly shaped the next milestone.

This sprint finished the loop driver with user-facing command coverage and broad throwaway-repo tests. It was the right final cut because all internal behavior already existed, so the sprint could validate the whole workflow rather than design the loop body. The gate stayed green and closed the driver milestone.

This sprint split the old combined mode surface into independent Build, Map, and Design destinations. It was structural website work with clear routing, navigation, view, and style boundaries. The first gate failed and a fix pass followed, locating the difficulty in turning the new page structure into tested Rails behavior.

This sprint added the public Loop explanation after the Build page's merge story, with goal campaigns primary and the simpler loop as an aside in the original plan. It carried the review-gated completion correction from the previous milestone, so copy accuracy was part of the task boundary. The first gate went red and was repaired, which fits a prose-and-view sprint where tests protected exact wording and order.

This sprint was the thin follow-through after the web structure and Loop copy existed. It aligned the docs page and content reference with the new command surface, removed the retired sprint flag from user-facing docs, and kept critical links current. The run stayed green, which is what a bounded docs synchronization unit should do when the behavior is already implemented.