Runs and Patterns

The pattern language and the One World build

Drivers became declared, user-authorable patterns, and the per-driver runtimes collapsed into one execution world.

1. 2026-07-21 – 2026-07-22 · 114 commits, 086ae368a → f818f4605 run runs-and-patterns replay

   Runs execute patterns: vocabulary, pattern language, one projection

   A gantry run built the five-plan runs-and-patterns family in 114 commits over two days: it retired "job" from Gantry's vocabulary (a run executes a pattern), made the compiled defaults refreshable with a provenance manifest and factory reset, moved the goal check in-tree, implemented the pattern language core with sub-patterns and recursive built-ins, and gave every display consumer one run-state projection. A forensic audit the same day found the run had oversold one claim: the inner per-task pipeline was resolved and substituted from TOML but still executed by the old Rust code, which set up the two audit runs that followed.

2. 2026-07-22 – 2026-07-23 · 63 commits, 038aa51d8 → d5a3f2368 run audit-finish-inner-unit-handover replay

   The interpreter drives the gated inner unit in production

   A gantry run executed the forensic-audit handover left after runs-and-patterns: gated-task-set.toml — the per-task execute, gate, fix, review, replan, commit pipeline — was being parameter-substituted in production but never interpreted; the live executor was still the pre-refactor Rust. In 63 commits the run defined the language contract for the gated inner unit, built the production world that executes gated tasks through the interpreter, routed production sub-patterns through interpreted gated tasks, and hardened resume. After the merge on 2026-07-23, editing the TOML actually changes runtime behavior.

3. 2026-07-22 · 2 commits, 475df52d6 → 786758b3c session

   TUI sidebar stops flashing bare milestone ids

   A Claude Code session fixed an id collision in the milestone sidebar and made the sidebar withhold a node until it has a name, so a bare id is never rendered while the name is still being written.

4. 2026-07-23 · 71 commits, 025c18dd8 → fd7457965 run audit-pattern-language-conformance replay

   A conformance suite tests the pattern language itself

   With drivers expressed as TOML, any one driver is a single sample from the pattern language's space, so testing the drivers no longer tests the language contract they all depend on. A gantry run built a conformance suite against the spec in 71 commits: a trustworthy test world, interpreter conformance tests, and exhaustiveness and mutation guards that keep the suite complete as the language grows, reaching into the interpreter and the bundled pattern files themselves. It changes nothing the binary does — it is what stops the language shifting under a user's own patterns unnoticed.

5. 2026-07-23 – 2026-07-26 · 186 commits, 28846d1d9 → fd81e6778 run 03-implementation-04-patterns-as-first-c replay

   Patterns become first-class, user-authorable drivers

   The largest run of the pattern work — 186 commits over four days — executed plan 04: a person holding only the binary can now author and run a new driver. It deleted the closed binding layer (the Pattern enum, DriverRegistry, and related types), made --pattern <name|file.toml> the real selector with the driver flags as sugar, converted every built-in driver to TOML, and removed design mode up front so it could return at the end as two ordinary bundled TOML patterns with no design-specific Rust. It also froze pattern inputs into a content-hashed closure for run identity and derived the display from pattern shape — a net removal of about 15,100 lines of driver code by the successor plan's accounting. The merge on 2026-07-26 landed with three gate breaks, fixed by hand the same day.

6. 2026-07-23 · 3 commits, 35ccd2f8e → f2aadf54a session

   Fixes for regressions the pattern-conversion merges left

   A Claude Code session fixed two milestone-sidebar regressions the runs-and-patterns run had introduced, and made the merge resolver dispatch on markerless integrate_main conflicts.

