Recovery Pass
Recover Clean Empty Sprint Attempts
No-op sprint work is judged by the real gate and recorded through durable completion state.
0 milestones 4 tasks 10 agents
2 plan 5 execute 5 review
153k peak context
127k median execute
56m 36s total 10m 1s per task
2m 25s plan 29m 54s execute 13m 10s review
34 edits 307 commands
codex harness
This run fixed a resume failure where Gantry could ask a fresh executor to rebuild work that was already present. The executor would correctly leave the tree unchanged, but the old guard treated that clean empty result as a run-killing failure before asking whether the sprint's own gate was already satisfied.
The build separated the problem into durable completion state, gate-green reconciliation, red-gate recovery, and end-to-end resume coverage. The original sprint-driver files from this run have since been replaced by the generic pattern interpreter, but the same contract is visible in the shipped sprint pattern: a clean green no-op records a done row, while a clean red no-op enters the recovery ladder.
How this walkthrough is structured
Feature
What did the run build and ship?
The old driver code is gone, but its behavior survives in the shipped sprint pattern and interpreter as gate-grounded no-op completion plus bounded recovery for empty failed attempts.
Build
How did Gantry structure the work?
The run split no-op recovery into ledger durability, acceptance, failure routing, and proof, with the only retry pressure landing on the final regression pass after review.
Completion Ledger
2 agents 8m 49s wall time 127k peak context
The exact driver files this sprint edited are no longer present, but the durable ledger rule remains in the current run engine. Normal sprint completion records a done row through engine-owned bookkeeping, and finalize still sweeps trailing ledger state before merge so a completed sprint is not lost as a side effect of cleanup. The shipped pattern documentation now treats ledger done-ness as the uniform completion predicate.
This sprint carried the root cause rather than the visible alarm: a completed sprint's verdict had to become committed state. That was a compact boundary for a fresh agent because it did not need to decide what a no-op meant yet; it only had to make normal completion survive restart and reset. The run stayed green at this boundary, which matters because later reconciliation work could then rely on a cold ledger instead of uncommitted bookkeeping.
Green Reconciliation
2 agents 17m 28s wall time 153k peak context
The live sprint pattern still exposes this behavior directly. After a green gate, an unchanged task can take the `inner-unit-green-noop` branch to `record-noop-done`, with an auditable note that says the work was already satisfied and recorded done. The pattern interpreter implements that step without review or a new task commit, then clears stale task state so resume sees the sprint as complete.
With durable done rows available, this sprint could focus on the acceptable empty attempt: clean unchanged work is not failure by itself when the real gate is green. The brief gave the agent a narrow decision boundary, accept only the gate-proven case and record it through the same committed completion path. It landed without recorded repair, so the contract from the first sprint held under the added branch.
Red Recovery Routing
2 agents 8m 19s wall time 110k peak context
In today's pattern flow, a red post-execute gate goes to the troubleshoot route rather than the no-op done branch. The recovery plumbing records retry notes through the same inner-unit operations used by other under-delivered sprint work, resets only when the route calls for a retry, and halts through the existing blocked or exhausted recovery shapes. The no-op branch therefore has no separate human-decision state in the current tree.
This sprint completed the other half of the gate split: a clean empty attempt against a red or unusable gate must stay loud, but it should spend the existing recovery budget instead of inventing a terminal stop. The cut was agent-sized because the green path already existed, leaving only the under-delivery branch and its diagnostic note. It stayed green, showing that the old safety purpose could be preserved through existing recovery machinery.
Resume Regression Coverage
4 agents 11m 14s wall time 115k peak context
The original test file has been refactored away, but the regression intent is still represented in current tests around the interpreter and run reset behavior. There are tests for green no-op completion without review or task commit, stale review verdicts not steering an already-complete no-op into retry, troubleshoot retry note plumbing, and resume reset scope. Those tests now guard the pattern-level implementation rather than the old sprint-driver module.
The final sprint was asked to prove the pieces together from the outside: completed rows, green reconciliation, red recovery, and resume had to compose as one lifecycle. Review did not simply pass it through; the run retried this unit after a review note, so the stress landed exactly where the integration proof lived. The second pass came back green, and the run then stopped at merge before any merge facts were recorded.