skip to content

Releases

0.1.0

Hello, World!

The first ever release covered work from the project start June 9, 2026 through the first six weeks of development. This version of Gantry was essentially complete and ran successfully hundreds of times, but it lacked flexibility and polish.

1,571 commits by Gantry runs

82% of the release

351 commits by non-Gantry sessions

18% of the release

1922 commits 122 entries 12 sections

Gantry 0.1.0 is the first release, covering the whole history of the project from git init on 2026-06-09 to the release on 2026-07-21 — the v0.1.0 tag, cut four days later, added only release plumbing. It is 1,922 commits in 122 units of work: 101 gantry runs contributing 1,571 commits, and 21 hand or interactive-agent sessions contributing the other 351. The product was called loom for most of this period; it was renamed to Gantry on 2026-07-18, three days before the release. From its first day, Gantry was building itself: four fifths of the commits described here were written by its own runs.

The first version shipped in one day on 2026-06-09: a Rust binary with a live TUI monitor and a real orchestration engine driving a coding agent through a plan, implement, gate pipeline — and the first autonomous run landed on the repo the same day. The rest of June grew the engine around that loop: milestone runs that split large plans into phases with their own gates, a design mode, headless and --detach operation for planning agents, transient-failure retries, resumability for every job type, and a per-repository gate lock. July hardened it after real incidents — a work-loss audit produced a bounded replan-capable retry ladder and resume that stops discarding completed work — and two of the largest runs of the release moved harnesses and drivers behind registries (78 commits) and derived the parser, the settings form, and the docs from one declarative config schema (54 commits); that run died at its own merge stage and was finished by hand, the incident that motivated resume-in-place.

The drivers arrived in sequence: the map job type on 2026-06-19, and the goal and loop drivers in a 55-commit run on 2026-07-10, later given unlimited cycles and the --ralph alias. --map learned to take a prose plan and generate its own spec. Harness support was pluggable from 2026-06-16 — claude, codex, opencode, and gemini — and grew reset-aware usage-limit backoff, deferred model selection, and a global config tier with defined precedence. The merge machinery was rebuilt across eight runs: partial resumable merges, conflict reconciliation that preserves both sides, merges gated in the worktree before landing, autonomous conflict resolution, and a unified recoverable finalize.

The Gantry Assistant was built in one 2026-06-22 burst of six runs — a bidirectional engine/UI channel, an MCP server for querying and controlling runs, the chat pane, ownership locks with a live attach transport — then renamed from "brain", made strictly opt-in, and polished in a 55-commit run. The TUI gained a menu bar, pager, and clipboard, a shared modal system, artifact tags, and unified casing and hover states. Behind all of it, and across 100 commits of its own, Gantry's test suite was split into tiers, measured for flakes and root-caused, and rebuilt around injectable seams — none of it in the binary, but it is what the gate's verdicts, and so every run's ground truth, rest on.

Every run records a lossless event tape from 2026-07-03, and captures per-turn token usage into normalized sidecar files, so a finished run can be read back and costed afterwards. The demo edition arrived in July: the licensing gate and unlock flow in the binary, and demo identity by verified email rather than a personalized build.

Distribution went from GitHub Releases to locally built, signed artifacts. A release now ships a source-review archive, an SBOM, and third-party notices alongside the binary, is checked by a license-compliance gate, and rebuilds byte-for-byte from the published source with a verifier the customer runs themselves — proven at release time before anything is signed. gantry doctor and a startup dependency check tell a fresh installation what it is missing. Development-only surfaces were put behind cargo features and stripped from distributed builds.

The release closes with the rename: two runs moved the product, the source tree, and the orchestration paths from Loom to Gantry on 2026-07-18. The last substantial work landed on 2026-07-21; the v0.1.0 tag was cut on 2026-07-25, with only release plumbing in between.

The first days: an orchestrator from nothing

Two weeks in June: the first engine, the first TUI, and the gate that grounds every agent.

  1. 24 commits, 7fbac2ed7 81c50733d session

    Day one: orchestrator engine, TUI monitor, sandboxing, and auth

    A Claude Code session built the whole first version of the product in a single day: a Rust binary with a live TUI monitor, then a real orchestration engine driving the coding agent through a plan→implement→gate pipeline, verified end to end. The same session kept iterating on that core: it split gate construction into its own agent stage, made re-plan and conflict-resolve first-class stages, added graceful abort, headless auth loading, an opt-in (then default) sandbox for agents, process reaping via the kill(2) syscall, retry annotation in the ledger, and a money-free end-to-end smoke test against a stub agent. Nearly every subsystem the product still has traces back to this cluster.

  2. 9 commits, 3fbefa01b 5620ee25d run plan-card-detail

    First autonomous run: the card-detail modal with live transcript tail

    The first real gantry run on gantry's own repo. Working from the day-one plan, it built the TUI's card-detail view in five sprints: streaming the agent transcript to a log file, carrying the log path through the pipeline, card selection and modal state, the modal renderer and transcript formatter, and a live tail of the running stage. All five sprints finished green, with a re-plan after the first sprint along the way.

  3. 7 commits, 603a6a589 dcdca79e2 run plan-card-metrics

    A run adds per-stage token and cost metrics to the TUI

    A gantry run executed the day-one metrics plan in four green sprints: the pipeline now captures per-stage metrics, cards and the status line show stage figures and run totals, active stages display live token counts, and the session modal gained a metrics strip in its footer.

  4. 6 commits, c146f7012 3e65426ca run plan-worktree-confinement

    A run closes the absolute-path sandbox escape

    Agents in the sandbox could still write to the main checkout through absolute paths. A gantry run built the fix from its own plan in three green sprints: the bubblewrap sandbox now binds the main checkout read-only, the orchestrator detects any absolute-path escape that slips through, and an integration test verifies the write confinement.

  5. 5 commits, 1956e56ef 35e48b053 session

    Run-complete card, Haiku commit messages, and engine hardening

    A Claude Code session fixed a batch of early rough edges: a run-complete summary card and commit messages written by a Haiku call, git's local environment variables cleared before hook-run tests, chunk diffs no longer sliced mid-codepoint, the terminal restored on panic so error output stays readable, and the baseline gate re-verified on restart after a red baseline.

  6. 13 commits, a5793c599 12887e8d7 session

    TUI visual overhaul, content-hash run identity, and gate on resume

    A two-day Claude Code session in two threads. On the TUI it did the flat, near-monochrome visual overhaul via a theme module — feed margins, card padding, a generated project-name sidebar header, and scroll-to-selection. On the engine it added --clean/--remove for tearing down a botched run, derived run identity from plan content instead of filename so same-named plans don't collide, gave a red-after-review gate one bounded fix attempt before stopping, gated the baseline on every resume, and ran the worktree-escape check after the fix and review stages too.

  7. 6 commits, c6c7fa69c 928142b89 session

    Activity journal with replay; card layout fixes

    A Claude Code session made the engine persist an activity journal and replay it — both when resuming a run and when reopening a finished job, the origin of today's replay surface. On the TUI side it fixed early layout gaps: a placeholder card before the first stage, flexible per-stage card heights, the scan card kept in the feed, and chunk numbers in card footers.

The build pipeline

