skip to content

Replays of Gantry building Gantry

Gantry jobs generate detailed logs, which can be used to replay them. On this page a number of such jobs are presented, as screencasts and case studies.

142 replays 3.4k sessions 20.3M output tokens 198k avg peak

Gantry jobs building Gantry

  1. 1 milestone 8 tasks 27 agents 196k peak context 4h 55m

    Unify Run Re-entry

    Unified Run Re-entry

    Existing runs re-enter through `gantry resume`.

    Feature
    The current tree routes a plan address for an existing run through the same resume path and documents the position-checkpoint variation.
    Build
    The cut put the shared re-entry contract in a milestone, while the run record leaves its gate failures unattributed to a unit.

    Gantry milestones

  2. 4 milestones 15 tasks 62 agents 245k peak context 7h 52m

    Patterned Merge Path

    Merge Repair as Pattern Execution

    Finish-time merge repair moved into the selected pattern.

    Feature
    The current tree expresses merge repair through bundled patterns and an engine-owned finish bracket.
    Build
    The run separated the contract, selection, invocation, and record changes into four green milestones.

    Gantry milestones

  3. 1 milestone 8 tasks 28 agents 202k peak context 5h 58m

    Known Task Rail

    The Tasks Rail Before Work Starts

    A run that made readable nested task lists visible before their work began.

    Feature
    The current tree documents task-list directories by container task path and contains the preview and card-headline behavior the milestone describes.
    Build
    One milestone gathered task-list previews, their live-enumeration boundary, and task-aware card names into a single engine change whose gate required a retry.

    Gantry milestones

  4. 2 milestones 4 tasks 21 agents 119k peak context 1h 34m

    Resume Verdict Guard

    Safe Resume Verdicts

    Resume keeps unfinished work visible in the ledger and checkpoint state.

    Feature
    A resumed run now preserves unfinished verdicts and restores the iteration context needed to continue them.
    Build
    The cut split resume correctness between the ledger's current verdict and the checkpoint's restored frame state.

    Gantry milestones

  5. 4 milestones 21 tasks 71 agents 244k peak context 8h 4m

    TUI Directory Split

    A code-motion refactor that divided the terminal monitor by ownership.

    Feature
    The current tree retains the TUI directory roots, pane-owned rendering modules, surface-owned state modules, and the checker that supports later code motion.
    Build
    The cut used stable module boundaries and a code-motion check to divide the terminal monitor without making a broad behaviour change.

    Gantry milestones

  6. 4 milestones 14 tasks 53 agents 238k peak context 7h 22m

    Unified Documentation Set

    Documentation With One Source

    A documentation migration that joined website pages, installed docs, generated inventories, and CLI help.

    Feature
    The tree still has the root manual, generated reference markdown, materialized documentation, and usage help, while the website source-document reader is no longer present.
    Build
    The cut divided a documentation migration into authored source, generated reference material, installed copies, and the command surface that points readers to them.

    Gantry milestones

  7. 2 milestones 9 tasks 32 agents 200k peak context 2h 38m

    Interface Assertion Sweep

    Assertions at the Interface

    A sweep that kept tests on observable contracts rather than rendered sentences.

    Feature
    The current tree keeps tests on values and interface presence while the archived plan and accounting retain the rule and its scope.
    Build
    The cut separated the Rust-side rule from the Rails sweep and closeout, leaving each milestone a bounded assertion audit.

    Gantry milestones

  8. 2 milestones 7 tasks 28 agents 172k peak context 2h 25m

    Stranded Run Recovery

    Resuming and Finishing Recorded Runs

    Recovery for unfinished merges and completion from the run record.

    Feature
    An uncommitted merge is recoverable at resume, and recorded completed work can close a run through `gantry merge`.
    Build
    The cut separated worktree recovery from recorded completion, giving each boundary its own acceptance criteria.

    Gantry milestones

  9. 5 milestones 20 tasks 71 agents 213k peak context 6h 29m

    Dead-Code Cleanup

    Shipping-Target Linting and Code Removal

    A cleanup cut that made production reachability part of the gate.

    Feature
    The current tree retains the shipping lint, its release-pattern validation, and the later module surfaces that carry the cleanup forward.
    Build
    The cut made production reachability enforceable before dividing the resulting cleanup across focused ownership boundaries.

    Gantry milestones

  10. 4 milestones 13 tasks 66 agents 236k peak context 10h 59m

    Checkpoint Restore

    Resume From the Position Checkpoint

    Resume restores committed state and runs forward from the checkpoint.

    Feature
    The tree now contains checkpoint reconstruction support, resume diff handling for trailerless operator commits, synchronized pattern reference data, and published pattern docs for checkpoint restore.
    Build
    The cut kept the interpreter-state work separate from resume execution, then used the later pattern and docs units to settle the consequences of that restore rule.

    Gantry milestones

  11. 5 milestones 11 tasks 50 agents 173k peak context 3h 16m

    Merge Integrity

    Home Branch Merge Integrity

    Gantry states, checks, and repairs the home-branch-wins rule across integrate, resume, merge-back, and repair surfaces.

    Feature
    The tree now carries prompt and documentation text for the rule, guards around merge state and merge results, and repair commands that report and restore lost home-branch paths.
    Build
    The run split home-branch merge integrity by boundary: stated rule, resume cleanup, integrate validation, fallback and merge-back, then repository-history repair.

    Gantry milestones

  12. 4 milestones 18 tasks 65 agents 194k peak context 5h 47m

    Simulation Framework

    Full-Run Simulation Coverage

    Gantry gained scenario data for stopped runs, resume incidents, and merge-family outcomes.

    Feature
    The current tree still carries typed stop identity, `SimulationRunner`, stop-corpus scenarios, merge and resume scenarios, and the stop identity blind-spot report.
    Build
    The cut put stop identity before simulation, then let corpus work stress the framework at the boundaries where scenario data had to prove stopped-run evidence and resume behavior.

    Gantry milestones

  13. 3 milestones 10 tasks 38 agents 245k peak context 4h 13m

    Declared Gate Work

    Declared Gates in the Pattern Runtime

    Gantry made gate commands explicit across pattern loading, run boundaries, and run reports.

    Feature
    The current tree requires explicit gate commands, runs declared run-scoped gates at run boundaries, and persists parsed gate coverage when a supported log format appears.
    Build
    The cut kept the format change, boundary rewrite, and reporting add-on separate, and every recorded stage completed without recovery or re-plan.

    Gantry milestones

  14. 3 milestones 11 tasks 42 agents 286k peak context 1h 36m

    Card Headline Truth

    Truthful Event Cards

    Card headlines, qualifiers, plan-change labels, and review summaries now come from declared runtime facts.

    Feature
    Gantry now renders step-backed cards from declared titles, derives task-position qualifiers from runtime paths, treats plan-change review as review, summarizes review cards through the existing summarizer, and records an audit of that surface.
    Build
    The build split card truth into source selection, runtime qualifier truth, and review summary verification, with the hardest stress falling after the position and merge semantics entered shared runtime code.

    Gantry milestones

  15. 2 milestones 9 tasks 37 agents 243k peak context 2h 57m

    Brief Repair and Prompt Truth

    Reviewer Brief Authority

    The build loop now records rejected attempts, lets review repair bad briefs, and bounds retry recursion.

    Feature
    The surviving tree carries the sprint pattern's reviewer brief contract, attempt ceiling route, stop-record wording, and mirrored reference data.
    Build
    The cut separated task memory from convergence policy, so the first milestone could make retry context and brief repair trustworthy before the second milestone changed how retries stop.

    Gantry milestones

  16. 6 milestones 31 tasks 247 agents 245k peak context 23h 50m

    Stop Recovery Redesign

    Typed Stop Recovery

    A stop model redesign that made recovery, replay, and retry read from typed records.

    Feature
    The current tree has `on_stop` in the bundled patterns, typed `StopRecord` data in the identity journal, structured stop evidence, replay admission checks, and harness-neutral transient retry classification.
    Build
    The decomposition put the language contract before runtime state, then made evidence, replay admission, hook dispatch, and cleanup depend on the typed stop record already in place.

    Gantry milestones

  17. 2 milestones 7 tasks 43 agents 189k peak context 2h 3m

    Agent Step Metadata

    Pattern agent steps gained stage declarations, role selection overrides, and generated task card text.

    Feature
    The tree now carries agent-step stage keys through parsing, reference data, runtime events, and generated task metadata fallbacks.
    Build
    The cut put the format and runtime contract before display reuse, so task card text could depend on resolved stages instead of adding another display-only exception.

    Gantry milestones

  18. 24 tasks 74 agents 244k peak context 8h 14m

    Production Pattern Runs Become Durable

    The run finished the pattern engine's state, boundary, prompt, CLI, and record contracts.

    Feature
    Gantry now reads modern pattern runs through invocation-scoped state, full task paths, declared task-list directories, honest pattern events, bundled map and until entry points, and a pause-based partial merge workflow.
    Build
    The decomposition cut the production world by contract boundary, so state identity, tree movement, agent context, entry parameters, and record honesty could each be carried by small agents before the final merge tested them together.

    Gantry milestones

  19. 5 tasks 14 agents 142k peak context 50m 42s

    Record-Derived Run Surfaces

    Cold projection, fleet records, and resume completion now read the same durable facts.

    Feature
    Cold projection, fleet records, and completion routing now preserve the run shape and completion state from recorded data and repository checks.
    Build
    The cut kept the record-read repairs and the resume-route repair in one milestone, then split the work by the surface that consumed the authoritative fact.

    Gantry milestones

  20. 14 tasks 39 agents 238k peak context 3h 52m

    Task Vocabulary Convergence

    Gantry renamed its generic work item to task while keeping historical records readable.

    Feature
    The tree now exposes task vocabulary through engine records, prompts, docs, Rails replay code, analysis scripts, and screencast tooling while serde aliases and legacy keys still read older data.
    Build
    The cut separated Rust compatibility work, prose surfaces, and adjacent app and tooling code so each fresh agent could judge vocabulary by boundary rather than by search-and-replace.

    Gantry milestones

  21. 7 tasks 16 agents 140k peak context 12h 38m

    Post-Completion Records

    Post-Completion Record Tails

    A record-maintenance run that preserves finished-run artifacts written after the last ordinary run-record commit.

    Feature
    The current tree has the record-tail backfill module, singular and plural CLI verbs, worktree reclamation protection, a late final record commit path, tests, and user-facing documentation.
    Build
    The run treated post-completion records as a single maintenance boundary, small enough to split by command, guard, lifecycle, and documentation while still proving the loss path end to end.

    Gantry milestones

  22. 5 milestones 32 tasks 133 agents 246k peak context 21h 30m

    Pattern Language Redesign

    Format Two Pattern Language

    A complete migration from the retired pattern model to the current language, runtime, corpus, and surfaces.

    Feature
    The current tree has a strict pattern reader, a typed execution path, shipped current-language patterns, regenerated reference data, and website surfaces that consume that data.
    Build
    The run was cut as a dependency stack, with the contract made reviewable before execution, execution before the corpus, the corpus before deletion, and deletion before public surfaces.

    Gantry milestones

  23. 1 milestone 2 tasks 11 agents 93k peak context 8h 12m

    Home Merge Halt

    Dirty Home Checkout Halt

    Gantry now reports Git refusing a final merge as a resumable home checkout stop.

    Feature
    Gantry now preserves Git's refusal, named paths, and resumable run state when the home checkout blocks final landing.
    Build
    The run treated the defect as a contract split followed by presentation work, with the only recorded stress appearing at the final integration boundary rather than inside the child sprints.

    Gantry milestones

  24. 1 milestone 2 tasks 9 agents 186k peak context 5h 58m

    Feed Card Durations

    Durations That Survive the Feed

    Making activity cards tick while open, freeze when closed, and replay with the same timing.

    Feature
    The feed, journal replay, headless output, and stage statistics now share durable elapsed values for timed work while preserving already reported card metrics.
    Build
    The run first established a card-level timing contract, then fed it from mechanical close events, with final integration needing resolver attention after the milestone itself had stayed green.

    Gantry milestones

  25. 2 milestones 7 tasks 15 agents 194k peak context 2h 3m

    Process Fence Repair

    Process Fence Contract

    Gantry returned its sandbox to a process wrapper and documented where confinement belongs.

    Feature
    The live project now describes and implements Gantry's built-in sandbox as a process fence, with stronger confinement assigned to external operator boundaries.
    Build
    Gantry split the repair into runtime contract and public contract milestones, and each unit crossed review and gate without recovery or replan.

    Gantry milestones

  26. 1 milestone 6 tasks 13 agents 192k peak context 2h 54m

    Stop Recovery Projection

    Stopped Runs Read From Projection

    The monitor, status, controls, and cleanup paths moved onto shared run state.

    Feature
    The current tree still routes stopped-run display, controls, status, and cleanup through shared projection, action, roster, and fold code.
    Build
    The run was cut as one milestone whose sprints established shared projection contracts first, then made every front-end surface consume them without any recorded red gate or re-plan.

    Gantry milestones

  27. 3 milestones 10 tasks 22 agents 131k peak context 5h 24m

    Recovery Stop Engine

    Stop handling became a verified recovery path instead of a recoverability guess.

    Feature
    The current tree still carries the run's recovery engine: acquired contexts are reused, journaled stops are factual, halt hooks resolve through checks, takeover discards are parked, and user-facing stop outcomes are outcome based.
    Build
    The cut staged stop recovery from internal contracts through verified takeover mechanics and then surface cleanup, with the only recorded stress landing at the foundation milestone boundary rather than inside an individual sprint.

    Gantry milestones

  28. 3 milestones 14 tasks 30 agents 181k peak context 11h 39m

    Sandbox Private Home

    Sandbox Write Boundary

    Gantry tried to move agent writes into run-owned storage, then left a visible record of what survived and what was withdrawn.

    Feature
    The shipped tree later replaced the write-boundary claim with a process-fence contract, while retaining shared wrapper resolution, visibility metadata, MCP parity, and the historical documentation trail.
    Build
    The run separated sandbox policy, runtime adoption, and proof work into milestone-sized cuts, with unit gates staying green while final integration needed reconciliation.

    Gantry milestones

  29. 1 milestone 6 tasks 13 agents 204k peak context 4h 7m

    Core Structure Cleanup

    Core Refactors Without Behavior Drift

    Gantry cleaned up shared predicates, feature boundaries, command ownership, rendering layers, diagram modules, and tiny config parsing.

    Feature
    The live core still carries the cleanup as shared runtime decisions, narrower feature exposure, clearer module ownership, and parser plumbing that replaces duplicated hand lexers.
    Build
    The run kept independent refactors in sibling sprints under one structural milestone; the child work stayed green, while integration stress appeared only at the final merge boundary.

    Gantry milestones

  30. 1 milestone 4 tasks 9 agents 188k peak context 59m 26s

    External Agent Window

    Detached Blocker Investigations

    Blocker-launched agents can open outside the live TUI while inline suspend remains available.

    Feature
    The current tree still carries the external terminal resolver, configuration schema, diagnostic command, detached TUI launch path, and documentation, while one confirmation promise has since drifted in code.
    Build
    The build put the launch policy behind a pure resolver first, then let each later sprint consume one stable contract without a repair or replan.

    Gantry milestones

  31. 3 milestones 11 tasks 25 agents 187k peak context 2h 46m

    Operational Fixes

    Gantry hardens run control, reporting, lint checks, and source-review packaging.

    Feature
    The tree still carries the hardened command paths, runtime guards, stats model, lint gate, and source-review archive checks this run introduced.
    Build
    The build split a broad external review into contract-sized milestones, with only the reporting cut needing a repair pass before the rest composed cleanly.

    Gantry milestones

  32. 4 milestones 13 tasks 26 agents 164k peak context 2h 52m

    Troubleshoot Before Halt

    Recovery Gets the First Pass

    A recovery rebuild that moved repair, halt routing, pause, and plan cleanup into the shipped flow.

    Feature
    The tree now carries a shared troubleshoot prompt, pattern-declared halt hooks, pause and resume controls, compatibility wording for retired stages, and a live plan queue that treats the recovery cluster as landed.
    Build
    The work was split by recovery boundary, letting mostly green sprint rows carry prompt repair, halt policy, pause semantics, and cleanup without mixing operator intent with failure handling.

    Gantry milestones

  33. 1 milestone 4 tasks 9 agents 154k peak context 51m 30s

    Fresh Assessment Resume

    Fresh Resume Verdicts

    A stopped run is reassessed from present durable state before Gantry tries recovery again.

    Feature
    Gantry now projects old stops as history, records newly surfaced stops before an owner can disappear, retries recoverable resume stops through the normal verifier, and scopes stash refusal to the current worktree.
    Build
    The cut made resume state a sequence of durable facts, then put recovery and stash rollback behind that same assessment contract without needing a re-plan or repair pass.

    Gantry milestones

  34. 3 milestones 8 tasks 19 agents 145k peak context 1h 52m

    Agent Onboarding

    Installed Agent Manual

    An embedded reference, discoverability paths, and project init command for coding agents.

    Feature
    The current tree still carries the embedded manual renderer, command dispatch, reachability pointers, drift checks, and init behavior that the run introduced.
    Build
    The work was cut as a manual foundation, a discoverability and honesty pass, and a small closing init command, with each boundary staying green in the recorded run.

    Gantry milestones

  35. 2 milestones 4 tasks 10 agents 168k peak context 1h 7m

    Run Continuation Pass

    Proceed From a Live Blocker

    Gantry split investigation from continuation, then renamed the assistant surface without breaking older inputs.

    Feature
    Interactive blockers now offer investigation launchers separately from resolving Proceed and Stop answers, and the current assistant name is the public spelling across commands, prompts, reference data, and documentation.
    Build
    The run was cut into a blocker-continuation milestone and a naming-compatibility milestone, with clean sprint execution and review gates used to prove each boundary before the next surface depended on it.

    Gantry milestones

  36. 1 milestone 4 tasks 10 agents 175k peak context 1h 1m

    Assistant Pane Stop

    Stops In The Transcript

    Stopped and paused runs now appear as assistant-pane entries instead of full-screen modals.

    Feature
    The current tree still shows stopped and paused runs as durable assistant transcript entries, while replay, demo, recent-events, status, and documentation describe the non-modal surface.
    Build
    The run used one milestone to move stop handling from modal ownership to transcript routing, with the only red gate landing where the new assistant entry contract was established.

    Gantry milestones

  37. 1 milestone 4 tasks 9 agents 142k peak context 49m 56s

    Quiet Semantic Gates

    Verified Gate Breaks

    Gantry now proves a clean merge red before treating it as semantic.

    Feature
    The current tree still has the quiet entry sweep, child-held gate lock, verified semantic merge verdicts, focused coverage, and runtime documentation in place.
    Build
    The run stayed green while a single milestone carried the coupled gate story through entry cleanup, lock lifetime, semantic verification, and durable documentation.

    Gantry milestones

  38. 2 milestones 10 tasks 23 agents 214k peak context 3h 20m

    Hermetic Test Policy

    Hermetic Gate Contract

    A post-purge test suite gained hermetic seams, explicit heavy tiers, runtime budgets, and policy text.

    Feature
    The live tree still carries explicit Rails service inputs, marker-selected heavy Rust tests, runtime and flake evidence, and agent guidance that tells future work how not to regrow bad tests.
    Build
    The cut separated hermetic restoration from gate policy, letting fresh agents restore narrow detectors before later agents measured and documented the suite they had produced.

    Gantry milestones

  39. 2 milestones 7 tasks 20 agents 401k peak context 13h 15m

    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.

    Feature
    Gantry now has an include form for authored pattern fragments and a bundled milestone and sprint pair that compose into the build pipeline.
    Build
    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.

    Gantry milestones

  40. 4 milestones 22 tasks 48 agents 240k peak context 32h 11m

    Reference Documentation Build

    Source Built Reference

    A generated reference dataset became the public documentation surface.

    Feature
    Gantry still ships a generated reference dataset and a public section that renders command, configuration, harness, tool, pattern, prompt, menu, stop, and journal facts from source-owned data.
    Build
    The run cut a broad documentation plan into source extraction, dataset proof, vocabulary completion, and web publication, with the hardest stress concentrated where generated facts first met the Rails page surface.

    Gantry milestones

  41. 3 milestones 16 tasks 36 agents 235k peak context 12h 15m

    Fleet Statistics Build

    Native Fleet Statistics

    A local stats command moves from recovered foundation to corpus-grounded dashboard.

    Feature
    The tree now carries a documented `gantry stats` command backed by fleet discovery, cached run folding, corpus reconciliation, aggregate rendering, JSON output, and public reference material.
    Build
    The run cut a broad analytics feature into a foundation, a reconciliation pass, and a presentation finish, with all unit work staying green and the only recorded stress arriving at final merge resolution.

    Gantry milestones

  42. 2 milestones 6 tasks 15 agents 337k peak context 11h 16m

    Process View

    Process Visibility

    Gantry learned to show the process groups a build run owns, from terminal commands to the TUI and MCP.

    Feature
    Gantry now reports a run's recorded process groups through terminal, TUI, and MCP readers that share one verified process model.
    Build
    The run separated process visibility into a shared model milestone and a surface milestone, with only the model/status sprint needing repair before the later readers composed on top.

    Gantry milestones

  43. 2 milestones 10 tasks 20 agents 199k peak context 3h 21m

    Readable Stop Cards

    Readable Run Stops

    Structured stop reasons, durable records, and generated cards for live and cold run views.

    Feature
    Current Gantry still carries structured stop reasons, mechanical rendering, durable stopped events, stop-summary prompts, best-effort card generation, and shared live and cold rendering paths.
    Build
    The run split stop legibility from stop generation, letting the deterministic reason contract land before card storage, prompting, and reader surfaces depended on it.

    Gantry milestones

  44. 1 milestone 5 tasks 11 agents 211k peak context 10h 29m

    Signal Resilience

    Signal Protocol Hardening

    Recovery, advisory reads, and prompt overrides were brought under one signal contract.

    Feature
    The tree now preserves intended signal values through recovery, advisory degradation, generated contracts, stale override refusal, and documented prompt conformance.
    Build
    The cut held the signal protocol as one milestone, with green inner sprint boundaries and stress deferred to the final merge boundary.

    Gantry milestones

  45. 3 milestones 13 tasks 31 agents 239k peak context 33h 13m

    Ghost Reaping

    Run Ownership And Process Reaping

    How Gantry learned to identify live owners, record child processes, and clean them up safely.

    Feature
    The current tree still carries the run lock, process roster, stop and remove safety paths, process readouts, and nested-start guards as one connected process-control layer.
    Build
    The cut moved from ownership truth to process accounting and then to operator commands, with the hard boundaries surfacing in parent-death cleanup and the first stop/reporting passes.

    Gantry milestones

  46. 4 milestones 22 tasks 47 agents 231k peak context 6h 11m

    Pattern Diagrams

    Pattern Diagrams Become Inspectable

    A generic diagram layer, static pattern charts, an interactive surface, and live overlays were built as separate contracts.

    Feature
    The tree now carries a crate-in-waiting diagram module, pattern ASCII commands and snapshots, an interactive TUI surface, runtime overlays, and an extraction readiness record.
    Build
    The run split pattern diagrams into reusable layout machinery, Gantry-specific projection, terminal interaction, and runtime overlay proof, with every nested cut staying within its contract boundary.

    Gantry milestones

  47. 1 milestone 4 tasks 9 agents 173k peak context 1h 2m

    Unified Merge Routine

    One Partial Merge Path

    Make stopped and live partial merge behave the same across every modern run pattern.

    Feature
    Gantry now exposes partial merge as a modern pattern-run capability, with live and stopped paths both described around the committed run-branch tip.
    Build
    The cut used one milestone to remove pattern-specific merge choices, prove live safe stops, pin the committed-tip boundary, and then update the user-facing contract.

    Gantry milestones

  48. 3 milestones 15 tasks 30 agents 240k peak context 3h 57m

    Finish One World

    Pattern World Cleanup

    A run that moved built-in pattern behavior into declarations, compatibility checks, and authored coverage.

    Feature
    Gantry's pattern engine now exposes the former one-world exceptions as declared stages, channels, standing-loop pieces, goal-check authority, plan-source pins, and authored production-world tests.
    Build
    The cut moved from reader-facing declaration rules, through runtime contract deletion, to compatibility and coverage closure, with review-driven replanning only where the documentation boundary needed more work.

    Gantry milestones

  49. 3 milestones 17 tasks 40 agents 189k peak context 3h 29m

    Run Space Reclamation

    Opt In Run Reclamation

    Prune transcripts, purge detailed logs, and clear stale worktrees without erasing run records

    Feature
    Gantry now ships opt-in reclamation verbs that report exact planned impact, preserve durable run records, and distinguish transcript cleanup from stale checkout cleanup.
    Build
    The run used contract-first milestones for a destructive feature, and review feedback between milestones reshaped the remaining work without producing a red gate.

    Gantry milestones

  50. 4 milestones 12 tasks 30 agents 244k peak context 3h 10m

    Script Execution Flow

    Scripted Pattern Control Flow

    Pattern scripts, verdict branches, rule probes, and the documentation that makes them authorable

    Feature
    The current tree still exposes verdict branches, engine-owned script steps, script rule probes, bare rule outcomes, replayable script journals, migrated bundled patterns, and matching public pattern documentation.
    Build
    The run moved from shared branch syntax to production script execution, then reused that contract in rule blocks and docs, with the recorded stress concentrated where new script syntax met the gate and where the last documentation correction had to be repaired.

    Gantry milestones

  51. 8 milestones 57 tasks 114 agents 246k peak context 17h 31m

    First-Class Patterns

    Patterns Become Drivers

    A migration from fixed Rust drivers to typed pattern data, frozen inputs, and declared run shape.

    Feature
    Gantry now carries a pattern language, bundled pattern data, frozen generic invocation state, shape-derived display, declared channels, and data-only design flows in the current tree.
    Build
    The cut repeatedly cleared compatibility leftovers before letting later workers depend on generic pattern state, and the stress showed up where old driver assumptions had not fully disappeared.

    Gantry milestones

  52. 1 task 4 agents 113k peak context 16m 39s

    Content Review Gate

    Review Edits Get Proven Again

    The sprint pipeline stopped trusting path dirtiness when review changes content.

    Feature
    The original driver files are gone, but the current pattern pipeline still verifies reviewer edits before commit and documents the repair path for a red post-review gate.
    Build
    The run collapsed to one sprint and stayed green, with the useful stress located in the extra after-review gate the brief required rather than in a repair loop.

    Gantry milestones

  53. 4 milestones 25 tasks 52 agents 201k peak context 5h 5m

    Pattern Language Audit

    Pattern Language Conformance Audit

    An audit run turned the pattern interpreter from driver smoke coverage into contract evidence.

    Feature
    The tree now carries a machine-readable conformance inventory, a world-contract matrix, mutation sentinels, and interpreter tests that make pattern semantics observable beyond bundled driver smoke tests.
    Build
    The run cut a broad language audit into inventory, interpreter coverage, drift guards, and world-contract closure, with replans concentrated where production effects had to become executable evidence.

    Gantry milestones

  54. 4 milestones 20 tasks 42 agents 198k peak context 4h 16m

    Inner Unit Handover

    Interpreted Inner Work Units

    Moving Gantry's nested task pipeline from compiled control flow into pattern data

    Feature
    Gantry now exposes inner-unit state as pattern data, runs shared sprint work through interpreted child patterns, and projects nested child journals through the current run-view stack.
    Build
    The work was cut from contract to production dispatch to resume proof, with review-driven replans landing where child-world scope and projection compatibility exposed gaps in the original boundary.

    Gantry milestones

  55. 5 milestones 38 tasks 95 agents 542k peak context 31h 5m

    Runs and Patterns

    Pattern Runs Take Over

    The execution engine moves from hard-coded drivers to authored patterns and shared run views.

    Feature
    Gantry now ships pattern definitions, runs them through a generic interpreter, and renders run state through shared projection surfaces that survive in the current tree.
    Build
    The build proceeds from language settlement to shipped pattern execution, with the hardest boundary appearing where old drivers were removed and projection had to read the new journal shape.

    Gantry milestones

  56. 3 milestones 13 tasks 35 agents 244k peak context 4h 57m

    Source Tree Rename

    Product Rename Through The Tree

    Gantry carried its product rename through contracts, stored replay data, source code, docs, and local harness names.

    Feature
    The current tree speaks Gantry on primary code, replay data, commands, docs, and harness-local artifacts, while explicit legacy reads and historical residues remain named as such.
    Build
    The run cut the rename by risk surface, and the stress clustered where Rails autoloading, broad runtime vocabulary, and final documentation residue crossed subsystem boundaries.

    Gantry milestones

  57. 3 milestones 16 tasks 39 agents 244k peak context 5h 38m

    Brand Identity Rename

    Gantry Rename Cutover

    A product rename carried through code, runtime contracts, web surfaces, and release preparation.

    Feature
    Gantry now stands as the product, binary, runtime namespace, documentation vocabulary, and primary web identity, while later site work has revised part of the public-host layer around the company brand split.
    Build
    The run was cut by contract boundary: visible identity first, runtime compatibility second, and public release surfaces last, with replans where reviews found residual names outside the current slice.

    Gantry milestones

  58. 4 tasks 10 agents 235k peak context 1h 43m

    Pinned Home Branch

    Home Branch Pinning

    Gantry records the launch branch, merges back to it, and names it in output.

    Feature
    The current tree still carries a persisted home branch through run metadata, merge checks, partial merge, TUI and headless labels, and live documentation.
    Build
    The run held one branch concept steady across persistence, merge safety, output naming, and documentation, with stress concentrated where the new invariant met final merge and display text.

    Gantry milestones

  59. 2 tasks 5 agents 97k peak context 28m 41s

    Shared Plan Visibility

    Plan Artifact In Every Preamble

    The run made Gantry show scoped workers the durable plan source they can consult.

    Feature
    Current Gantry still persists a source-plan artifact and renders a plan-artifact line into worker preambles when a usable path exists.
    Build
    The run split the work between the shared preamble contract and the driver routing needed to make that contract true for scoped workers.

    Gantry milestones

  60. 2 milestones 9 tasks 22 agents 243k peak context 2h 35m

    TUI Hover Polish

    Hover States for the Terminal UI

    Gantry made its terminal click targets visible under the mouse, then moved menu hover colors through the widget contract.

    Feature
    Gantry now tracks frame-local hover targets for its own clickable TUI chrome and themes menu, dropdown, modal, chat, blocker, and divider hover states through surviving palette and widget contracts.
    Build
    The run split terminal hover polish into Gantry-owned interaction surfaces and an upstream-backed widget refresh, with the only recovery landing where the generic vendor boundary was too broad.

    Gantry milestones

  61. 5 tasks 11 agents 192k peak context 1h 27m

    Resume In Place

    Front-End Run Restart

    A stopped owning monitor can restart the same run without leaving the terminal.

    Feature
    Gantry now has a standing owner-only Resume in place path that re-acquires the run lock, resumes the same identity, keeps the terminal session open, and documents when to use it.
    Build
    The decomposition kept the owner contract, TUI action, session reset, lifecycle coverage, and docs in separate fresh-agent slices, with the final documentation slice taking an extra gate pass after review.

    Gantry milestones

  62. 3 milestones 12 tasks 28 agents 149k peak context 1h 47m

    Prose Map Driver

    Prose Plans Become Map Runs

    The map driver learned to turn prose into checked, durable fan-out specs.

    Feature
    Gantry now routes prose map sources through a generated spec authoring and validation loop before normal fan-out work begins.
    Build
    The run was cut as a front door, an empirical spec check, and a final repair pass, with milestone reviews driving each later tightening.

    Gantry milestones

  63. 2 milestones 9 tasks 20 agents 141k peak context 1h 40m

    Menu System Coherence

    Coherent Monitor Menus

    Make run operations reliable, then give the monitor a smaller menu system with clear ownership.

    Feature
    The current tree still carries live artifact resolution, durable plan inspection, capability-based merge gating, journal reading, blocker visibility, Stats retry detail, and the reduced monitor menu contract.
    Build
    The cut kept the hazardous repair work ahead of the visible menu reshape, with one capability re-plan and one repaired gate marking the places where the boundaries were tested.

    Gantry milestones

  64. 3 tasks 8 agents 156k peak context 45m 10s

    Loop Driver Transition

    Goal Loop Command Surface

    Moving goal campaigns onto `--loop` while giving Ralph its own explicit command.

    Feature
    Gantry now presents `--loop` as the goal campaign command, keeps `--goal` as its alias, and gives the standing Ralph loop the explicit `--ralph` spelling.
    Build
    The run stayed green by treating the rename as a sequence of contracts: routing and persistence first, misroute checks next, and public language last.

    Gantry milestones

  65. 4 tasks 10 agents 227k peak context 1h 10m

    Card Artifact Tags

    Clickable Card Artifacts

    Structured artifact tags on activity cards, opened through the existing TUI pager.

    Feature
    The current TUI still derives card artifact tags from structured state, renders only visible clickable regions, opens them in the shared pager, and suppresses path noise in card text.
    Build
    The run stayed green while moving from a pure artifact resolver through rendering and activation to a final prose cleanup pass.

    Gantry milestones

  66. 3 milestones 16 tasks 33 agents 214k peak context 6h 28m

    Config Schema Studio

    Schema Backed Settings

    A persistent config schema grew into writes, resolution, a terminal form, and checked reference docs.

    Feature
    The tree still exposes a central config schema, schema-aware config loading and writes, source-labeled settings rows, an engine-owned settings write path, a TUI settings modal, and checked config reference material.
    Build
    Gantry carried the settings overhaul by separating schema mechanics, modal form plumbing, and the final editable surface, with replans clustered around effective resolution and guard coverage.

    Gantry milestones

  67. 3 tasks 8 agents 99k peak context 37m 4s

    Blocker Message Flows

    Transcript Blocker Actions

    A blocker prompt became a chat message with keyboard and mouse controls.

    Feature
    The current TUI still routes pending blockers into chat messages with markdown bodies, guarded action focus, composer handoff, and stale-safe button footprints.
    Build
    The cut built the blocker as transcript content first, then made the inline row keyboard-owned and mouse-clickable without recorded recovery or replanning.

    Gantry milestones

  68. 2 milestones 9 tasks 21 agents 141k peak context 2h 19m

    Global Config Harness

    Standing Harness Preferences

    A global config file now resolves harness, model, and assistant choices before Gantry starts work.

    Feature
    Gantry now reads one global config file for standing role, harness, model, and assistant preferences while preserving harness-native model deferral.
    Build
    The run first built a typed global-preference foundation, then sent the user-facing execution and command surfaces back over that foundation until absent model pins stayed absent.

    Gantry milestones

  69. 2 milestones 9 tasks 20 agents 238k peak context 1h 57m

    Identity Demo Build

    Verified Demo Identity

    The demo build stopped identifying users through downloaded bytes and now verifies registered email instead.

    Feature
    Gantry now gates demo builds through verified registered email hashes, while the old binary personalization model and its Rails storage are gone from the current tree.
    Build
    The run split a risky identity change into a removal milestone and a replacement milestone, with only the terminal prompt slice needing a retry before the final merge.

    Gantry milestones

  70. 4 milestones 17 tasks 40 agents 202k peak context 4h 40m

    Assistant Polish Suite

    Daily Assistant Console

    A build-run assistant pane with truthful state, model switching, blocker handling, and matching docs.

    Feature
    The tree now presents the assistant as a build-run console with truthful availability, resizable transcript UI, next-turn model choice, inline blocker handling, and audited MCP documentation.
    Build
    The run split assistant polish into pane foundations, control selection, blocker routing, and truth documentation, with the only major recovery concentrated where stale menu assumptions blocked later work.

    Gantry milestones

  71. 3 milestones 14 tasks 32 agents 203k peak context 2h 55m

    Modal Overlay Rework

    Shared Modals for the TUI

    Gantry rebuilt its dialog overlays on one modal path and made dismissed modal events reopenable.

    Feature
    Gantry now has a shared modal path for dialog-shaped overlays, bounded scrollable modal bodies, repaired global-key fallthrough, recovery actions led by external harnesses, and Recent events entries that can reopen modal content.
    Build
    The run cut a wide TUI rework into a vendored foundation, a full overlay migration, and a modal-history finish, with milestone reviews feeding the two unfinished contracts into the next slice.

    Gantry milestones

  72. 2 milestones 8 tasks 19 agents 230k peak context 1h 42m

    Environment Bootstrap

    Run Briefings Before Worker Prompts

    A run-local environment section became part of the worker preamble surface.

    Feature
    Gantry now composes worker preambles from known run facts, optional environment prose, and bounded run history, with map and checkpoint workers using the same rendered environment section.
    Build
    The work was cut as a lifecycle milestone followed by a prompt-surface milestone, with the milestone review forcing the second pass to close bypasses before cleanup.

    Gantry milestones

  73. 4 tasks 11 agents 202k peak context 1h 4m

    Goal Run Dashboard

    Goal Runs Without a Hidden Limit

    Goal campaigns became open ended by default, with explicit ceilings treated as resumable stops.

    Feature
    Current Gantry still parses goal ceilings as optional, materializes only real goal cycles, stops explicit ceilings resumably, and documents goal campaigns as open ended by default.
    Build
    The run cut the change into contract, lifecycle, rendering, and documentation units, with extra review pressure landing where runtime semantics first met public progress surfaces.

    Gantry milestones

  74. 5 milestones 27 tasks 62 agents 245k peak context 8h 9m

    Plugin Seam Refactor

    Static Extension Seams

    Harnesses and production drivers were pulled behind explicit in-process contracts.

    Feature
    Harness selection still runs through a registry, while the driver seam has evolved into pattern pins, read-side contracts, shared services, and pattern-independent partial merge.
    Build
    The cut separated harness work from driver work, then let reviews reopen the driver side where the first registry pass had preserved too much central dispatch.

    Gantry milestones

  75. 3 tasks 8 agents 161k peak context 32m 39s

    Reader Naming Cleanup

    Reader-Oriented Source Names

    A behavior-preserving cleanup that made Gantry's project vocabulary readable in code and conventions.

    Feature
    The current tree still tells readers to spell out Gantry domain terms, and the live code keeps the major type and orchestration names in full-word form while preserving persisted run layout.
    Build
    The run treated naming as a behavior-preserving dependency chain: document the rule, make the bounded type renames canonical, then sweep the broad orchestration surface after review tightened the remaining work.

    Gantry milestones

  76. 4 tasks 10 agents 153k peak context 56m 36s

    Recovery Pass

    Recover Clean Empty Sprint Attempts

    No-op sprint work is judged by the real gate and recorded through durable completion state.

    Feature
    The old driver code is gone, but its behavior survives in the shipped sprint pattern and interpreter as gate-grounded no-op completion plus bounded recovery for empty failed attempts.
    Build
    The run split no-op recovery into ledger durability, acceptance, failure routing, and proof, with the only retry pressure landing on the final regression pass after review.

    Gantry milestones

  77. 2 tasks 6 agents 126k peak context 26m 24s

    Resume Recovery

    Resume Without Losing Bookkeeping

    Repairing a resume loop by preserving Gantry state and accepting already-satisfied reruns only after the gate proves them.

    Feature
    Current Gantry still preserves orchestration state during interrupted-worktree recovery and carries green no-change completion through the newer generic run machinery.
    Build
    The run cut the resume loop into a preserved-bookkeeping recovery contract followed by an idempotent rerun contract, and both sprint-local gates stayed green.

    Gantry milestones

  78. 4 milestones 19 tasks 46 agents 244k peak context 8h 2m

    Test Suite Redesign

    Tests Stop Owning the Machine

    The root and web gates move toward fakeable driver logic, bounded processes, explicit tiers, and structural page checks.

    Feature
    Gantry now has fake-backed driver tests, bounded gate and runner behavior, explicit root tiers, stress evidence tooling, and structural web assertions still visible in the tree.
    Build
    The build moved from driver isolation through process hardening into tiered root and Rails checks, with stress recorded where real driver coverage resisted the first cut.

    Gantry milestones

  79. 6 tasks 14 agents 244k peak context 3h 49m

    Sprint Recovery Flow

    Reviewer findings became retryable, resumable sprint recovery instead of a hard stop.

    Feature
    The current tree still carries the recovery contract in the pattern runtime, event history, status surfaces, and scenario tests, though the original build-driver files have since been replaced.
    Build
    The cut built the recovery ladder from verdict shape through persistence, action, visibility, and coverage, with only the audit surface needing an extra gate pass.

    Gantry milestones

  80. 5 tasks 12 agents 244k peak context 2h 56m

    Agent Investigation Workflow

    Interactive Snag Investigation

    Blocking prompts became a guided choice between external agents, the internal assistant, shell access, and stop.

    Feature
    The current tree still carries fixed blocker choices, attach and history compatibility, installed-harness launch helpers, TUI pending actions, and documentation that frames blockers as assisted investigation work.
    Build
    The cut held the workflow as a clean sequence of contracts, surface, launcher services, action dispatch, and cleanup, with every sprint staying green and no repair pass reshaping the plan.

    Gantry milestones

  81. 4 tasks 12 agents 124k peak context 2h 5m

    Build Progress Dashboard

    Live Testing Cards

    The build feed learned to tick for mechanical tests and keep finished card durations honest.

    Feature
    Current Gantry still shows testing as human-facing card chrome, folds final stage metrics into completed cards, emits progress from mechanical test commands, and preserves those events through attach and demo paths.
    Build
    The run separated the presentation sweep, finished-card state fold, command-runner heartbeat, and attach/demo propagation so each fresh agent owned one boundary of the feed contract.

    Gantry milestones

  82. 5 tasks 14 agents 222k peak context 3h 5m

    Driver Loop Reliability

    Driver Loop Stress Reliability

    A flaky driver-loop class became a reproducible stress case, hardened git path, and documented closeout.

    Feature
    Gantry now carries a whole-module driver-loop stress preset, hardened shared git invocation, infrastructure-aware control flow, and a durable reliability closeout.
    Build
    The cut put the oracle first, absorbed the only red boundary there, and then let the git, verdict, audit, and closeout work proceed against a stable reproduction.

    Gantry milestones

  83. 3 milestones 15 tasks 43 agents 212k peak context 7h 1m

    Reproducible Source Release

    Prove Your Rebuild Matches the Shipped Binary

    A comment-stripped source tree, a byte-reproducible build, and a script that lets a customer check both.

    Feature
    The tree now carries the comment-strip tool, stripped-tree release scripts, reproducibility tests, and a customer verifier that are still visible in the current source.
    Build
    The run split the problem into a reusable stripping transform, a release build that consumes its output, and a customer verification layer, with the repaired gates concentrated where archive policy met external rebuild behavior.

    Gantry milestones

  84. 1 task 4 agents 130k peak context 15m 54s

    Active Sprint Sidebar

    Active Work in View

    The sprint sidebar follows the running row instead of the end of the tree.

    Feature
    The sidebar now centers automatic follow on the active sprint or fallback work row while preserving ordinary tail-follow scrolling for other TUI panes.
    Build
    The run kept a user-visible TUI fix in one focused sprint, and the boundary stayed green because the cut isolated sidebar placement from shared tail-follow behavior.

    Gantry milestones

  85. 4 tasks 11 agents 220k peak context 8h 29m

    Feature Exclusion Release

    Stripping Internal Tooling from Shipped Builds

    Default-on build features keep developer builds whole while paid and demo distributions ship without the internal tooling.

    Feature
    Gantry now has default-on internal features, stripped paid and demo build paths, focused boundary tests, and release documentation that names what distributed binaries omit.
    Build
    The run put the feature taxonomy before the larger product-surface cut, and the only red boundary was the opening devtools split that later sprints depended on.

    Gantry milestones

  86. 2 milestones 9 tasks 23 agents 174k peak context 1h 14m

    CLI Alias Updates

    Compatibility Alias Surface

    Resume and print spellings were added around Gantry's existing command model, with TUI naming work split out afterward.

    Feature
    Gantry still accepts the resume and print aliases through the canonical command path, while the former live recent-runs menu has been superseded by later menu cleanup.
    Build
    The run cut CLI compatibility first, then replanned the all-runs inspection work into a TUI milestone after review found the resume picker had stayed deliberately narrower.

    Gantry milestones

  87. 1 task 4 agents 203k peak context 22m 15s

    TUI Casing Cleanup

    Sentence Case for Engine Status Text

    Make card detail and finish messages read as prose, without disturbing the tokens inside them

    Feature
    Engine card detail and finish messages now start in sentence case where they begin with prose, and current build modules still carry that authored-text convention.
    Build
    The job was small enough to carry as a single grep-driven sweep, with the sprint staying green and the only recorded trouble appearing later at integration.

    Gantry milestones

  88. 3 milestones 16 tasks 41 agents 140k peak context 4h 49m

    Flaky Test Cleanup

    Making a Flaky Test Suite Trustworthy Again

    Measure flakiness with evidence, fix the confirmed offenders by root cause, and guard against their return.

    Feature
    The tree still contains the flake stress runner, report generator, analysis snapshots, fixture isolation helpers, guardrail test, reliability guide, and overlay readiness fix that came out of this job.
    Build
    The run was cut as measure, repair, and prevent, with the main adjustment coming when post-fix evidence showed that the repair and prevention boundaries had to be handled together.

    Gantry milestones

  89. 5 tasks 14 agents 158k peak context 1h 9m

    Robust Merge Finalization

    Merge Finalization That Recovers Itself

    One finish path, a truthful success check, and resume that converges without hand cleanup.

    Feature
    Gantry now judges a finished merge by landed history and real residue, not by unrelated checkout dirt, while live, offline, and resumed finalization keep distinct operator behavior.
    Build
    The run established the merge postcondition first, then made each finish surface reuse it, with stress appearing where resume and offline behavior had to compose the new invariant.

    Gantry milestones

  90. 3 tasks 8 agents 144k peak context 28m 40s

    Halt Recovery Modal

    The Halt Modal Shows the Whole Diagnosis

    A stop screen that grows to its content, scrolls, and reads the report inline

    Feature
    The TUI now renders halted runs through a content-sized, scrollable stop modal that can show a diagnosis report body inline and expose that same visible text for copying.
    Build
    The cut kept one TUI surface manageable by landing modal geometry, then overflow handling, then report content, with sprint boundaries staying green and the only recorded stress appearing at final merge.

    Gantry milestones

  91. 3 tasks 9 agents 174k peak context 48m 54s

    Autonomous Conflict Handover

    Autonomy-First Merge-Back Conflict Handling

    Try to resolve the merge conflict without a human, and ask only when that fails.

    Feature
    The tree still carries one merge-back conflict path that tries autonomous repair before any interactive choice, with tests and UI state around the fallback.
    Build
    The cut established the visible fallback contract first, concentrated the only red gate in the engine rewrite, and finished by wiring the assistant path as a last resort.

    Gantry milestones

  92. 4 tasks 12 agents 160k peak context 1h 10m

    Aggressive Merge Resolution

    Prove the Merge Before It Lands

    Merge-back that integrates and tests the combined tree before the main branch ever moves.

    Feature
    Gantry's merge-back stopped ending at git's textual verdict; a single shared path now integrates the current main, runs the real gate on the combined tree, and advances the main branch only for a proven-green result — with a lock spanning the whole sequence.
    Build
    The plan separated a correctness guarantee from the repair behaviour that only matters once that guarantee can fail, then carried the guaranteed path across every merge surface — and the two hard pieces each went red at the gate before they landed.

    Gantry milestones

  93. 3 tasks 10 agents 139k peak context 38m 45s

    Enter Guide

    Entered Runs Explain Themselves

    The enter shell now gets a generated run guide without taking ownership of the worktree.

    Feature
    Gantry still renders a run guide, writes it as a git-excluded status file with safe instruction-name aliases, and refreshes it before an entered shell opens.
    Build
    The run split the guide into pure rendering, conservative file ownership, and final command wiring, with the gate pressure landing on the content boundary and the shell hook.

    Gantry milestones

  94. 4 tasks 13 agents 128k peak context 49m 56s

    Gantry Casing Cleanup

    Sentence Case Across the Live Monitor

    Making the terminal UI read consistently without disturbing a single machine string

    Feature
    The current tree still separates machine labels from display labels, centralizes harness display names, applies them through the live monitor, and asks generated dashboard copy to start as proper sentence-case prose.
    Build
    The run was cut by TUI surface, with shared card casing first, broader live labels next, diagnostic panes after that, and prompt wording last, while red gates concentrated on the render paths that had exact text assertions.

    Gantry milestones

  95. 2 tasks 8 agents 110k peak context 1h 22m

    Sprint Count Views

    Making Sprint Counts Comparable Across Runs

    Splitting a run's completion state from the sprint size a person actually scans for.

    Feature
    Current run records still carry separate completion units and display sprint progress, and the command and MCP surfaces continue to expose that distinction.
    Build
    The run put the new registry contract before the consumer rewrite, then found its real stress in the routing sprint after the foundation review changed the remaining work.

    Gantry milestones

  96. 7 tasks 20 agents 157k peak context 1h 15m

    Inline Usage Capture

    Usage Sidecars Written Beside Every Stage

    Capture per-turn context usage as each stage finishes, so a run carries its own numbers

    Feature
    Current Gantry still writes normalized usage sidecars from the harness layer and reads them first during context analysis, while keeping degraded and historical fallback paths explicit.
    Build
    The job put the shared sidecar contract first, then let each harness and the analyzer consume that shape independently, with stress appearing at the contract, Opencode, and scanner boundaries.

    Gantry milestones

  97. 5 milestones 30 tasks 74 agents 240k peak context 12h 39m

    Goals and Loops

    Runs That Build Until a Goal Passes

    Point Gantry at a check and let it plan, build, and re-plan until that check turns green.

    Feature
    Gantry gained frozen goal checks, amber results, campaign loops, Ralph-style iterations, and review-gated completion, with the core code still present even where the website framing later changed.
    Build
    The run put shared verification and campaign seams ahead of the new drivers, then let the later goal and loop milestones expose exactly where live progress, resume, and public copy needed correction.

    Gantry milestones

  98. 3 milestones 10 tasks 24 agents 127k peak context 7h 1m

    Test Suite Speed

    A Fast Default Gate and an Opt-In Display Tier

    Split the test suite so the everyday gate stops launching the real display stack

    Feature
    The current tree keeps the ordinary gate separate from display-stack coverage, runs consolidated integration modules through the root test entry point, and offers optional readable output without requiring that tool for verification.
    Build
    The job split a suite-speed problem into tiering, wait reduction, and consolidation, with a re-plan after the first milestone carrying an end-to-end discovery constraint into the later runner work.

    Gantry milestones

  99. 2 tasks 6 agents 124k peak context 33m 35s

    Worktree Locator

    Finding the Real Checkout Behind a Worktree

    Making run identity resolve to the primary checkout no matter where Gantry is invoked

    Feature
    Run identity now resolves through git's shared common directory, while checkout-local work has an explicit resolver that does not climb out of the invoking worktree.
    Build
    The run put the shared root resolver ahead of the entrypoint audit, so the caller sweep inherited a proved meaning for the primary checkout and stayed green.

    Gantry milestones

  100. 4 tasks 59m 37s

    Opt-In Input Recovery

    Opt-In Assistant Input

    Recovery and chat remain visible without taking keyboard input until the operator asks for it.

    Feature
    Gantry now keeps recovery blockers and assistant chat discoverable while requiring an explicit action before text input reaches either surface.
    Build
    The cut put the prompt marker before the two interface changes, then used the final sprint to verify that the integrated input contract had not left older assumptions behind.

    Gantry milestones

  101. 4 tasks 1h 28m

    Gate To Test Rename

    From Gate to Test in Gantry's Prose

    A documentation pass that says test where the words are for people and keeps gate where they name a thing.

    Feature
    The tree still separates many human instructions into tests and checks while retaining `bin/gate` and gate-shaped config keys as literal protocol names.
    Build
    The run treated the rename as a prose-boundary problem, letting each fresh worker handle one reader surface while a shared preserve-list kept machine names stable.

    Gantry milestones

  102. 3 tasks 58m 26s

    Default Build Triage Cleanup

    One Default Build Path, No Startup Triage

    Plain plan builds now go straight to the milestone driver, with the startup classifier and its build-family flags removed.

    Feature
    The current tree still routes plain builds through the milestone driver, keeps legacy flat runs resumable, and has no triage prompt or stage left in the build engine.
    Build
    The job was cut as one removal milestone whose sprints first changed dispatch, then deleted the now-unused triage surface, then corrected the public contract where the only red gate appeared.

    Gantry milestones

  103. 3 milestones 10 tasks 32 agents 219k peak context 3h 2m

    Demo Gating System

    Gantry's Gated Demo Edition

    A try-before-you-buy build that checks in, refuses offline when exhausted, and unlocks to unlimited.

    Feature
    The tree now has a demo-only licensing surface behind a cargo feature, with server check-in, completion reporting, local unlock state, command dispatch, and release packaging still visible at HEAD.
    Build
    The cut kept the paid build boundary in front, isolated policy from lifecycle integration, and left the run's hardest stress in the gate core and the later wiring that made that policy visible.

    Gantry milestones

  104. 2 milestones 7 tasks 17 agents 184k peak context 1h 46m

    Brain To Assistant Rename

    Renaming the Brain to the Assistant

    A behaviour-preserving rename of Gantry's conversational LLM driver, from brain to assistant, across code and docs.

    Feature
    The current tree still uses assistant as the live vocabulary for the conversational driver across source, selection, diagnostics, menus, and docs, while the product remains the Gantry Agent.
    Build
    The run put the source rename before every surface that depended on it, then adjusted the downstream split after review showed the foundation had already absorbed part of the diagnostics work.

    Gantry milestones

  105. 5 tasks 53m 51s

    Global Harness Defaults

    Retiring Gantry's Hard-Coded Harness Default

    A hand-editable global file, a first-run picker, and a config command replace the assumed Claude backend.

    Feature
    The tree now treats build harness choice as a user-owned setting, resolved through documented tiers instead of a hidden compiled default.
    Build
    The run built the global default from storage through startup resolution, precedence, command dispatch, and docs, with the only recorded re-plan attached to the fallback resolver.

    Gantry milestones

  106. 3 tasks 58m 23s

    Local Release Producer

    Gantry Builds Its Own Releases

    Replacing the GitHub Actions release pipeline with one local, self-verifying command.

    Feature
    The current tree still releases through the local producer, keeps the GitHub release workflow deleted, and tests the website download model instead of the retired release path.
    Build
    The run kept the dependency order explicit: establish the producer, make the docs true against it, then retire the old pipeline with the tests that had been pinning it.

    Gantry milestones

  107. 3 tasks 47m 22s

    Deferred Harness Model Selection

    Harnesses Choose When Unpinned

    Gantry stops forcing a main model unless the operator pins one.

    Feature
    Gantry now records absent main models as deferral, omits model flags for unpinned heavy work, and documents small-model defaults separately.
    Build
    The run held a cross-harness behavior change by landing the data shape first, proving invocation semantics next, and only then rewriting the public contract.

    Gantry milestones

  108. 3 tasks 27m 57s

    Smooth Card Motion

    Activity Cards In Motion

    The terminal monitor learned to animate new feed cards without changing the feed model.

    Feature
    Current TUI code still carries a startup motion mode, materialized card colors, live-only append state, and half-row tail slide rendering backed by focused coverage.
    Build
    The run kept terminal motion as layered rendering work, first proving the clock, then color materialization, then tail-follow position changes with clean gates at every boundary.

    Gantry milestones

  109. 2 milestones 10 tasks 24 agents 117k peak context 1h 26m

    Source Review Distribution

    A Verifiable Source-Review Archive for Every Release

    Deterministic source snapshots, license compliance, and signed checksums wired into the release.

    Feature
    Gantry still carries the source-review archive machinery, license guardrail, generated notices, signing material, and verification docs, while the original hosted release workflow has been superseded.
    Build
    The decomposition proved the compliance and archive contract locally before wiring publication around it, with replans confined to the source-archive digest contract rather than to failing gates.

    Gantry milestones

  110. 2 tasks 50m 36s

    Sprint Loop Re-enumeration

    Live Replans Stay In The Run

    A sprint-level replan became work the current loop executes and displays.

    Feature
    Current Gantry still treats a changed task catalog as live input and carries the changed roster through durable and interactive projections.
    Build
    The run split mid-run replanning into a contained executor change followed by a contained observer change, and both boundaries stayed green.

    Gantry sprints

  111. 6 tasks 1h 45m

    Shared Checkout Safety

    Safe Finalize in a Shared Checkout

    Undo only your own changes, lock master while you mutate it, and re-gate the merge so a concurrent run never loses committed work.

    Feature
    The tree now carries a shared-checkout finalize path that ignores sibling run state, commits only owned archive paths, aborts only its own unfinished merge, serializes branch mutation, and checks the merged branch before success.
    Build
    The cut separated checkout-safety work into independently provable hazards first, then the rollback core, then lock wiring and post-merge verification where the run record shows the coupling tightened.

    Gantry milestones

  112. 5 tasks 1h 25m

    Harness Model Display

    Which Harness Ran This Card

    Make every build-stage card name the harness and model behind it

    Feature
    A structured agent tag still moves through the event, attach, journal, and card-state paths, while later TUI work has changed how much of that tag the footer displays.
    Build
    The run split one display feature into a source-to-screen chain, so each fresh agent could prove one boundary before the next layer depended on it.

    Gantry milestones

  113. 2 tasks 33m 29s

    Unified Sandbox Layer

    Sandbox Boundaries

    A run that made every harness enter the same wrapper and pointed agents at the disposable worktree.

    Feature
    The current tree still carries a uniform wrapper path for harness spawns and a worker prompt that frames the disposable worktree as the only place to edit.
    Build
    The run split the incident into a confinement invariant and a worktree-targeting guardrail, and both pieces stayed within their sprint boundaries without repair.

    Gantry milestones

  114. 2 milestones 9 tasks 20 agents 133k peak context 1h 40m

    Distribution and Preflight

    The Fresh-Box Readiness Check and Release Path

    gantry doctor for a clean machine, plus a path to shipping Gantry as a versioned binary

    Feature
    Gantry still has the readiness inventory and doctor path this job introduced, plus the vendored menu crate and version-check seam, while the original release workflow has been replaced.
    Build
    The run kept shared foundations ahead of their consumers, first for machine readiness and then for distribution, and the child sprints completed without retry, red gate, or re-plan.

    Gantry milestones

  115. 5 tasks 1h 20m

    Text Selection

    Drag to Select and Copy in the Monitor

    Grab text out of any pane or error popup with the mouse, and copy it on release

    Feature
    The monitor now owns selectable text blocks, routes drag gestures through them, copies selected text on release, and paints the selected cells after the frame renders.
    Build
    The cut turned a mouse feature the gate could not drive directly into independently provable state, registration, routing, and paint steps.

    Gantry milestones

  116. 1 task 15m 22s

    Hide Milestone Language

    Feed Cards That Match the Run's Real Shape

    A run classified for milestones but built as one flat sprint no longer announces a structure it never builds.

    Feature
    The current tree still keeps pre-decision build cards neutral and reserves explicit milestone wording for committed multi-milestone routes.
    Build
    The run was a single constrained wording sprint, so the cut put all risk in preserving routing behavior while changing only feed text.

    Gantry sprints

  117. 1 task 13m 42s

    Adaptive Split Defaults

    A Sensible Default for the Untouched Split

    Give the never-dragged sidebar/feed divider an adaptive layout, and leave a dragged one alone

    Feature
    The monitor now gives an untouched split an adaptive centered layout, then preserves a dragged split as the user's proportional choice.
    Build
    The build kept the state latch, renderer branch, drag handoff, and tests in one sprint because the no-jump invariant crossed all of them.

    Gantry sprints

  118. 3 milestones 12 tasks 29 agents 251k peak context 4h 26m

    Plans Stats Panel

    A deep-dive panel for a run's stats and git history

    Turning the monitor's one-line stats glance into a full panel, a commit-activity view, and a pager every drill-down reads through.

    Feature
    The monitor still exposes a richer stats model, a full stats overlay, commit activity inspection, and a pager that can search, follow, wrap, zoom records, and color patches.
    Build
    The decomposition put the common reading surface ahead of the panels that would depend on it, then let the stats and git views build as bounded consumers of that surface.

    Gantry milestones

  119. 4 tasks 1h 36m

    Merge Reconciliation

    Teaching the Merge Resolver to Prove It Dropped Nothing

    The finish step now checks a resolution actually carried main's changes, and repairs the ones it didn't.

    Feature
    Gantry now checks what main contributed against the resolved tree, restores missing hunks when the branch never touched that region, and sends only ambiguous overlap to a repair agent.
    Build
    The run kept the merge repair problem bounded by layering audit output, git-only primitives, orchestration decisions, and the ambiguous repair agent, with no sprint needing retry or re-plan.

    Gantry milestones

  120. 2 tasks 21m 34s

    Restore TUI Layout

    Restoring a Silently Reverted TUI Layout

    Re-applying dropped layout commits by hand, then pinning them with a test the gate never had.

    Feature
    The tree still carries the stacked sidebar-card structure and tests that inspect the drawn layout, while later layout work replaced the restored equal split with adaptive sizing and a draggable divider.
    Build
    The cut separated hand reconciliation from test coverage: first a narrow agent reapplied known TUI diffs onto changed context, then another converted the missing visual contract into render assertions.

    Gantry sprints

  121. 4 milestones 18 tasks 42 agents 243k peak context 6h 12m

    Plans Menu Makeover

    A Menu System for Gantry's Run Monitor

    Rebuilding the terminal front-end around an action registry, a shared file viewer, clipboard copy, and live run statistics.

    Feature
    The monitor still uses the registry, pager, clipboard path, statistics fold, ticker, and inspection menus from this job, while later work renamed and compressed several of the original bar titles.
    Build
    The run split the monitor redesign into dependency-ordered menu infrastructure, shared viewers, live run state, and cross-cutting display work, with re-planning isolated to the shared pager and metadata milestone.

    Gantry milestones

  122. 3 tasks 57m 28s

    Usage Limit Countdown Card

    A Live Countdown for a Parked Run

    Turning a usage-limit wait from a stale corner note into a card that counts down to the resume time.

    Feature
    A usage-limit wait now appears as its own waiting card, fed by a durable wake instant and rendered with a local retry time plus a live remaining-time display.
    Build
    The job split a parked usage-limit wait into data, lifecycle, and rendering layers, and the run stayed green while clean review replans carried context between the first two boundaries.

    Gantry sprints

  123. 3 tasks 37m 45s

    Parallel Map Resume

    A Fast Parallel Resume Scan for Map Runs

    Classify every already-done unit at once, up front, instead of two slow sequential sweeps.

    Feature
    Map resume now derives done units through a host-width parallel scan, feeds only unfinished units to the pool, and renders direct Skipped events without in-flight flicker.
    Build
    The run isolated the pure classifier before the driver rewrite and left rendering verification for last, so each fresh agent received one boundary with an existing oracle or a narrow event-shape claim.

    Gantry milestones

  124. 2 tasks 29m 31s

    Codex Usage Limit Backoff

    Teaching Codex to Wait Out a Usage Limit

    Codex usage-limit hits become a timed pause and auto-resume, not a dead run

    Feature
    Gantry now carries Codex's captured event stream into classification and turns a recognized usage-limit event into a bounded reset wait instead of a terminal empty-answer failure.
    Build
    The run kept the risky behavior behind a proven plumbing change: one sprint widened the parse input as a no-op, and the next used that channel for Codex reset waits without needing repair or re-planning.

    Gantry sprints

  125. 4 milestones 18 tasks 42 agents 233k peak context 5h 38m

    Core Consolidation

    Shared Core Refactor

    A broad deduplication pass across the driver, front-end, attach, harness, worktree, CLI, and TUI layers.

    Feature
    The current tree still carries the shared model layer the run introduced, even though later reorganizations moved much of the driver work out of its original module paths.
    Build
    The work was cut as a stack of small refactors, with the only stress appearing where a completed slice changed the next plan rather than where the gate found broken behavior.

    Gantry milestones

  126. 3 tasks 40m 35s

    Resume Worktree Reset

    Recovering a Worktree Left Dirty by an Interrupted Chunk

    When gantry dies mid-chunk, resume discards the unverified work and rebuilds from the last committed green state.

    Feature
    Resume can now clean an interrupted commit-per-chunk worktree before the baseline gate, preserve run bookkeeping, and replay the recovery as durable history.
    Build
    The cut separated the git operation, the resume decision, and the audit records, with a review re-plan after the wiring clarified that observability had to handle the journal state around the reset.

    Gantry sprints

  127. 2 milestones 11 tasks 24 agents 148k peak context 5h 23m

    Refactor Build.rs

    Refactoring the Build Engine Into Concern-Focused Modules

    Turning one oversized file into a directory of per-concern modules, with the test suite as proof nothing moved but the code.

    Feature
    The build engine now has stable addresses for its major concerns, with a thin module root that preserves external paths while later work continues to add files beside the original split.
    Build
    The cut treated the monolith as a dependency problem: move the low-friction leaves and drivers first, then move the sibling support clusters once the compiler could name each required visibility boundary.

    Gantry milestones

  128. 4 tasks 1h 40m

    Partial Merge Checkpoints

    Checkpoint a Gantry Run Without Ending It

    Bank a long run's finished work to master, then resume the rest.

    Feature
    Gantry can now land completed run work before final completion, through the same conflict-aware merge machinery used at the ordinary finish, while preserving the state resume needs.
    Build
    The decomposition kept the command contract, owner-engine behavior, command surface, and documentation separate, with the engine finalize step exposing the only boundary that had to be replanned.

    Gantry sprints

  129. 1 task 6m 28s

    Stream JSON Verbose

    The Verbose Flag That Kept Runs Alive

    A one-flag compatibility fix that stops a CLI change from halting whole Gantry runs.

    Feature
    The Claude harness still emits `--verbose` with its stream-json command, before user-supplied extra arguments, and the module still tests that requirement.
    Build
    The run was cut as a flat compatibility patch because the argument change, its placement rule, and its regression test all belonged inside the Claude harness boundary.

    Gantry sprints

  130. 4 tasks 36m 12s

    Usage-Limit Reset Backoff

    Backoff That Waits for the Reset Time

    When a usage window runs out, sleep until it reopens instead of halting the run.

    Feature
    Gantry now recognizes usage and session limits as retryable, carries optional reset waits through the retry loop, and presents long waits as intentional usage-limit pauses instead of generic retry countdowns.
    Build
    The cut isolated reset-aware backoff into classification, retry accounting, harness parsing, and presentation, and the only red gate in the run belonged to baseline setup before any sprint owned code.

    Gantry sprints

  131. 5 tasks 1h 6m

    Harness-Aware MCP Delivery

    Delivering Gantry's Tools to Any Harness's Assistant

    The conversational assistant reached its run tools only under Claude; this job taught every harness to register them natively.

    Feature
    The assistant now receives gantry's run tools through the selected harness's native MCP mechanism, with the neutral server description still present in the harness module and the host.
    Build
    The run separated neutral registration, generic delivery, per-harness renderers, and the final driver switch so each fresh agent could prove one boundary before the assistant wiring depended on it.

    Gantry milestones

  132. 1 task 36m 20s

    Chat Console Integration

    The Chat Pane Learns to Reply

    Joining a fully built but isolated chat backend to the running engine, so a typed message finally gets an answer.

    Feature
    A typed chat message now reaches an assistant running beside the build, while prompt answers still resolve through the original path and idle runs keep their old event shape.
    Build
    The job was cut as a single integration sprint because the backend parts already existed, leaving the fresh agent to own the channel split, event fan-out, and live-engine handoff as one bounded wiring problem.

    Gantry sprints

  133. 2 milestones 8 tasks 18 agents 203k peak context 2h 8m

    Live Run Architecture

    One Owner Per Run, Attach From Anywhere

    A process-grounded lock makes one engine own a run, and a live transport lets other front-ends attach to watch and steer it.

    Feature
    Current Gantry still has the run lock, live-owner routing, attach protocol, publisher, client, lifecycle tests, and MCP bridge that this job introduced.
    Build
    The run was cut into ownership first and attachment second, with each milestone proving its primitive before callers and consumers depended on it.

    Gantry milestones

  134. 3 tasks 54m 43s

    Resumable Job Types

    Resume Any Job Type Where It Stopped

    Teaching a flagless resume to route every driver, not just the layouts it already recognised.

    Feature
    Gantry now carries a run's driver identity in durable state and uses driver-declared resume footprints, with the original implementation relocated into the current build driver modules.
    Build
    The work was cut as a dependency chain: record the driver identity, ask the selected driver whether its state exists, then lock the resumed behavior for every driver.

    Gantry milestones

  135. 3 milestones 12 tasks 30 agents 254k peak context 3h 30m

    Gantry Agent Chat

    A Conversational Console for a Running Build

    An in-run chat pane and agent backend that turn gantry's dead-stop moments into conversations.

    Feature
    The current tree still carries a chat-capable assistant surface with durable turns, run-scoped tools, terminal rendering, and recorded-stop investigation actions, though several original backend files have since been reorganized.
    Build
    The run separated the assistant into backend, pane, and recovery layers, with stress concentrated where the assistant crossed into the live engine and merge handling.

    Gantry milestones

  136. 3 tasks 51m 15s

    Per-Repo Gate Lock

    Serializing Concurrent Gates Behind a Per-Repo Lock

    One gate at a time per repository, so overlapping runs stop failing each other

    Feature
    Gate execution now passes through a locked repository-scoped chokepoint, surfaces contention to users, and archives merge-resolve gate output when that path fails.
    Build
    The work was cut at the interface where it mattered: prove a standalone lock first, re-plan the integration contract after review, then handle merge-resolve log capture as a separate defect.

    Gantry sprints

  137. 2 milestones 7 tasks 16 agents 160k peak context 1h 44m

    Gantry MCP Server

    An MCP Server for Watching and Steering a Gantry Run

    Expose one build's status, artifacts, and controls to an agent — confined to that run

    Feature
    Gantry still carries a run-scoped MCP surface for status, artifacts, worktree state, sandboxed commands, and live prompt answers.
    Build
    The run separated read access from action tools, put run scoping underneath both, and stayed green by letting each sprint inherit one proven contract before adding the next.

    Gantry milestones

  138. 2 tasks 28m 41s

    Worktree Conflict Resolution

    Resolving Merge Conflicts Off the Main Checkout

    Move conflict resolution into the throwaway worktree so a failed merge never dirties your real tree.

    Feature
    Gantry now routes merge-back conflict work through the disposable worktree, grounds the result with the gate, and touches the home branch only after the integrated branch is clean.
    Build
    The cut isolated git primitives from finish-path control flow, so the worktree operations could be proven against throwaway repositories before the run-finish resolver depended on them.

    Gantry milestones

  139. 4 tasks 41m 57s

    Timeout Guard and Salvage

    Salvage the Work a Timeout Would Have Thrown Away

    Kill a coding agent for stalling, not for being slow — and keep the work it already finished

    Feature
    Gantry now treats agent silence, absolute runaway bounds, and test-passing timed-out execute work as separate runtime states instead of one terminal timeout.
    Build
    The run cut the timeout change into a progress detector, an execute-only salvage route, downstream accounting, and docs, with every sprint landing cleanly without repair or re-plan.

    Gantry milestones

  140. 3 tasks 1h 1m

    Plan Review Completeness

    Judging Whether the Work Was Actually Finished

    Review learns to ask if a sprint covered its brief, and a cut-off agent stream stops meaning failure.

    Feature
    Gantry now asks review whether the brief was covered, can reset an incomplete attempt without erasing its audit trail, and treats a truncated execute as a question for the worktree, gate, and review to answer.
    Build
    The run stayed green because the cut put the judgement first, the recovery mechanism second, and the truncation rule last, so each sprint inherited only the contract it needed.

    Gantry milestones

  141. 2 milestones 11 tasks 31 agents 216k peak context 3h 50m

    Map Job Type

    Map: Fanning Gantry's Pipeline Over a List

    A job type that runs one fresh worker per enumerated item — one at a time, or several at once.

    Feature
    Gantry now has a Map driver that turns a spec and enumerator output into checked per-item work, with skip-heal resume, bounded concurrency, sampled QA, and fan-out reporting still present in the current tree.
    Build
    The decomposition put the generic, single-worker Map path under test before adding shared-state concurrency, so the later pool and checkpoint work could be measured against an already-working per-unit contract.

    Gantry milestones

  142. 3 tasks 39m 37s

    Transient Retries

    Riding Out a Transient API Outage

    Gantry tells a momentary upstream blip from a real failure and waits it out instead of halting the run.

    Feature
    Gantry now has a transient outcome class, a configurable retry loop in the agent runner, and event-stream visibility in both front-ends.
    Build
    The run split a cross-harness reliability change at the runner boundary: classify first, retry second, and only then publish the waiting state to operators.

    Gantry milestones