7. 2026-07-26 · 50 commits, 00f7a8de0 → fecc3c7ee run 03-implementation-05-script-steps-and-br replay

   Script steps and branch keys join the pattern format

   A gantry run executed plan 05 in a day, 50 commits: a new script step kind lets a pattern run a user-supplied command as a node in the control flow — the engine executes it, journals its exit status and output, and replays recorded verdicts on resume — and the verdict-producing steps (gate, goal-check, script) gained their own if/then/else branch keys so the branch sits on the step that produced the signal. The conditional step was demoted to conditions no step produces, and the docs were reconciled with the shipped behavior.

8. 2026-07-26 · 6 commits, 02d59ff36 → 98ab8cf2b session

   First repairs after the first-class-patterns merge

   A Claude Code session repaired the three gate breaks the first-class-patterns merge landed with, fixed roster re-announcement when a unit's task catalog changes, resolved work-list bookkeeping from the active work-list context, and restored cold projection for runs recorded before the pattern language.

9. 2026-07-26 – 2026-07-27 · 77 commits, 0cdda59c6 → f8029fc41 run 03-implementation-06-one-world-no-driver

   One World: per-driver runtime branches collapse into shared steps

   A gantry run executed plan 06, the delta against what plan 04 actually shipped: one execution world with no per-driver branches. It finished three of its five milestones — spec-derived enforcement in place of the hand-maintained conformance scan, general build and goal primitives, and pattern parity including the collapse of the Ralph-specific path — then stopped resumably during the map-seam milestone after 77 commits. The branch was merged by hand, follow-up sessions repaired what the stop left open, and the remainder was written up as plan 07.

10. 2026-07-27 · 13 commits, 038b77bec → f4488fb7c session

    Hand repairs around the stopped One World run

    A Claude Code session worked alongside the One World run on the day it stopped: it made pattern branch targets structural on every step kind, fixed freezing and prompt resolution for contract-named child patterns, restored the bounded fix agent after a review turns the gate red, made a milestone restate its ledger-done sprints on roster re-announcement, and kept the attach socket bindable when the endpoint path exceeds sun_path. It then checkpointed the run's sprint-05 attempt, restored the honest dispatch detector, and wrote the handover for closing the map-world dispatch outside Gantry.

11. 2026-07-28 · 44 commits, 01b07ed71 → ff94568a9 run 03-implementation-07-finish-one-world replay

    One World finished: last runtime contracts gone, pinned runs resume

    A second run finished the One World work after the first stopped, executing plan 07 in a single day and 44 commits: it wrote the dispatch rules into the pattern spec and moved stage mapping into declarations, deleted the loop and goal-cycle runtime blocks and re-expressed their behavior as declared steps, made a pinned run resume cleanly, and widened compatibility coverage for pre-pattern runs. Merged 2026-07-28, closing the plan 04–07 family.

12. 2026-07-28 · 13 commits, 155716f67 → f9c536246 session

    The fan-out runtime dispatch closes into declared steps

    A Claude Code session executed its own conversion plan for the last big runtime dispatch: map's fan-out. It declared the fan-out roster as a generated-spec work-list source, ran the worker and per-unit gate through roster membership, made the classify pre-scan and the map-spec author declared step kinds, then deleted the fan-out runtime from the production world (about 330 lines out of map_pattern.rs) and stated the declaration-not-identity selection rule in the spec. The session also restored the display descriptor contracts lost in a sprint rewrite and fixed reproducibility-input replay in the host-target round trip.

13. 2026-07-29 – 2026-07-30 · 66 commits, 03681b27f → f8189391a run pattern-diagrams replay

    Pattern flow charts: static diagrams, interactive view, live overlay

    A second run executed the rewritten pattern-diagrams plan to completion in 66 commits: a generic lane layout over the typed pattern model (so the chart cannot disagree with the interpreter), static ASCII rendering of the shipped patterns, an interactive diagram view with navigation back to the pattern source, and a live overlay that shows a running pattern's position, with an extraction proof for later reuse of the drawing component. Merged 2026-07-30.