Sprints, milestones, gates, review, recovery, and the prompts and config that steer them.

  1. 9 commits, 7632a5782 7d8aa64c5 run docs-haiku-maxx-ux-plan

    Status cards get model-written titles and blurbs

    A gantry run built the readable status dashboard: every sprint card in the monitor gets a short title and blurb written by a cheap-model one-shot, with dedicated decoration prompts and a sidecar file that persists the generated text per unit. The decoration step was wired into the build loop so cards are titled as the run progresses, and gate, review, and replan cards got stage summaries of their own.

  2. 13 commits, 7f7e25dc3 a90c46bf5 session

    Scoped gates, red-baseline halt, and --harness selection flags

    A Claude Code session hardened the engine around the gate and harness selection: the gate-builder agent now receives the plan, the gate is scoped to it, and a red baseline halts the run at gate-build instead of letting a broken start proceed. Harness selection moved to explicit --harness / --harness-<role> CLI flags, dropping the old environment variable tier. The session also unified the four cheap-model one-shots behind one helper, fixed headline drift between the TUI and headless logs, cleaned up per-frame card formatting in the TUI, and updated the Codex harness default model.

  3. 12 commits, 5688cc0c0 7d21c42b6 run docs-in-process-milestones-plan

    Milestone runs: large plans split into phases with their own gates

    A gantry run built the in-process milestone driver, the engine's move from flat sprint lists to a two-level structure: a large plan is split into milestone phases, each planned, executed, and reviewed in sequence with an advisory review between phases. The work restructured the per-unit context for milestone attribution and a shared journal, introduced the Job dispatch seam and extracted the sprint pipeline, ported milestone planning and review prompts, added disk-based resume detection, and gave both the headless output and the TUI sidebar a two-level milestone/sprint hierarchy.

  4. 28 commits, 591e3f7b5 c2f4f101f run docs-design-mode-convergence-plan

    Design mode lands: --design and --redesign drivers

    A two-day, four-milestone gantry run built design mode end to end: two bundled design prompt sets, a design seam in the engine with its own namespacing, fields, and preambles, the additive design driver behind --design for incremental visual work, and the clean-slate --redesign driver. The run's own record shows several replans along the way — one on gate constraints in the first milestone and two more inside the additive driver — before all four milestones passed.

  5. 15 commits, 2c85ecf30 f53592ee5 run plans-headless-for-agents-plan

    Headless mode made watchable, with docs for planning agents

    A gantry run made headless mode something an agent can drive and watch: a readable run stream with durable per-event timestamps, plus documentation for using gantry as a planning agent's execution backend — Claude Code hook examples, per-harness headless guides (including Gemini auth guidance), and a validation gate over the examples. One mid-run clippy fix was committed by hand.

  6. 7 commits, 36af7b8ad 50ccef304 run plans-transient-retry-plan replay

    Transient agent failures are classified and retried with backoff

    A gantry run added the transient-failure layer planned after 529 overload errors killed runs: a classification step that tells transient errors from real failures, and a bounded retry loop with escalating backoff around agent execution, so a flaky API response no longer ends a multi-hour run.

  7. 9 commits, 8e8bdcacf c6cdb91a4 session

    --detach and `gantry logs` for handing a run to an agent

    A Claude Code session across four days: added --detach and a logs verb (then `loom logs`) so a planning agent can start a run and cleanly hand it off, stopped the confinement backstop from flagging the user's own concurrent edits, steered the gate-build prompt away from absent tools and dormant guarded branches, and fixed resume so staged-uncommitted files no longer leak into a re-run. TUI side work made the sidebar tree independently scrollable with the mouse wheel.

  8. 7 commits, 69f81f32f 1162a5124 run plans-review-completeness-and-truncation replay

    Reviews track incomplete scope; truncated streams stop passing

    A gantry run made the review stage honest about what it did not see: reviews now track whether the full sprint scope was covered, an incomplete review triggers a scoped re-run instead of a silent pass, and a truncated agent stream yields a new Indeterminate outcome rather than an implicit pass.

  9. 8 commits, 03722be31 bf8f2a455 run plans-wall-clock-timeout-salvage-and-no replay

    No-progress guard replaces the fixed timeout; timed-out work salvaged

    A gantry run replaced the fixed wall-clock timeout with a stall guard that watches for actual build progress, and added salvage for execute stages the ceiling kills: if the work already passes the gate, it is kept as ground truth instead of discarded. Driver and systemic-failure detection were aligned with the new semantics, and the mechanics were documented.

  10. 7 commits, b17fe26d3 6262c529e run handover-gate-concurrency-lock-plan replay

    Per-repository gate lock serializes concurrent runs

    A gantry run built the per-repo gate lock planned after two concurrent runs shared a test database and produced spurious red gates: a crash-safe lock primitive, gate executions routed through it with a visible waiting state, and capture of the merge-resolve gate log on both pass and fail.

  11. 7 commits, fd832bc7f 0fc37cf85 run handover-resume-all-job-types replay

    Every job type becomes resumable

    A gantry run fixed resume for the newer job types: the job kind is now persisted with the run so resume re-derives the right driver, design and map jobs got per-driver resume guards, and each driver's resume path was checked for idempotence. Before this, resuming a design or map run could restart it as the wrong kind of job.

  12. 12 commits, 003d90933 c164a330f session

    Identity and polish: the ⋈ symbol, chat pane, and cleaner run list

    A mixed Claude Code session on one day: adopted ⋈ as the project symbol throughout, put live run progress in the terminal window title, and made `list` hide finished runs by default. It fixed the Codex harness writing its answer file inside the worktree where it could leak into commits, refined the TUI chat pane (collapsed by default, phosphor amber/green accents from the web design system, wheel-only mouse tracking so native text selection works).

  13. 7 commits, f87fce2a1 3c1b1f904 run plans-resume-reset-interrupted-chunk replay

    Resume discards an interrupted sprint's partial work

    A gantry run added the resume-time reset: when a run is resumed over a sprint that was interrupted mid-execution, the worktree is hard-reset to the last good state and the sprint re-executes from scratch, instead of building on half-finished work. The recovery is narrated durably in the run journal so a later reader can see the reset happened; the map driver was documented as outside this observability.

  14. 30 commits, dec88f137 eef4dcf3b run plans-refactor-dedup-core replay

    Core deduplication: one driver core, one event fold, one codec

    A two-day, four-milestone gantry run consolidated the engine after months of accretion: a single per-stage driver core shared by the flat and map drivers, one event-fold shared by the TUI and headless front-ends (with display-title, time-format, and dispatch consolidation), a serde-derived attach codec plus harness config and auth dedup, and a final hygiene pass over the worktree contract, git error handling, and CLI/TUI helpers. At 30 commits it was one of the largest pure-refactor runs of the release, with one mid-run replan to pin serde key ordering.

  15. 7 commits, 688d6d16a 085d44f71 run plans-fast-map-resume-scan replay

    Map runs resume in one fast parallel scan

    A gantry run sped up resuming wide --map jobs: instead of classifying completed units one by one, resume now does a single parallel pre-scan across a thread pool and burst-emits already-finished units as Skipped, so the front-ends show the resumed state at once without flicker.

  16. 13 commits, a730d97d9 8b2ab8d04 session

    Demo mode, run.pid cleanup, and the two-column TUI layout

    A Claude Code session in one day: made `--demo` an endless milestone-structured showcase run with a merge finale and STOP modal, rebuilt the TUI sidebar as stacked about + sprints cards in a floating rail and split the body into equal rail and feed halves, and let a resumed map run re-widen its worktree pool with a bare --jobs. It also made the run lock unlink run.pid on clean release — first gitignoring the runtime state files, then reverting that in favor of not leaving them behind at all — and scrubbed author identity env vars from the post-commit rebuild hook.

  17. 9 commits, dca590648 3a4f8f4b4 run plans-replay-past-runs

    Every run records a lossless event tape

    A gantry run gave each run a durable event tape that persists its event stream losslessly, and a fallback that reconstructs a playable stream from the run journal when no tape was recorded. The tape is what any later reader of a finished run works from. The playback tooling built on it in the same run is development tooling and is not part of a distributed build.

  18. 9 commits, 7e0af10a4 96293845b session

    Codex waits out weekly usage limits instead of failing the run

    A Claude Code session taught the Codex harness to park until the weekly usage-limit reset rather than give up, and detached the post-commit rebuild hook into its own session so it cannot hold the commit hostage. A TUI pass tightened card padding and made the sidebar/feed divider draggable.

  19. 4 commits, 66bf9b684 7e5ed6067 run plans-collapsed-milestone-run-hides-mile replay

    Single-milestone runs drop milestone wording from the feed

    A small gantry run made collapsed single-milestone runs read as plain runs: feed cards no longer mention milestones when there is only one, so the two-level vocabulary appears only where the structure is real.

  20. 5 commits, 286d20641 a6a421a45 run plans-replan-reenumerate-sprint-loop replay

    The build loop picks up mid-run replans as new sprints

    A gantry run made the sprint build loop re-enumerate the sprint spec after each unit, so sprint files inserted by an in-run replan are actually picked up and executed instead of being ignored by a roster fixed at start. A new RosterUpdated event carries the mid-run roster change, and the monitor, headless output, and replay all show the inserted sprints.

  21. 12 commits, 6bbf143c8 6f6c5dbe1 run inline-per-turn-usage-capture replay

    Capture per-turn token usage into normalized sidecar files

    A gantry run added per-turn usage capture across harnesses: a normalized sidecar record format, a finalization hook, and extractors that pull usage from Claude session references, Codex rollout files, and opencode session logs, with a degraded-capture fallback for Gemini. Analysis tooling was switched to prefer these sidecars over its previous fallback sources. The cluster's commits are the run's own plan and progress records; the extractor code landed alongside them over 2026-07-10 to -11.

  22. 16 commits, 6f08ce9f1 5bceaa11e run cli-convention-aliases replay

    Resume aliases, an interactive resume picker, and a Recent runs menu

    A gantry run brought the CLI's conventions in line with Claude Code and Codex: `--resume`/`-r`, `--last`, and `-p/--print` aliases, an interactive newest-first resume picker when no run is named, and a Run menu entry listing recent runs for reopening from the TUI. It also renamed agent session history to stage logs in the docs.

  23. 10 commits, 0b5990fcc 7ac65892e run sprint-replan-recovery replay

    Incomplete sprints get a bounded, replan-capable retry ladder

    A gantry run built sprint-level recovery for reviews that come back incomplete: the review's disposition routes the sprint into a bounded retry loop that can also replan the current sprint, attempt state is persisted in the job pin so retries survive interruption, sprint briefs are restored before resume, and recovery attempts show up in status and the event stream.

  24. 6 commits, d092e019c b56670c26 run handover-2026-07-13-fix-resume-reset-dis replay

    Resume no longer discards uncommitted sprint completion state

    A gantry run fixed the root cause of the falsely-reported no-work halts: resume's hard reset was discarding uncommitted sprint DONE ledger rows, making finished work look undone. Resume now preserves orchestration state through the reset, and a sprint re-run that finds nothing left to do completes as an idempotent no-op instead of an error. Companion to the no-file-changes recovery run from the same day.

  25. 8 commits, 56029ab11 ff46583c6 run no-file-changes-recovery replay

    No-file-changes halts reconcile against the gate before stopping

    A gantry run replaced the blunt \"agent produced no file changes\" halt: a no-op sprint is now reconciled against the real gate — green means the work was already done and the sprint completes, red routes through the bounded recovery path instead of stopping the run. The sprint completion ledger is also committed on normal finish so the state resume depends on is durable. Built from the halt catalog and root-cause work recorded the same day.

  26. 78 commits, 38dbcd3b3 6ccad3a9d run plugin-seams replay

    Harnesses and drivers move behind registries and a service surface

    The largest engine refactor of the release: a 78-commit gantry run executed the revised plugin-seams plan across five milestones, putting harness metadata behind a compiled registry, driver selection and job dispatch behind a registered-driver seam, and the build pipeline's roster, gate, partial-merge, and read-side helpers behind a DriverServices surface with documented contracts. Missing harness or driver implementations now fail explicitly instead of silently. The run replanned its sprints repeatedly along the way, and Martin intervened once by hand to defer visibility enforcement from milestone 03 to 05.

  27. 25 commits, da8bd119f e3c34a576 run environment-bootstrap replay

    Runs gain an environment stage that briefs every agent

    A gantry run added an environment-build stage: a run produces an environment briefing artifact, validated on render, and injects it into every worker's preamble prompt — map workers included — so agents start knowing the project's build and test facts instead of rediscovering them. Malformed preamble prompts now fail loudly, and the prompt set was consolidated and reworded.

  28. 10 commits, 81c9a7766 03e141076 session

    Bootstrap rework, SBOM in tarballs, and preserved stage logs

    A Claude Code session made a batch of engine and release fixes by hand: it reworked the environment bootstrap to be plan-aware, unverified, and non-fatal; preserved an earlier attempt's stage logs across a re-run; shipped the SBOM inside every binary tarball; stripped documentation comments from the release tree; stopped a hung test suite from silently disabling the rebuild hook; nudged the sprint planner toward preparatory refactorings; and gave the TUI menu model its own identity apart from the screencast code.

  29. 11 commits, f6609b0cf 565c9b8e5 run blockers-flow-as-messages replay

    Blockers arrive as chat messages with inline action buttons

    A gantry run moved run blockers into the assistant pane's conversation: a blocker now renders inline as a markdown message with relabeled action rows, operable both by keyboard focus and by mouse click, instead of interrupting with a separate prompt surface.

  30. 54 commits, 4dde3bd93 533748d6c run config-schema-and-settings-form replay

    One config schema drives parsing, the settings form, and its docs

    A large gantry run built the schema-driven settings system: a declarative config schema from which the global-config parser, an effective-config snapshot, a modal settings form with stateful sessions and paste handling, a settings-write engine command, and the generated settings docs are all derived, plus role-specific effort and timeout budgets. The run itself became a story: it reached all units done but died at the merge stage on a resolve failure, Martin staged a sprint split replan and reconciled test fixtures by hand, and filed the bug that the assistant pane could not finish a stalled run — the incident that motivated the resume-in-place work.

  31. 14 commits, d34952aa7 e7f1f2515 run resume-in-place replay

    A stopped run resumes with a keystroke, without quitting the TUI

    A gantry run built resume-in-place: an owned, stopped run can be re-entered from the front end that is already on screen — no quit, no retyped resume command in a host shell. The engine distinguishes in-place front-end restarts from ordinary resumes, restores the TUI session after one, and covers the lifecycle with regression tests. Built from the plan written after the config-schema run died at merge with the fix known but unreachable from inside the application.

  32. 5 commits, a82212b25 c8aba3716 session

    Agent prompts become named instructions; the planner stops setup

    A Claude Code session tightened the shipped agent prompts: every prompt in config/agent-prompts/ is now named as an instruction, the sprint planner is told to plan setup work rather than do it itself, and the executor's naming rule lost its Gantry-specific wording and padding. A follow-up commit greened the gate by vetting a Brakeman warning and dropping assertions on a removed component.

