skip to content

Releases

0.2.2

Records and Commits

Another week, another update to Gantry. We now use git more consistently and use commits as checkpoints throughout agent sequences. Several additional minor changes.

568 commits by Gantry runs

96% of the release

22 commits by non-Gantry sessions

4% of the release

590 commits 11 entries 6 sections

Gantry 0.2.2 covers the four days from the 0.2.1 release to the 2026-08-14 cut: 590 commits in 11 units of work — 5 gantry runs contributing 568 commits, and 6 hand or interactive-agent sessions and standalone commits contributing the other 22.

Read this before upgrading. Runs started on 0.2.1 or earlier cannot be resumed by this binary. A run created before patterns became first class pins a driver-shaped payload in its pattern.toml — kind = "milestones", "map", "goal", "loop", "ralph", or "design" — and 0.2.2 refuses to resume it rather than guess at the translation. The run's artifacts are left intact and nothing is destroyed: finish the run with the 0.2.1 binary, or abandon it with gantry remove and start it again. Two further removals are in the same release. --ralph is gone, along with --max-iters and --quiesce-after; a standing loop is now an authored pattern selected with --pattern <name|file.toml>, and the bundled ralph.toml has been withdrawn from the shipped set. --jobs is gone too. And every bundled pattern was rewritten in this release, so a fresh run of an unchanged plan resolves to a different run id than 0.2.1 would have produced — runs already on disk keep their own frozen copy of the pattern they started with.

The release is named for its largest run. records-and-commits reformed how a run records what it did, on five rules: Gantry makes every commit and agents make none; every agent session that changes the tree is committed when the session ends; a dirty tree is never a signal the engine reads; run records are append-only and identified by attempt; and committed work is never destroyed by the engine. What that means concretely is that the executor's changes, the reviewer's edits, and each repairer's fix are now separate commits attributed to their own sessions rather than folded into one "task complete" commit, and that sessions and steps have durable identities that record paths, transcript names, and commit trailers are keyed on — so a unit's five gate runs no longer overwrite each other's evidence. The orchestration record also moved: .gantry/<plan>/ is now backed by its own nested book repository rather than being tracked in your project's repository, which is why a finished run is inspectable without orchestration commits being merged into your history, and why an abandoned run's records now survive it. gantry extract-book promotes the legacy cohort whose records were committed into the primary repository before book repositories existed, and gantry extract-book --untrack removes those legacy paths afterwards — dry-run until you pass --yes.

The largest run by commit count shipped no behaviour at all. comment-style-repo-wide applied the project's comment style guide across the tree, rewriting or deleting comments in 212 source files without changing what any of them do. It is in this document because a source-review customer receives src/ whole and reads those comments, and because the agent prompts the pass rewrote are compiled into the binary. If you are upgrading for behaviour, there is none here.

every-change-is-reviewed finished a design that had been stated but not built: any agent that may edit files may edit plan files, and every plan-file change dispatches a review session of its own whose only job is to judge that diff against the source plan you actually wrote. Because the review always happens, the editing side needed no restriction — a reviewer may rewrite the brief it is judging and record the unit complete in the same session, and the plan-change review is what catches a wrong call. Whether a role may edit briefs is per-pattern configuration rather than engine law. Withheld drafts are now kept as commits under refs/gantry/draft/, and reclamation learned to discover and age out that namespace alongside refs/gantry/discarded/.

Two smaller runs worked on what the monitor tells you. every-card-keeps-its-duration made the rule uniform — every card in the activity feed shows how long it took, ticking while it runs and frozen at its final value when it closes, whether or not an agent was involved — where before a merge card could sit on screen for minutes with nothing in its corner. handover-merge-blocked-by-dirty-home-checkout came out of that run's own failure: it finished green, could not merge, and told the operator to resolve a merge conflict that did not exist. The real cause was staged uncommitted work in the shared checkout, which git refuses to merge over regardless of what the branch touched, and the run now says so instead.

Run records and commits

How a run records what it did — session and step identity, one commit per session, and the run's record moved into its own repository.

  1. 155 commits, bfc4f4bae 1b5d636bc run records-and-commits

    Every session is a commit, and the run's record is a repository

    A gantry run reformed how a run records work and state, against five rules: Gantry makes every commit and agents make none; every agent session that changes the tree is committed when it ends; a dirty tree is never an engine signal; run records are append-only and attempt-identified; and committed work is never destroyed by the engine. Sessions and steps became first-class identities minted before dispatch and embedded in record paths, transcript names, and commit trailers, which is what stopped a unit's repeated gate runs from overwriting each other's logs. The executor's changes, the reviewer's edits, and each repairer's fix are now separate commits attributed to their sessions instead of one folded "task complete" commit, and the reviewer reads a commit range rather than an uncommitted working-tree diff. The orchestration record moved out of the primary repository into a nested book repository under `.gantry/<plan>/`, so a finished run is inspectable without orchestration commits merged into your history and an abandoned run's records survive it; `gantry extract-book` replays the legacy committed cohort into book repositories, and `--untrack` removes the old tracked paths after a dry-run report. Three removals land here: `--ralph` with `--max-iters` and `--quiesce-after`, the bundled `ralph.toml`, and `--jobs`; and a run whose `pattern.toml` pins a legacy driver-shaped `kind` is refused on resume with its artifacts intact rather than translated by guesswork.

  2. ddd316ec9 commit

    Snapshot protected paths from the tree, not from HEAD

    Hand work corrected where the protected-path snapshot reads from. Taking it from `HEAD` rather than the working tree meant a protected file's guarded content could differ from what was actually on disk when the step ran, so the comparison that detects an illegal write to the source plan was made against the wrong bytes.

  3. 14 commits, b6c223c4f 4327ab098 session

    Follow the record layout through the prompts and paths that missed it

    An interactive agent session cleaned up after the records reform, where several call sites still named record paths the new layout had moved. Plan agents could no longer author into the run record; a nested unit's authors wrote to the parent's record directory; a goal cycle's stub took record paths the prompt did not carry; and the protected-path snapshot looked somewhere other than where the record now lives. The same session made the map spec's support-file paths one contract instead of two spellings, stated and implemented the post-merge rule for a file the run itself authored, and made `gantry` tell the operator which config files are theirs rather than Gantry's.