14. 2026-07-29 · 13 commits, 0fd3d8e7e → f36995bfd run pattern-diagrams

    First pattern-diagrams run stops after the diagram core

    The first run at pattern flow charts got through the generic diagram core — its first three sprints reached master in two partial merges — and was then stopped after 13 commits, never reaching the static charts or live overlay. The plan's byte-for-byte reference chart had proved to be the wrong verification target: a Claude Code session rewrote the plan around contract assertions, deleted the TX-02 specimen and its generator, and merged the rewrite (df90e987c) so a second run could finish the work.

15. 2026-07-30 – 2026-07-31 · 45 commits, 26a560581 → ff1d43cd3 run milestone-and-sprint-patterns replay

    gated-task-set retired; milestone.toml and sprint.toml ship

    A gantry run added discovery-time pattern inclusion — Gantry finds patterns when initializing the build system instead of relying on a fixed list — and shipped the gated inner unit as two named pattern files, milestone.toml and sprint.toml, retiring the gated-task-set name. The shipped set now reads as the vocabulary everything else already uses (build runs milestones, a milestone runs sprints), and users can override either file separately instead of forking one 660-line pattern. Both sprints finished; one interrupted attempt was discarded and re-executed, and the work reached master through two partial merges on 2026-07-31 after conflict resolution.

Stops, recovery, and the review loop

1. 2026-07-23 · 8 commits, 055340c47 → f2c7858d4 run regate-after-review-content-detect replay

   Re-gate detects review edits by content, not by changed paths

   A single-sprint gantry run fixed a violated invariant in the sprint pipeline: a review that edited a file the execute stage had already touched was judged to have changed nothing, so the re-gate was skipped and the sprint committed code the gate never ran. The failure was real — a prior run had merged a deterministically failing test to master this way. The run replaced the path-based change detector with a content-based one, so any review edit forces a re-gate before commit. One retry, merged the same day.

2. 2026-07-28 · 8 commits, 53ca40830 → ebc66a42b session

   Troubleshoot agent replaces investigate; replan route made reachable

   A Claude Code session implemented the recovery-ladder plans directly, about 2,500 lines across the engine. It made review's replan route actually reachable and gave every agent the run's history, replaced the investigate agent with the troubleshoot agent and reordered the recovery ladder, added a scoped revert behind review and a report path on terminate, seeded a resumed attempt from the troubleshoot handover, and stopped runs from halting over how an agent worded a signal it was right to raise — the fix the signal-robustness run later finished.

3. 2026-07-28 – 2026-07-29 · 65 commits, 90adcae7f → fc09db232 run source-axiom-and-change

   Source plan protected; observed plan diffs replace replan codes

   A five-sprint gantry run of 65 commits rebuilt how plan changes are detected and routed. It made the run's source plan — the file or prose Gantry was started with — a first-class protected artifact no agent may edit, collapsed the sprint- and milestone-review prompts into one general reviewer with edit rights at every altitude, and replaced the reviewer's self-reported replan and plan_impact codes with an observed plan-file diff that patterns route to a reviewer, planner, or troubleshoot agent as they choose. The last two sprints were retirement passes the run added to its own plan mid-flight, after milestone reviews found shipped surfaces — docs, smoke and demo paths, and the non-pattern review parser — still describing or accepting the old replan contract.

4. 2026-07-29 – 2026-07-30 · 58 commits, 0555b2e89 → e15188382 run ghost-process-reaping replay

   Run ownership, a durable process roster, reaping, and gantry stop

   A three-sprint gantry run built the cleanup layer after a workstation hit load average 111 with 97 orphaned agent process trees — one run had finished and left its agents alive, another logged its stop and then idled for 34 hours. The run made the run lock honest (a live owner is visible and blocks unsafe removal), added a durable per-spawn roster of agent process groups with pid-reuse protection, reaps every recorded group whenever the engine exits, and added a gantry stop verb plus guards against nested agent-launched runs.