Drivers beyond the default build

The map, goal, and loop job types, and the first swappable prompt set.

  1. 6 commits, 0ad9e4e84 e4e486eaf session

    A web-design prompt set turns the planner into a design-brief author

    A Claude Code session added the first swappable prompt set: pointed at a web project, the planner reads that project's own design system and writes design briefs instead of build plans. It shipped with a wrapper script and its own --help and README entries, and is the ancestor of the design drivers that arrived later in the release.

  2. 6 commits, d7596beab 4c4257b68 run docs-job-management-plan

    Runs get names: list, status, enter, resume, and remove by name

    A gantry run added name-addressed run management. It created a persistent run registry with a forgiving name resolver, then wired CLI verbs on top of it — list, enter, status, remove, and resume — so a run can be managed by its name instead of a path, and documented the new commands. The main commit added the command layer in src/commands.rs and rewired main.rs around the registry.

  3. 21 commits, 74821fe25 1c74cb133 run plans-jobs-triage-and-sprints-plan

    Triage agent at the front of the run, and chunks become sprints

    A gantry run refactored the job-planning layer in three milestones: it cleaned up the three-job system and fixed clarity problems in the job definitions, added a triage agent that organizes jobs at the front of a run, and renamed "chunks" to "sprints" throughout the codebase. The rename milestone had a rough patch — chunk 02 failed, was replanned, and re-executed — but the run finished the same day. It also made the TUI sidebar label dynamic and the plan-card text outcome-neutral.

  4. 24 commits, a38d37b66 e6b88cdcf run plans-map-job-type replay

    The map job type — fan work out over many items, then concurrently

    A gantry run built the map job type in two milestones. The first implemented the sequential core end to end: a spec-driven fan-out that runs one agent per work item. The second added concurrent execution, sampled checkpoint QA, and live fan-out monitoring. One sprint needed a retry and the run replanned twice along the way, but both milestones completed in a single day.

  5. 4 commits, f541955e5 ad305fd19 run plans-adaptive-split-default-plan replay

    TUI sidebar/feed split gets an adaptive default width

    A small single-sprint gantry run gave the TUI an adaptive default for the sidebar/feed split: when the user has not dragged the divider themselves, the split position now follows the terminal size instead of a fixed value. The change lives in the TUI render and state code.

  6. 55 commits, 91828f45b 4f2612c83 run goal-job replay

    The goal and loop drivers: verification-driven runs beyond milestones

    The largest driver run in the release: a gantry run built the goal and loop drivers on a shared verification pipeline, in five milestones — verification foundations, campaign and build refactors, the goal campaign driver, the loop iteration driver, and the web/docs surface. Fix commits along the way hardened the new machinery: goal verdicts persist across resume, synthesized campaign files keep the original run's identity, frozen goal output is escaped with dynamic fences, and a final goal review is guarded before merge. Martin intervened once mid-run to re-scope a sprint to the progress-descriptor rendering code, and the run replanned the goal driver after a cycle-cap review.

  7. 13 commits, 1987fab69 6fa6501a6 run goal-unlimited-cycles replay

    Goal runs lose their cycle cap and default to unlimited

    A gantry run made the goal driver's cycle ceiling optional: goal runs now iterate without a cap by default, and a ceiling, when set, survives resume. The run also surfaced registry progress in the run-management commands and updated the help text and docs to describe goal runs as unlimited.

  8. 11 commits, 27e311e4f 21ee3f153 run loop-becomes-the-goal-driver-ralph replay

    --loop becomes the goal driver's name; --ralph is the alias

    A gantry run reorganized the driver command surface: it renamed the goal loop driver, added the --ralph alias, and made --loop, --goal, and --ralph route to the right owner. It also added front-matter guards that reject a prompt whose front matter belongs to a different driver, so a plan cannot run under the wrong mode, and refreshed docs, prompts, help text, and site copy to match.

  9. 40 commits, b52a1f35d 754718769 run map-driver-takes-prose replay

    --map takes a prose plan and generates its own spec

    A gantry run made the map driver accept prose like every other driver: a prose plan is turned into a generated map spec by a planning agent, so the user no longer has to hand-write the spec. Most of the run's weight went into validating what the planner produces — generated specs are checked against real enumerators, shell-dependent and statically-listed work lists are rejected, support files and template placeholders are verified, and a bounded repair loop fixes a bad spec before fan-out. Resume keeps the original prose identity.

  10. 22 commits, cf12db10f 023b1da82 session

    Map runs get an environment briefing; harness choice survives resume

    An interactive Claude Code session fixed two gaps in the map driver: a map run now builds and injects the same environment briefing every other run gives its agents, and its workers get unique test scratch directories so concurrent units stop colliding. A resumed run also keeps the harness it was started with instead of falling back to the default. TUI menu dividers were fixed the same day.

