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.

51 replays 570 sessions 9.1M output tokens 177k avg peak

Gantry jobs building Gantry

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

    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

  2. 4 sprints 11 agents 220k peak context 8h 29m

    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

  3. 1 sprint 4 agents 203k peak context 22m 15s

    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

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

    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

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

    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

  6. 3 sprints 8 agents 144k peak context 28m 40s

    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

  7. 3 sprints 9 agents 174k peak context 48m 54s

    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

  8. 4 sprints 12 agents 160k peak context 1h 10m

    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

  9. 4 sprints 13 agents 128k peak context 49m 56s

    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

  10. 2 sprints 8 agents 110k peak context 1h 22m

    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

  11. 7 sprints 20 agents 157k peak context 1h 15m

    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

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

    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

  13. 3 milestones 10 sprints 24 agents 127k peak context 7h 1m

    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

  14. 2 sprints 6 agents 124k peak context 33m 35s

    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

  15. 4 sprints 1h 28m

    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

  16. 3 sprints 58m 26s

    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

  17. 3 milestones 10 sprints 32 agents 219k peak context 3h 2m

    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

  18. 2 milestones 7 sprints 17 agents 184k peak context 1h 46m

    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

  19. 5 sprints 53m 51s

    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

  20. 3 sprints 58m 23s

    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

  21. 2 milestones 10 sprints 24 agents 117k peak context 1h 26m

    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

  22. 6 sprints 1h 45m

    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

  23. 5 sprints 1h 25m

    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

  24. 2 milestones 9 sprints 20 agents 133k peak context 1h 40m

    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

  25. 5 sprints 1h 20m

    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

  26. 1 sprint 15m 22s

    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

  27. 1 sprint 13m 42s

    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

  28. 3 milestones 12 sprints 29 agents 251k peak context 4h 26m

    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

  29. 4 sprints 1h 36m

    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

  30. 2 sprints 21m 34s

    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

  31. 4 milestones 18 sprints 42 agents 243k peak context 6h 12m

    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

  32. 3 sprints 57m 28s

    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

  33. 3 sprints 37m 45s

    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

  34. 2 sprints 29m 31s

    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

  35. 3 sprints 40m 35s

    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

  36. 2 milestones 11 sprints 24 agents 148k peak context 5h 23m

    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

  37. 4 sprints 1h 40m

    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

  38. 1 sprint 6m 28s

    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

  39. 4 sprints 36m 12s

    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

  40. 5 sprints 1h 6m

    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

  41. 1 sprint 36m 20s

    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

  42. 2 milestones 8 sprints 18 agents 203k peak context 2h 8m

    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

  43. 3 sprints 54m 43s

    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

  44. 3 milestones 12 sprints 30 agents 254k peak context 3h 30m

    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 first-line recovery records, 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

  45. 3 sprints 51m 15s

    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

  46. 2 milestones 7 sprints 16 agents 160k peak context 1h 44m

    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

  47. 2 sprints 28m 41s

    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

  48. 4 sprints 41m 57s

    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

  49. 3 sprints 1h 1m

    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

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

    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

  51. 3 sprints 39m 37s

    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