5. 2026-07-30 · 20 commits, 015921606 → ef0a24bed run signal-robustness-and-stale-overri replay

   Blocked signals survive wording and stale prompts

   A single-sprint gantry run finished what a hand fix had started: a run must never hard-halt because an agent wrote its blocked signal as prose instead of the declared TOML line, and a signal must never vanish because the prompt describing it went stale. The run closed the six remaining defects from the original analysis and its review, unifying the two prompt-filling paths so the inner-unit execute and fix stages get the same generated channel contract the generic pattern path already had.

6. 2026-07-30 · 33 commits, 03a605d10 → fb63f0319 run generated-stop-cards replay

   Every stop gets a real reason, a durable record, and a generated card

   A two-sprint gantry run replaced the fixed-string stop message — nested interpreter frames that discarded the agent's own reason for refusing a task — with legible stops. Sprint one carried the real stop reason and its position through the stop path instead of dropping them; sprint two journals every stop durably and renders one shared card whose title and summary a utility model generates from the evidence in hand, so the operator reads what actually happened instead of format! plumbing.

7. 2026-07-30 · 26 commits, 118d233bb → fc2a92c75 run process-view replay

   gantry ps, a TUI processes panel, and MCP process data

   A two-sprint gantry run built the interface over the ghost-reaping run's data: the roster answers which processes belong to which run and sprint, and live /proc sampling supplies what they cost. Sprint one built the process data model and the gantry ps terminal report; sprint two added a processes panel to the build-run monitor and exposed the same rows through MCP. The roster stays a join key — resource usage is sampled live, never stored.

8. 2026-07-30 · 6 commits, 6a97992af → f16833bac session

   Process reporting moved off gantry list into its own ps verb

   A Claude Code session moved process reporting out of `gantry list`, where it had been added first, into the dedicated `gantry ps` verb that the process-view run then built on. The rest of the session's work was planning that shipped nothing.

9. 2026-08-01 · 21 commits, 0d1f74a1b → f2ae33001 run proceed-without-killing-the-run replay

   Proceed from a stop without killing the run; assistant renamed

   A two-sprint gantry run made the engine's existing proceed path reachable from inside the app. A stopped run used to offer only investigation launchers and Stop, so the operator's real procedure was kill the run and gantry resume from the shell; now a proceed choice on the stop prompt re-enters execution directly. The second sprint renamed Gantry Agent to Gantry Assistant across the surface.

10. 2026-08-02 – 2026-08-03 · 53 commits, 004723998 → fcd552065 run troubleshoot-before-halt replay

    No halt until a troubleshoot agent tried; routing is pattern policy

    A four-sprint gantry run of 53 commits consolidated the recovery work into one thesis: Gantry never halts until a troubleshooting agent has been dispatched and failed, and which failure gets which treatment is declared in pattern TOML, not hardcoded in the engine. It built the shared troubleshoot ladder for every failure class, a halt hook with policy routing, pause controls, and a cleanup sprint that retired the plans this one absorbed. The run itself stopped once mid-build when a milestone review declared a halt on sprint 02, then was resumed and finished all four milestones.

11. 2026-08-02 · 15 commits, 1718380ba → f5ed5b7bf run resume-is-a-fresh-assessment replay

    gantry resume re-assesses the run instead of replaying an old stop

    A single-sprint gantry run established the resume contract: every resume re-derives the run's state from the ledger, worktree, and halt conditions, makes a new recovery attempt with a fresh budget, and when it stops again records the true current reason durably. It was written against a real failure — a run whose operator fixed the stash a stop named, resumed three times, and was shown the same stale card each time while the actual current stop was never recorded. The run also added one automatic retry for resumable headless stops.

Run measurement and fleet statistics