Harness support

Running claude, codex, opencode, and gemini agents, and surviving their usage limits.

  1. 13 commits, 593c254de e6d879f47 run docs-multi-harness-plan

    Pluggable harnesses: Claude, Codex, OpenCode, and Gemini agents

    A gantry run made the agent runner harness-agnostic and added the three non-Claude harnesses in one day. It extracted a Harness interface from the Claude-specific runner code (argv construction, stream-json parsing, usage feed, sandbox capability flags) and refactored Claude as the first plugin, then implemented the Codex, OpenCode, and Gemini plugins on top of it, with role-based harness selection, per-harness system-prompt delivery variants, and exit-code threading for Gemini's parser. The run also documented the new configuration surface, a Gemini authentication caveat, and the env-scrubbing design decision.

  2. 7 commits, b2b2c157c 8caf6dcdd run plans-usage-limit-reset-aware-backoff replay

    Retries wait for the Claude usage-limit reset time instead of guessing

    A gantry run replaced blind exponential backoff with reset-aware waiting when a harness hits a subscription usage limit. It reclassified subscription and session limit errors as transient rather than terminal, added optional wait hints that the retry loop honors, parsed Claude's usage-limit reset times to set the wait, and rendered the reset-wait distinctly in the headless frontend. A hand fix during the run deflaked a chat test by also waiting for the RunStarted event.

  3. 4 commits, e1c61554c 574043075 run plans-gantry-handover-stream-json-verbose replay

    Fix claude 2.1.191+ invocation by pairing --verbose with stream-json

    A small gantry run executed a single-sprint compatibility fix: claude CLI 2.1.191+ requires --verbose alongside --output-format stream-json, so the Claude harness now always passes it. Four commits, one real change.

  4. 5 commits, d49afd3f3 c0f234bfe run plans-codex-usage-limit-backoff replay

    Codex harness gains reset-aware usage-limit backoff

    A gantry run extended the reset-aware backoff (built earlier for Claude, entry c041) to the Codex harness. It first threaded the agent's stdout JSON into the harness parse layer via a ParseInputs type, then taught the Codex parser to recognize usage-limit reset times from that stream so the retry loop can wait until the limit actually lifts.

  5. 8 commits, 3d1414a54 f289e5088 run plans-usage-limit-card replay

    Usage-limit waits get their own TUI card with a live countdown

    A gantry run gave usage-limit reset waits a dedicated Waiting card in the TUI that counts down to the resume instant, instead of the run appearing silently stalled. It captured the absolute resume instant (with local offset for display), built the card lifecycle, and rendered the ticking countdown; a follow-up sprint specified the edge cases. Executed from the plan written the same day (entry c051).

  6. 7 commits, 628e02d2c e07ddfb7b run plans-codex-single-sandbox-layer replay

    One sandbox layer for every harness; agents aimed at their worktree

    A gantry run collapsed the per-harness sandbox exemptions into one rule: claude, codex, opencode, and gemini all run inside gantry's bwrap when a sandbox is configured, and native-sandbox harnesses (codex, gemini) disable their own containment via a new AgentSpec flag so exactly one filesystem isolation layer applies. A second sprint fixed agent working directory targeting, guarding the cwd in the preamble and setting it to the worktree instead of the main checkout.

  7. 9 commits, dd941351d e23de09ee run plans-harness-model-on-every-card replay

    Every TUI card footer shows which harness and model ran the agent

    A gantry run, structured into five sprints, threaded a harness+model AgentTag through the whole system so each agent card can say what ran it. The tag is emitted at spawn, carried across the attach wire protocol, persisted and re-parsed in the history journal, held in TUI card state, and rendered in a new two-line card footer alongside the metrics. Executed from the card plan in entry c051.

  8. 8 commits, 53f64dde6 97341377b run plans-defer-harness-model-selection replay

    Model choice defers to the harness CLI unless explicitly pinned

    A gantry run made the main-model setting optional across harness config, harness info, and the AgentTag, so gantry omits the model flag when no model is pinned and lets each harness CLI pick its own default. It also fixed the utility small-model override to work without a main pin and documented the deferral policy. Executed from the plan Martin rewrote the same morning (entry c089).

  9. 10 commits, 3be8a847f 6b2d30c56 run global-default-harness replay

    Global default harness and a repo-free `gantry config` command

    A gantry run added persistent global configuration for the default harness: a global config store, startup fallback resolution when no per-project setting exists, precedence rules between build roles, and a new `gantry config` command that works outside any repo. It kept a legacy role-resolver wrapper for compatibility and documented the new surface.

  10. 8 commits, ee8da5f0f 1e836461b run global-config-harness-and-model replay

    Global config covers harness settings with defined env precedence

    A gantry run, in two sprints, expanded global config preference parsing beyond the default harness and merged global `[harness.*]` settings into harness configuration with defined precedence: plugin defaults, then global preferences, then environment overrides, including legacy environment aliases declared by registry entries. Tests cover the merge precedence, malformed args, and unknown harness tables.