Comments across the source tree

  1. 363 commits, 1d8a11871 6b33183f2 run comment-style-repo-wide

    Apply the comment style guide to the source tree

    A gantry run brought the repository's code comments into line with the project's comment style guide, rewriting or deleting comments across 212 source files and the agent prompt set without changing behaviour anywhere. The corpus it started from was roughly 23,400 comment lines written by agents with no guidance; the pass deleted doc comments that only paraphrased the identifier they sat on and kept the ones carrying a fact the code cannot state — an invariant, an external constraint, a policy boundary. This ships nothing you can run, and it is here for two reasons: a source-review customer receives `src/` whole and reads those comments, and the prompts the pass rewrote are compiled into the binary.

Plan changes and their review

  1. 40 commits, 4ec6618be 49a40e2b9 run every-change-is-reviewed

    Every plan-file change gets a review session of its own

    A gantry run built the plan-change review that an earlier release had stated as a success criterion and left unbuilt. Any agent that may edit files may now edit plan files, and Gantry dispatches a separate review session whenever it observes those files change, judging the diff against the source plan the operator wrote — the source plan itself remains the one file nothing may write to, and writing to it halts the run. Because that review always happens, the editing side needed no restriction: a reviewer may rewrite the brief it is judging, move the remainder into later briefs, and record the unit complete in one session. Whether a role may edit briefs became per-pattern configuration with a permissive default, and a pattern that declares the restriction gets a recorded refusal rather than a silence. Withheld drafts moved from serialized `.diff` files at a fixed path to commits under `refs/gantry/draft/`, and worktree reclamation learned to discover and age out that ref namespace alongside `refs/gantry/discarded/`.

The activity feed

  1. 2 commits, 54b5661b9 52f7142f9 session

    Name the gate and support cards for what they did

    Hand work fixed cards that all read "Testing" regardless of which gate produced them, gave the merge-resolve gate a card that announces itself, and renamed the support cards after the work they actually performed.

  2. 5 commits, a787d0cb4 d461bb122 run every-card-keeps-its-duration replay

    Every card in the feed shows how long it took

    A gantry run made the activity feed's corner timer uniform. Only agent cards ticked before, because only the agent supervision loop emitted the per-second beats the card's elapsed counter depends on; a merge card could sit on screen for many minutes showing nothing but the word `Merge`, and numbers that were on a card while it worked could vanish when it closed. Merge, test, resolve and note cards now tick while they run and keep their final value when they close, whether or not an agent was involved.

Finishing a run

  1. 5 commits, b6339e0e7 636bfa533 run handover-merge-blocked-by-dirty-home-che replay

    Tell a blocked merge apart from a merge conflict

    A gantry run fixed a misdiagnosis its predecessor had walked into. The feed-durations run finished both sprints green, passed its pre-merge gate, and then stopped with a card reading "Local Changes Blocked Merge" that told the operator to resolve a merge conflict by hand in the partial-integration worktree — but there was no conflict. Git had refused the final merge because the shared checkout carried staged uncommitted work, which it refuses to merge over regardless of whether the merge touches those paths. The two states are now classified apart and the run reports the real precondition rather than sending the operator to resolve a conflict that does not exist. The failure mode was not a regression from the records reform; it had always been reachable and nobody had left staged work in the checkout at the moment a run finished before.

Maintenance and the release cut

  1. 75d740045 commit

    Put the end-to-end test tier where it runs by itself

    Hand work restored the end-to-end tier after the records reform left parts of it wired into the wrong gate stage, which also corrected the pattern interpreter and the smoke stubs the tier exercises.

  2. 2 commits, 3eaf514e9 f705c951b session

    Let a gitignored .gantry keep its runs, and re-announce the roster on resume

    Two hand fixes. A checkout that lists `.gantry` in its own ignore rules no longer halts the runs it holds, which the move to book repositories had made a reachable configuration. And a resumed run that replays its announce-roster step announces the roster again instead of leaving the monitor without one.

  3. 2 commits, 7b83643f6 df7f4347d session

    Release 0.2.2 cut, and the redaction anchor that blocked it

    Hand work bumped the crate version and regenerated the reference dataset the binary exports about itself, which carries the version string. The cut then aborted in its first phase: the script that redacts withheld documentation references from the agent-prompts README — which must run on the stripped tree before the build, because that file is compiled into the binary — pinned the exact link anchor of a docs heading, and the records reform had renamed that heading when it replaced the config mirror's provenance manifest with git history. The redaction silently stopped matching and the script's own guard caught it. It now matches any anchor on that link rather than the one spelling, so a future heading rename cannot abort a cut the same way.