1. 2026-07-24 · 28 commits, 070638b53 → eddd1cb39 run active-run-duration

   Run durations count active time, not idle wall clock

   A gantry run replaced start-to-finish wall clock with an active duration everywhere a run's length is derived or displayed, the live run timer and the statistics output included. The measure unions the journal's stage intervals, excludes the spans where a surfaced stop sat waiting for a human to answer, and newly journals usage-limit parks so future runs can subtract that sleep too; the run's plan measured the distortion at 1,028 reported wall-clock hours across the collected corpus covering roughly 640 hours of actual work. The distorted wall-clock field was deleted outright rather than kept beside the new figure. Two milestones, both green, in a single day.

2. 2026-07-29 – 2026-07-30 · 63 commits, 0dae9073d → fda10880f run fleet-stats-in-the-binary replay

   gantry stats: native fleet statistics, printed and as JSON

   The fleet-stats plan took two runs. The first (b4e39908452f) built a sound data layer and printed dashboard, then drifted into building an out-of-scope interactive TUI and was stopped and abandoned before merge. After a post-mortem and a full plan rewrite, this second run recovered the first attempt's gate-green foundation from its branch, ran the corpus reconciliation immediately — before any presentation work, the ordering the first attempt got wrong — and finished the printed dashboard, the JSON output, opt-in reconciliation stats, and the docs. The result is `gantry stats`: any installation can now answer how many runs it has, what they cost, how long they take, and where the money goes, from the binary alone, without the private Python analysis tier. Three milestones, all green.

The Gantry Assistant and agent orientation

1. 2026-08-01 · 33 commits, 0263dc084 → fba61b2a0 run agent-orientation-in-the-binary replay

   gantry agents: an in-binary orientation manual for coding agents

   A gantry run added `gantry agents`, a manual embedded in the binary for the coding agents users point at a fresh install: a top orientation page with the mental model of a run and a topic index, per-topic pages served as `gantry agents <topic>`, live project context in the output, and `gantry agents init` to set up AGENTS.md. Three milestones — the embedded manual, discoverability and truth gates, and the init flow — all green in a day.

2. 2026-08-01 · 16 commits, 185bb96f4 → d3f8dcc8b run stop-in-the-assistant-pane replay

   Run stops render in the assistant transcript, not a modal

   A single-sprint gantry run removed the full-screen stop modal: a stop is now a message in the assistant transcript, rendered like a blocker — nothing to dismiss, the text stays on screen and selectable, with the composer directly beneath it at exactly the moment you want to ask what happened. The whole overlay path (StopModal, Overlay::Stop, its scroll and mouse handlers, the stopped-phase draw branch) was deleted rather than disabled, retiring the overlay's selection off-by-one with it.

Licensing and the demo edition

1. 2026-07-22 · 12 commits, 166b70b04 → fa3ecc099 session

   Rewrote the EULA and Source License, added a versioning policy

   A Claude Code session reworked the legal texts: it dropped the anti-compete clauses, rewrote the Source License to permit reading and discussion while forbidding forking, moved binary redistribution into the EULA's domain, renamed LICENSE to SOURCE-LICENSE with a LICENSE index file, set the copyright holder to Martin Eriksson, and declared the repo-root copies canonical with web/app/legal a clone. It also added the SemVer versioning policy with a per-surface change catalogue and documented the pre-launch release re-cut convention. This license pair was replaced wholesale by the PolyForm adoption on 2026-07-30.

2. 2026-07-30 · 5 commits, 471457a2c → c32054480 session

   Adopted the PolyForm Internal Use License 1.0.0

   A Claude Code session replaced the homegrown SOURCE-LICENSE/EULA pair with one standard license plus a sale document: LICENSE is now the verbatim PolyForm Internal Use License 1.0.0 with a gate test pinning its SHA-256, NOTICE and TERMS-OF-SALE are new, and every release artifact ships the same four legal files, served by the site at /license and /license/terms. The download page now states the internal-use grant, and the third-party notices were regenerated for the current lockfile and synced with the canonical root copy.