Worktrees and the merge machinery

Isolated run worktrees, conflict resolution, and a finalize that holds.

  1. 8 commits, 825eb140f c30e91cd2 run plans-merge-partial-resumable replay

    Partial, resumable mid-run merges via the merge command

    A gantry run added checkpointing to builds: a MergePartial command in the engine, wired through the attach transport, that merges the work completed so far back to the main branch and leaves the run in a resumable state. It also added the user-facing `gantry merge <name>` verb, working against both live-attached and offline runs, and documented the workflow.

  2. 8 commits, f7da9c38b 4099b73a0 run plans-merge-preserves-both-sides replay

    Merge reconciliation that preserves both sides of a conflict

    A gantry run built the merge-reconciliation layer: delta-classifier primitives that analyze what changed on the main branch versus the run branch, automatic repair of unambiguous cases where a merge dropped one side's content, and an autonomous adjudicator-repairer for the residue where main dropped content in regions the run branch also rewrote. Clean merge-backs now emit a Reconciled event so integration is auditable.

  3. 13 commits, 0e08ac2b0 37856a673 run plans-shared-checkout-safe-finalize replay

    Finalize made safe in shared checkouts

    A gantry run hardened run finalization for the case where the primary checkout is shared with other work: archive commits are scoped to explicit pathspecs so unrelated uncommitted changes are never swept in, `.gantry/` run-state is excluded from the confinement diff, and a crash-safe checkout lock serializes concurrent finalizes that mutate master. It also retired the snapshot-based restore_main_state rollback in favour of a non-destructive merge abort that leaves the checkout at its live tip, and added a post-merge gate run on master to catch semantic conflicts between concurrent runs.

  4. 6 commits, d7d22073c e482efa6b run worktree-locate-from-linked-worktr replay

    Runs launched from linked worktrees find the primary checkout

    A short gantry run fixed primary-checkout resolution so a run started from a linked git worktree (where the git dir lives elsewhere) resolves the real primary checkout root, and audited the run entrypoint for linked-worktree handling.

  5. 8 commits, dd19e17d0 6b8e0bb20 run aggressive-merge-resolution replay

    Merges are gated in the worktree before landing on main

    A gantry run tightened the merge flow: a clean merge is now test-gated inside the worktree before it lands on the main branch, semantic breaks introduced by a merge are repaired before main advances, and partial merges go through the same resolve path as full ones instead of a separate code path. It also clarified the resolution prompts and failure-handling documentation.

  6. 10 commits, ec41eb979 acb3aaa17 run handover-autonomous-conflict-resolve-the replay

    Merge conflicts are resolved autonomously before asking the user

    A gantry run, planned from a handover document, changed conflict handling to try an autonomous resolution first: an agent attempts the merge repair on its own, and only when that stalls does the flow fall back to a prompt offering the user a choice of recovery paths, including an assistant-guided retry loop. Tests cover the fallback recovery paths.

  7. 11 commits, 7ab66ab15 b02bd5fcb run rock-solid-merge-finalize replay

    Merge finalization unified and made recoverable

    A gantry run consolidated merge finalization onto one shared path with a single completion condition all routes must satisfy. Finish now distinguishes a merge that actually landed from stale merge residue, handles already-merged runs and residue left by earlier failures, and routes semantic merge repair through the normal resolve_conflict path; offline partial merges against a dirty main checkout are pinned by tests. The run closed by archiving the merge incident documents that motivated it and retiring a stale plan.

  8. 14 commits, be0d5f9cd 46416341d run pin-and-name-the-home-branch replay

    Runs merge back to a pinned home branch, named in the UI

    A gantry run made the branch a run was started from an explicit, persisted fact: the home branch is captured at launch, survives run resume, merges route back to it rather than to an assumed main/master, and user-facing screens name the actual target branch. Docs were renamed from main-branch to home-branch vocabulary. One test spec that drifted during the run was reconciled by an interactive Codex session.

The Gantry Assistant