3. 2026-07-31 · 6 commits, 4ed9c696c → d08ad1d23 session

   Hardened the demo gate: signed check responses, no env override

   A Claude Code session closed a bypass in the demo edition's three-build allowance: the demo binary now verifies a cryptographic signature on the licensing response it receives, and the environment variable that could retarget the licensing call at runtime is gone, so the allowance cannot be lifted by anything the holder of a demo build controls.

The CLI surface, declared in one table

Every verb, flag and enumerable inventory the binary holds, stated once and gated against drift.

1. 2026-07-30 – 2026-07-31 · 79 commits, 0007c1912 → 9895bb374 run reference-from-source replay

   CLI verbs and flags move into one declarative specification table

   A gantry run replaced hand-written CLI parsing with a declarative specification table — every verb, flag, alias and help line stated once in one 944-line table and dispatched from there — and added a deterministic exporter that reads every enumerable inventory the binary holds (config settings, CLI surface, patterns, agent prompts, harnesses, MCP tools, menus, stop vocabulary) into a versioned dataset. The gate now fails when the code and that dataset disagree, so a stated fact can no longer rot the way the hand-transcribed tables it replaced had. Four milestones, all green; the run's resume was interrupted near the end and its merge was finished by hand.

2. 2026-08-01 · 5 commits, 4e85bbefe → 7c8fb229f session

   Retired flag spellings dropped from the CLI

   A Claude Code session removed the flag spellings that had already been superseded, along with the status handling that existed only to accept them, so the CLI advertises one spelling per option. The comments in the bundled pattern files were rewritten as short markdown at the same time.

Run records, disk space, and lifecycle

1. 2026-07-27 · 51 commits, 01008d306 → f5932242f run reclaiming-run-artifact-disk-space replay

   gantry prune and purge reclaim transcript and worktree disk space

   A gantry run built the disk-space reclamation commands from the hand-written plan: `gantry prune` rewrites a run's transcripts, keeping everything the agent itself produced (messages, reasoning, tool invocations, edits) while capping the repository-sized payloads — file snapshots are replaced by markers carrying the git blob SHA, command output is truncated to head and tail — and `gantry purge` deletes transcripts outright while preserving the run's record (ledger, plan, about card, usage sidecars) so the run stays listable at the summary level. Both take `--dry-run`, `--yes`, `--all`, and `--older-than`, generate a missing usage sidecar before discarding anything, and detect already-done work so a second pass reports zero. A third milestone added worktree cleanup for the leaked disposable worktrees, the larger number on disk. Three milestones, all green, merged the same day.

2. 2026-07-29 · 14 commits, 0e09acd80 → ea34f543c run handover-partial-merge-routine-triplet replay

   Partial merge collapsed into one routine that works for every pattern

   Before this, partial merge existed as three near-duplicate routines keyed by pattern name (map, goal, ralph) — two of them identical except for four lines — while build, the default pattern that is actually run, had no partial merge at all: `gantry merge` on a build run refused and exited. A gantry run executed the hand-written handover (which had itself said the job was small enough to do by hand) and collapsed the triplet into one pattern-independent routine that merges the branch tip and does not sweep uncommitted work in, deleting the closed three-variant enum, the per-pattern target finders, and the tests defending the asymmetry. Build runs can now land finished work partially like every other shape.

3. 2026-07-31 · 2 commits, 382c2007f → ed3fd484e session

   Run short names made permanent in the registry

   A Claude Code session planned and implemented permanent run names: a run's short name is now fixed in the registry for its lifetime. The same change made the about.md agent product merge field-by-field onto the sidecar on disk — non-empty fields overwrite, empty ones keep the current value — instead of replacing the whole document and destroying the description, sprint cards, and gate summary.

4. 2026-08-01 · 15 commits, 0f09e3a18 → fc1ddaf89 run quiet-gates-and-verified-semantic replay

   Resume reaps orphan gates; merge breaks need a reproduced red

   A single-milestone gantry run fixed the three failures behind the hermeticity run's false merge stops. Run entry now sweeps the process roster and reaps the run's recorded orphan processes before touching the worktree; the per-repo gate lock is held by the spawned gate command itself, so it outlives a dead engine for as long as its gate child runs; and a semantic merge break is declared only after the red reproduced, with the stop card stating what was red.