The in-run agent: chat pane, MCP server, and agent diagnostics.

  1. 6 commits, 98d01bcc6 d8a970b2e run gantry-agent-p1-worktree-conflict-resoluti replay

    Merge conflicts get resolved inside the disposable worktree

    A gantry run built conflict resolution that never dirties the main checkout: a first sprint added five merge primitives with safe rollback, and a second moved the actual conflict-resolution step into the disposable worktree. This is the groundwork that lets an agent fix a conflicted merge without touching the user's own working copy.

  2. 9 commits, e13474d46 c8da900e4 run loom-agent-p2-bidirectional-ui-engine-ch

    The engine and TUI get a two-way prompt/answer channel

    A gantry run built the bidirectional channel between the engine and the interface: a prompt/answer contract with an engine command back-channel, a text-input widget and prompt modal for the TUI, non-interactive resolution for headless runs, and design-mode confirmation routed through the new in-run prompt channel. This is the mechanism every later interactive feature — chat, blocker prompts, investigations — sends its questions through.

  3. 13 commits, 38b7f3f1a 0b1cecc4d run gantry-agent-p3-gantry-job-mcp-server replay

    An MCP server lets agents query and control gantry runs

    A gantry run built the gantry MCP server in two milestones: first a read surface of tools for querying run status and metadata, then action tools — bash execution and run control — gated behind sandbox containment. This server is what the in-run assistant and any externally attached agent use to see and steer a live run.

  4. 23 commits, 38cd057f7 0ed7693a4 run gantry-agent-p4-gantry-agent-chat-pane replay

    The Gantry Assistant arrives: chat backend, chat pane, blocker routing

    A gantry run built the first version of the in-run assistant across three milestones and 23 commits: a conversational backend (harness selection flag, transcript store, chat loop runner, MCP plumbing, engine integration), a collapsible chat pane in the TUI, and first-line support routing that sends the run's halts and conflicts to the assistant for a decision. The run re-planned itself once mid-milestone and finished with all gates green.

  5. 14 commits, ab8cd067f cca46db99 run gantry-agent-p5-session-process-model replay

    Runs get exclusive ownership locks and a live attach transport

    A gantry run established the session process model in two milestones: process-aware locking that gives each run exactly one owner, and an attach transport — endpoint, client, lifecycle, and codec — that lets front-ends subscribe to a live engine, with the MCP server integrated on top. This is the one-owner run lifecycle and the attach layer later web-view work builds on.

  6. 4 commits, 985d84a5d 1994e651c run handover-wire-chat-console-into-engine replay

    The chat console is wired into the live engine

    A short gantry run, started from a handover, connected the previously stubbed chat console to the execution engine: user messages route to streamed replies, prompt answers forward to the engine's prompter, and runs without messages skip the assistant entirely, with an owned driver materializing the console on the demux thread. After this the assistant built in the chat-pane run actually talks to a running build.

  7. 10 commits, a9a41f914 50583fadd run plans-harness-aware-mcp-delivery replay

    MCP registration is delivered natively to each harness

    A gantry run replaced unconditional MCP config writes with harness-aware delivery: a harness-neutral server spec on the agent, then per-harness renderers that register the server the way each tool expects — Claude's config file, Codex's command-line flags, Gemini's and OpenCode's settings files — and finally migrated the assistant driver onto the new path. Martin added the plan files by hand mid-run.

  8. 7 commits, 39503af87 1a7975ee3 session

    Chat delivery fix, agent diagnostic, and small run-machinery fixes

    A stretch of Claude Code sessions across late June and early July fixed assistant replies arriving only after the engine finished and grew the `agent` verb into a multi-turn diagnostic for chat roundtrips. The same stretch added a post-commit hook that pushes a fresh green binary to the atlas machine, fixed the run identity on --no-ff merge commits, and adjusted chat prompt spacing in the TUI.

  9. 8 commits, d6bd670d5 c36be6776 run plans-bare-loom-chat

    Running bare `gantry` in a terminal opens the assistant chat

    A gantry run made a bare invocation with no plan or verb open the Gantry Assistant chat directly: a start-in-chat signal, empty-build chrome so the TUI has something sensible to show without a run, and a shared production console setup extracted for both the chat and build paths. The behavior was later revisited twice — withdrawn on 2026-07-13, then restored with a greeting on 2026-07-16.

  10. 14 commits, cdb297cb7 cec48d6e0 run rename-brain-to-assistant replay

    The in-run agent is renamed from brain to assistant

    A gantry run renamed the product vocabulary from "brain" to "assistant" in two milestones: first the code paths and chat-facing surfaces, then the live documentation and help text. A pure rename with no behavior change; the current Gantry Assistant name dates from here.

  11. 8 commits, 2531264d3 70026fe48 run assistant-input-strictly-opt-in replay

    Assistant input becomes strictly opt-in

    A gantry run stopped recovery prompts from grabbing the keyboard: recovery prompts are tagged as a distinct prompt kind and stay passive until the user focuses the pane, a nonintrusive overlay explains that input is waiting, and bare-invocation chat starts visible but unfocused. Typing into the assistant is now always an explicit choice, never something a run forces on you.

  12. 7 commits, b0cef48d4 d28b1d4ab run enter-agents-guide replay

    gantry enter writes an orientation guide into the run worktree

    A gantry run made `enter` leave a guide behind: a renderer produces an orientation document with the run's status and safe aliases, the files are written into the run worktree when it is opened, and the behavior is documented. An agent or human dropped into a run's worktree now finds instructions on what the place is and what is safe to do.

  13. 9 commits, 79ddf4e0e 43aec1d70 run investigate-with-agent replay

    Blockers can be investigated by launching an interactive agent

    A gantry run renamed the blocking-snag recovery flow to "investigation" and rebuilt it: blocker prompts share one choice contract and fold into the standard prompt modal, and a new action suspends the TUI to launch an interactive harness session in the run's worktree so a person can debug the blocker with an agent at their side, with harness options and launch helpers behind it.

  14. 18 commits, b353f06ff be96c89a9 session

    Agent prompts condensed, bare invocation reverted, snag renamed

    A day of Claude Code sessions across several threads. The shared agent prompts were condensed to one-to-three tight paragraphs and re-grounded with real context and structured escalation. Bare `gantry` was changed to print a terse two-line hint instead of opening the assistant chat (reversing the earlier bare-chat run; itself reversed three days later). The word "snag" was purged for "blocker" throughout, oversized merge prompts were externalized to avoid E2BIG at spawn, and licensing and copyright were settled.

  15. 55 commits, 54e1e0e92 9dc0d5710 run gantry-agent-p11-perfect-the-assistant replay

    Assistant polish: pane sizing, model menu, blockers, MCP docs

    The largest assistant run — 55 commits over four milestones — refined the whole experience: the composer grows and wraps with layout-driven focus and explicit resize actions; a model submenu switches the assistant's model for the next turn; blocker prompts route through the assistant pane with an inline stop action; turn failures surface as chat events and the assistant's identity threads through its turns; and the MCP server gained scoped run listing while the assistant and MCP documentation was aligned with the code and reorganized. Martin intervened by hand mid-run to drop a narrated menu-tour requirement and park a menu/screencast decoupling plan.

  16. 42 commits, 733ebb883 e8bcbd403 session

    Assistant chat polish, markdown replies, and prompt-pipeline studies

    A dense single-day Claude Code session spanning three threads. Assistant chat polish: agent replies render as markdown, the composer gained recall, paging, and paste, a waiting indicator shows while a reply is in flight, the divider bar and modal rendering were reworked, bare `gantry` opens the chat again with the assistant greeting first, and assistant commits get their own git identity. Prompt-pipeline work: an environment briefing authored ahead of the sprint planner, agents told they may read the orchestration directory, and fleet studies of opening tool calls, planner reading depth, and the bounded-fix stage.

  17. 8 commits, ce5574be6 0bd01f154 run spec-available-to-every-agent replay

    Every worker agent can read the durable plan artifact

    A gantry run made the original plan document visible to every worker agent in a build: the shared agent preamble gained an optional plan-artifact reference, and each driver supplies a worker-visible path to it. Workers no longer act only on their sprint brief; they can consult the plan the whole run is executing.

The terminal UI

Cards, sidebar, menus, modals, and the theme.

  1. 32 commits, d9a2bd916 43aa76ac3 run plans-menu-makeover-plan replay

    Menu bar, pager, clipboard, and live stats built into the TUI

    A gantry run executed the plans-menu-makeover plan across four milestones, rebuilding the TUI's command surface from scratch: an action registry and seven-menu bar with View and Help menus, a shared read-only pager, clipboard support, Tools and Chat menus, then Run, Agents, and Stats menus backed by a new statistics aggregation layer for agent-run tracking, and finally cross-cutting behaviours — bar ticker, Prompt menu, empty-state display, recent events, and a demo mode. The run replanned sprint 03 of milestone 02 mid-flight to also surface worktree metadata and the plan-source path.

  2. 5 commits, a9f3c44b6 5f3678ee1 run handover-reinstate-reverted-tui-changes replay

    Two-column layout with stacked sidebar cards restored after bad merge

    A gantry merge had reverted three TUI changes, so a follow-up gantry run was launched from a handover document to put them back. It reinstated the two-column layout with stacked sidebar cards in the renderer, then pinned the layout and sidebar stacking with render tests so a later merge could not silently drop them again.

  3. 23 commits, 0721b1d3e 243199503 run plans-stats-panel-plan replay

    Stats panel, upgraded pager, and git activity view for the dashboard

    A gantry run built the plans-stats-panel plan in three milestones. It first upgraded the shared pager component — line wrapping, scrolling, search, input handling and paging, and source threading with refresh — then implemented the stats panel itself, and finished with a git activity view showing commits and repository changes inside the dashboard. The run replanned one milestone after review over a cross-repo dependency, and along the way fixed fallback-backoff accounting to exclude mid-stage sleep.

  4. 9 commits, 92458e53d 7e84a2cc4 run plan-text-selection replay

    Mouse text selection and clipboard copy across panes and overlays

    A gantry run added text selection to the TUI: it wired in the mcurses-select crate and any-event mouse tracking, registered visible text in the feed, sidebar, and chat as selectable blocks, registered overlay text with modal z-order so selection scopes to the open modal, routed mouse gestures through an extracted, testable route_mouse_event function with copy on release, and painted the selection highlight as a post-pass over the rendered frame.

  5. 19 commits, d366dcf7c caae5d9af session

    Card gutter restyled; Loom source-available license replaces MIT

    A day of Claude Code session work with three threads. The largest was an iterative restyling of feed cards: a left gutter tried first as arrow glyphs, then as aligned box-drawing characters (a bar through body and wrapped lines, a corner on the footer), the footer collapsed to one line showing only the harness, future milestones rendered as top-level names, and width caps raised. A second thread replaced the false MIT declarations with the Loom Source-Available License v1.0 and a binary EULA. Smaller commits kept the sandbox active for codex and gemini, fixed a concurrent-run build break, and wrote the script-first narrated-screencast design plan.

  6. 7 commits, ae6bb005a f3e5d00f4 run plans-smooth-card-animation replay

    Card animation timing primitives and half-row feed slide

    A gantry run started the smooth-card-animation plan: it extracted the TUI's animation timing primitives, added half-row feed slide rendering, and marked replayed run events explicitly so replays could be told apart from live ones. Much of the run's output is the plan scaffolding itself; the fade-in and tail-follow sprints landed as later work.

  7. 10 commits, 9487451cc b8c79a21e session

    Feed slide on card growth; gantry list sorted, counted, and trimmed

    A three-day stretch of Claude Code session work across a few threads. The TUI thread made the feed slide when an in-place card growth moves the tail and made the sprint sidebar tail-follow the newest sprint. The list command was repaired: milestone runs no longer misclassified as empty, chronological sorting with a DATE column, unit counts read from the authoritative ledger (SPRINTS renamed to UNITS), and the TITLE column dropped. Smaller fixes covered SHA256SUMS coverage for the release ingestor, a merge card that said "sprints" regardless of unit, and demo unlock-token claim handling.

  8. 15 commits, a141ddb86 8e76c515d run tui-casing-cleanup replay

    TUI text casing unified across cards, statuses, metrics, and prompts

    A gantry run executed a four-sprint casing cleanup: it unified the casing of shared agent cards, aligned live-status and empty-state text, normalized state and metrics display strings, and rewrote decoration prompts into sentence case. The visible commit subjects are almost all run bookkeeping; the actual string changes ride inside the sprint-completion commits touching the renderer, state, and theme modules.

  9. 9 commits, ea489e618 f9753e146 run gantry-list-sprint-counts replay

    Run list shows sprint counts, split into state and display totals

    A gantry run (started under the pre-rename name loom-list-sprint-counts) added sprint counts to the run list: each run row shows how many sprints it holds, with the internal state count kept separate from the displayed total, and the MCP list_runs tool reporting both. The run replanned once after its first sprint and finished with a test pinning the state/display separation.

  10. 8 commits, 8c144e985 03858afed run halt-modal-full-content-scroll replay

    Stop modal sized to its content, scrollable, with inline diagnosis

    A gantry run reworked the halt modal in three sprints: halt modals are now sized from their content instead of a fixed frame, the stop overlay scrolls when the content is longer than the window, and STOP diagnosis reports render inline in the modal rather than pointing at a file.

  11. 6 commits, 40e8945b5 092e73e9b run tui-casing-cleanup-detail-strings replay

    Build stage detail strings switched to sentence case

    A small single-sprint gantry run, a follow-up to the wider casing cleanup (see the tui-casing-cleanup entry), that capitalized the engine's build stage detail strings so status text reads consistently.

  12. 5 commits, bc7f9a677 4339b7679 run sidebar-follow-active-sprint replay

    Sidebar follows the active sprint instead of the tree tail

    A single-sprint gantry run changed the sidebar's scroll behaviour to follow the currently active row rather than always tracking the tail of the tree, keeping the running sprint in view.

  13. 33 commits, b256b25a6 48b6f5f2e session

    The monitor is made panic-free at any window size

    A dense single-day Claude Code session hardened the terminal interface: the sidebar renderer and the monitor as a whole no longer panic at any window size, milestones draw as milestones from the first frame instead of appearing once the structure is known, and a flat run's sprint arrow-line is headed by the run title.

  14. 8 commits, a8005a5f1 91f7b1c87 run all-cards-count-and-state-duration replay

    Build view shows counts and final durations on every card

    A gantry run improved the build view's progress display: the feed's gate stage was retitled to plain testing language, finished cards keep their measured final duration instead of losing it when progress ticks stop, and mechanical gate stages emit live progress heartbeats that survive into the finished record. The work also covered attach and demo viewing of that progress.

  15. 43 commits, 6a8b1c49f 425b7471d run modal-rework replay

    All dialog overlays moved onto one shared modal system

    A gantry run executed the modal-rework plan in three milestones: it refreshed the vendored mcurses-menu modal and added a shared Gantry modal boundary module, migrated every dialog-shaped overlay — the stop overlay, pager, and git diffstat drill among them — onto the shared modal path with shared input dispatch and key fallthrough, and made dismissed modal events reopenable as read-only snapshots persisted in recent events. It also reordered recovery prompts to offer Gantry and external harnesses before the shell.

  16. 13 commits, 83509f352 b5cede340 run card-artifact-tags replay

    Cards show artifact tags that open in the TUI artifact viewer

    A gantry run built card artifact tags in four sprints: a tag data model, tag rendering on visible cards, opening a tag's artifact from the feed in the TUI viewer, and suppression of raw file paths from card prose now that the tags carry them.

  17. 29 commits, 32f26913f 4cf0f1fa4 run menu-system-coherence replay

    Menu system consolidated; run journal surface added

    A gantry run stabilized run operations and then reshaped the menu bar into a coherent four-title structure. It hardened the operations the menu exposes — the merge menu gated on declared partial-merge support, durable plan artifacts persisted for open-plan, live worktree artifacts preferred for run viewers — added a Run journal surface to the TUI, surfaced the configured retry policy in stats views and blocked state in collapsed chat, renamed the build-run menu surfaces to Inspect, and realigned the menu inventory docs with the shipped bars.

  18. 31 commits, 3ca0ea793 e0aa54d34 run tui-hover-affordances replay

    Hover and focus states across menus, modals, and dividers

    A gantry run added hover affordances throughout the TUI in two milestones. Gantry-side work gave the sidebar/feed divider, chat divider, composer, and inline blocker buttons hover states, applied the Gantry palette to modal chrome and buttons, and tracked hover targets during mouse routing with overlay mouse events routed through the frontmost modal; the upstream-backed milestone refreshed menu hover styling, including hover foreground theming for menu selections and highlighted menu and modal-close states.

Test-suite reliability

None of this is in the binary; it is what the gate's verdicts — and so every run's ground truth — rest on.

  1. 22 commits, b1ffcf6e6 05d8704c3 run test-suite-speed-and-tiers replay

    Test suite split into tiers; display E2E moves behind LOOM_E2E

    A gantry run reorganized the Rust test suite for speed: it moved the display end-to-end coverage into its own tier gated by an environment variable, added committed nextest profiles for the default and E2E tiers, tightened polling waits in the slow integration tests, and consolidated the default integration tests into one binary. Martin recovered two sprints by hand mid-run, and the consolidation commit itself was his.

  2. 32 commits, 0b6e29aa5 fa9f8c45f run flaky-test-eradication replay

    Flaky tests measured, root-caused, and fenced with guardrails

    A gantry run worked through test flakiness end to end: it measured a flake baseline with a stress runner, fixed the confirmed offenders — stub-executable isolation in build tests, a PATH-sensitive overlay probe, auth bootstrap leaking process env, scratch-path collisions between concurrent runs — and then added a guardrail scan for flaky antipatterns plus a test-reliability guide and evidence reports. Martin reframed four late sprints to a bounded verify/lock/document scope partway through.

  3. 10 commits, ffb02cc61 0906c4a87 run driver-loop-concurrency-flake replay

    Driver loop hardened against concurrency stress and git contention

    A gantry run chased a driver-loop concurrency flake: it first built a first-class stress reproduction, then routed git calls through a worktree helper to avoid lock contention under parallel load, made loop iterations distinguish real red verdicts from infrastructure failures (treating git baseline and gate launch failures as infrastructure), hardened rollback and invariant handling, and recorded after-fix stress evidence in a closeout.

  4. 36 commits, 9a9d4a660 4f7de8d43 run test-suite-redesign replay

    Test suite redesigned around injectable seams and structural asserts

    A gantry run restructured how the suite tests the drivers: it introduced injectable "world" seams for the driver loop, goal startup, and the sprint pipeline so driver logic runs against fakes without spawning git, bounded the test tiers with explicit timeouts and per-workspace process locks, split the root gate into default and heavy tiers, and replaced exact-copy pinning in the web tests with structural assertions (moving the legal-copy checks into quarantine). Martin rescoped two sprint briefs mid-run to split goal-mode into its own unit, and filed a bug report on an adjudicator argv E2BIG halt hit at the final merge.