Maintenance and the release cut

1. 2026-07-22 · 42 commits, 053712d2c → faa65d7ad run screencast-consolidation

   About 9,000 lines of screencast production leave the source tree

   A gantry run retired the narrated screencast series — roughly 9,000 lines of Rust and its supporting scripts, data and documentation — and consolidated what survived into a single timelapse flow, renamed across the command surface, the timing profile and the code. None of it is compiled into a distributed build, where the whole screencast surface is stripped; the deletion reaches a customer only through the source-review archive, which is that much smaller for it.

2. 2026-07-29 · 6 commits, 1d0b536de → f31f3495e session

   A day of fixes: resume stamp, sidebar levels, re-gate coverage

   A Claude Code session landed a set of unrelated fixes: the pattern-language compatibility stamp is enforced at resume rather than on every read; the build-commit stamp tracks HEAD across incremental rebuilds; work-list insertions are placed beside their siblings; each sidebar row is drawn from its node's declared level rather than inferred from the tree's shape; the TUI stops calling the test suite "the gate" in user-visible text; and whole-tree re-gates no longer silently skip milestone-layout runs.

3. 2026-07-30 · 10 commits, 0c30451ee → f0465c296 session

   Prompt text frozen per run; stash guard scoped to the run's worktree

   A Claude Code session froze a run's prompt text at start the way its pattern closure is frozen, and fixed the pre-existing-stash guard that had been blocking every resume by scoping it to the worktree's own branch instead of the whole repository's stash. It also kept the legacy bare-pid run-lock owner record readable, stopped a project rename from duplicating the fleet corpus, tightened two agent prompts, re-baselined the milestone 01 help fixtures onto merged main, and recorded the pattern-drivers run's repair pass.

4. 2026-07-31 · 17 commits, 0116d2b34 → fd5524981 session

   A test-suite purge across all of Gantry, and the policy behind it

   Roughly two thirds of Gantry's tests were deleted across both suites — the Rust suite from about 3,300 to about 1,200, the Rails suite from 840 runs to 317 — cutting the default behavioural tier from 33s to 4.5s and removing around 16,000 lines from `src/` in one pass alone, most of it inline test modules that never reach the binary but do reach the source-review archive, along with the production helpers whose only callers were those tests. The work ran deliberately outside Gantry, whose own pipeline is wired against deleting tests, and continued into a follow-up run that restored the deletions an audit judged wrong. What the binary does is unchanged; what ships with it is the policy the purge produced, now in the compiled-in prompt set — a test is justified only by a plausible regression it, and nothing else in the suite, would catch — so agents building under Gantry stop accreting tests that pin wording or freeze counts.

5. 2026-07-31 · 7 commits, 0bf945b90 → ead4e5dc0 session

   Stats dashboard redrawn; ledger-row and help-pin merge fixes

   Hand and agent-session work across one day: the printed `gantry stats` dashboard was re-laid as an aligned, box-drawn render; pending sprints no longer borrow an earlier milestone's ledger row; and the boundary-scoped --help byte pins that had blocked a merge were first re-baselined and then retired, with the block written up. A stray piece of uncommitted work was also committed by hand.

6. 2026-08-03 · 3 commits, 26c3da644 → 60720e15e session

   The build-run assistant is named Gantry Assistant in its own prompt

   A Claude Code session finished the assistant rename where it was still outstanding: the compiled-in prompt the build-run assistant is given now calls it Gantry Assistant, matching the name the interface had already adopted.

7. 2026-08-04 · 2 commits, 234b077d7 → 39d92b626 session

   Release 0.2.0 cut

   Hand work cut the 0.2.0 release and added the docs/manual tree to the shipped source archive.