The demo edition

The licensing gate in the binary, and demo identity by verified email.

  1. 19 commits, 6887a2cac f074cd84f run demo-gating replay

    Demo edition gating in the gantry binary itself

    A gantry run built the Rust side of the demo edition in three milestones: a demo identity layer, the runtime gate and unlock flow, and demo release artifacts proven end to end. Along the way it preserved HTTP error statuses from failed unlocks, tightened gating around the build lifecycle, and added demo license regression tests. It ran the same day as the website-side demo-gating run (c095), the two halves of one plan pair.

  2. 28 commits, 19c2b3239 0dc7cc7cf run demo-identity replay

    Demo builds identified by verified email, not personalized binaries

    A gantry run reworked demo identity: instead of stamping personalization into each demo binary, the demo now asks for the user's email — via a modal prompt in the TUI and a plain prompt in headless runs — verifies it, and caches the verified identity and license email hashes locally. The personalization stamp was removed from the demo gate, completion identity handling was hardened, and counted demo builds got end-to-end test coverage. The run spanned two days with a mid-run replan.

Packaging and release

Release builds, signing, the source-review archive, and the reproducible release.

  1. 19 commits, e0b8ad78d 737bc0b11 run plans-refactor-build-rs replay

    build.rs split from one monolith into a module hierarchy

    A gantry run refactored the orchestrator's monolithic build.rs into a module hierarchy over two milestones, extracting the driver, gate, agent, finish, and commit clusters and splitting the build tests into tests/ modules. The run was interrupted mid-chunk: Martin finished the last chunk's test split by hand and left a handover on resume-time interrupted-chunk recovery, also making the post-commit hook skip linked worktrees.

  2. 16 commits, 4a52ad60d 682b6bcf7 run plans-distribution-and-preflight replay

    gantry doctor, dependency preflight, and a four-target release CI

    A gantry run built the dependency preflight system and the first release pipeline in two milestones: a doctor verb that checks required external tools, startup dependency validation, a version-check, an installation guide, verified vendoring, and a CI pipeline producing release binaries for four targets.

  3. 20 commits, 232cc7077 87629b785 run plans-source-review-distribution replay

    Source-review archive, SBOM, signing, and license compliance in CI

    A gantry run made releases auditable: the release job now generates an SBOM and a source-review archive, produces detached signatures and a full checksum set, and includes THIRD-PARTY-NOTICES in release tarballs. A license-policy CI workflow keeps the notices fresh.

  4. 7 commits, d396bef33 c75052f8f run local-release-build replay

    Releases are built locally; GitHub Releases retired

    A gantry run replaced GitHub-hosted releases with self-hosted distribution: a build-local-release.sh script produces the release artifacts on Martin's machine, the GitHub Actions release workflow was removed, and the distribution and installation docs were rewritten around the website download model.

  5. 10 commits, 15a73c658 5161ebda8 session

    Release-script fixes accumulated across the 0.1.0 release period

    A thread of small release-pipeline fixes from 2026-07-10 to release day, mixing hand work and Claude Code sessions. Early fixes made the scripts run outside the repo root, installed the real minisign and demo-unlock public keys, and corrected the minisign self-verify target; later ones pinned the linker toolchain the reproducibility check builds under, stopped emitting the retired installer script, adopted the final 0.1.0 legal texts with the right licensor named, and pointed publishing at the storage volume production actually has.

  6. 11 commits, fd5f8c903 021df1b8e run distribution-feature-exclusion replay

    Devtools and screencast tooling stripped from shipped builds

    A gantry run put development-only code behind cargo features: devtools entrypoints and the replay/screencast tooling each sit behind a default-on feature, distributed release builds strip those defaults, and bin/test grew a matrix that compiles and tests the stripped configurations. Martin added one hand fix cfg-gating the demo/devtools boundary tests to their feature set.

  7. 29 commits, aa6469465 af8bef3fb run source-available-01-reproducible-release replay

    Releases build reproducibly from the published stripped source

    A gantry run made the source-available release verifiable: a comment-strip workspace member and strip-tree CLI remove comments (preserving copyright and license headers) from the published tree, the release binary is built from that stripped tree byte-reproducibly with a pinned SOURCE_DATE_EPOCH, and a verify-build.sh ships in the customer archive. A release-time gate unpacks the source-review zip, runs the shipped verifier, and refuses to ship unless it reports a byte-for-byte match — proving the customer's own verification path before anything is signed.

  8. 19 commits, c4f26053b 03723b0e2 run source-available-02-mechanized-code-stan

    A mechanized code-standards gate cleans the shipped Rust source

    A gantry goal run (three cycles) drove the shipped source toward a mechanized standards gate, scripts/source-standards-gate.sh — part of the source-available series after the reproducible release (c133). It centralized unix syscalls behind safe helpers, tightened source-safety checks across shipped code, hardened engine run-state and harness wiring, made harness and timing fallbacks explicit, and simplified the demo unlock-token validation flow.

The loom → gantry rename

The product was called loom until 2026-07-18.

  1. 7 commits, b257b654e 84066fe0e run remove-triage replay

    The triage stage removed from the build pipeline

    A gantry run deleted the build-triage stage and its job-selection plumbing from the pipeline, along with legacy sprint flags, leaving one default milestone-first build path, and documented that single flow. The matching website-copy cleanup ran the same day.

  2. 8 commits, 4bf9d9cda bc936e2b4 run gate-to-test-rename replay

    Core docs and agent prompts renamed from gate to test

    A gantry run renamed the pipeline vocabulary in the core repo: the public overview prose, the core and design-mode agent prompts, and the live documentation now say test where they said gate, and validator language became check. The website's copy got the same rename in a parallel run.

  3. 9 commits, 1a5fb4bf2 d9a12d040 run naming-cleanup replay

    Identifiers renamed for readers: BuildContext and orchestration

    A gantry run codified the name-for-the-reader convention and applied it to the code: build-pipeline context references became BuildContext, clipped orch identifiers became orchestration, and the naming guidance in the agent-facing docs was clarified to forbid invented abbreviations of the project's own vocabulary.

  4. 51 commits, 91df9496c 269744f1e run brand-gantry-rename replay

    The product renamed from Loom to Gantry

    A gantry run executed the brand rename from a hand-written plan: LOOM_* environment variables became GANTRY_*, the package, README, legal pages, TUI branding, and window titles now say Gantry, the emblem glyph changed from ⋈ to ⨝, orchestration paths moved from `.loom` to `.gantry`, and the website's legacy loom hosts redirect to the canonical gantry.software origin with host policy centralized. The plan deliberately left run history, applied migration filenames, and the one-shot screencast migration scripts untouched; runtime name helpers mark the rename boundary for anything that must still read old artifacts.

  5. 48 commits, 5309fc71a df4367449 run source-tree-product-rename replay

    Source tree renamed to gantry, with a compatible wire contract

    A gantry run — the first to commit under the gantry author name — executed the last and largest part of the rename: roughly 5,300 product references across 533 source files, including gantry_jobs artifact paths, the LoomJob→GantryJob model, the job-summary pipeline, ignore rules, and runbooks. The one behaviour-bearing piece, the demo API's loom_version request key, was handled as a permanent compatibility window: the server accepts both keys and the client sends gantry_version. Martin intervened by hand mid-run to drop an unmeetable fleet-closure-zero requirement from the gates and to fix the registry verifier, and the run repaired a merge that had dropped main's changes before finalizing on 07-19.

Maintenance

  1. 65 commits, 1ffff2858 5ab237000 session

    A global configuration tier joins harness and model resolution

    Two runs landed their build commits directly on master over this week: a source-standards pass that adopted the workspace readability lints across the engine, and the global-config work that put a global tier into harness and model role resolution — command line first, then the project's harness.toml, then global config, then the built-in fallback — with the resolution source tracked so a surprising choice can be explained. The rest of the cluster is Gantry's own record keeping after each run's merge.