Sprint Recovery Flow
Reviewer findings became retryable, resumable sprint recovery instead of a hard stop.
0 milestones 6 tasks 14 agents
2 plan 6 execute 6 review
244k peak context
169k median execute
3h 49m total 32m 42s per task
3m 9s plan 2h 10m execute 1h 19m review
111 edits 634 commands
codex harness
This run turned an incomplete sprint review from an endpoint into a routed recovery decision. It split the work into the review contract, persisted attempt state, retry execution, current-brief replanning, operator visibility, and scenario coverage, so each fresh worker handled a separate layer of the recovery ladder.
How this walkthrough is structured
Feature
What did the run build and ship?
The current tree still carries the recovery contract in the pattern runtime, event history, status surfaces, and scenario tests, though the original build-driver files have since been replaced.
Build
How did Gantry structure the work?
The cut built the recovery ladder from verdict shape through persistence, action, visibility, and coverage, with only the audit surface needing an extra gate pass.
Review Disposition Contract
2 agents 16m 47s wall time 144k peak context
The exact files from this sprint no longer stand in their original locations, but the contract survives in the shipped pattern definition. Sprint review now writes a declared scope value with complete, retry, or blocked as legal outcomes, and malformed or missing producer output is treated as a control-flow problem. The generated reviewer instructions also require the note file when retry or blocked is selected.
This sprint carried the smallest prerequisite: a reviewer had to produce a structured decision instead of a loose incomplete reason. That boundary was suitable for a fresh worker because it touched prompt policy, result parsing, and compatibility, but not the recovery loop that would consume the verdict later. The ledger and facts show it landed cleanly, so later work could depend on a stable review signal rather than infer intent from prose.
Durable Recovery Attempt State
2 agents 24m 59s wall time 169k peak context
The original job-pin storage has been folded into the pattern runtime, but the durable idea is still visible. Recovery attempts are represented by a named counter, and per-attempt verdict and note channels live under run state rather than in local process memory. Resume code seeds a restarted task from those durable artifacts so the next execute attempt can receive the latest recovery note.
This sprint made recovery state durable before any retry loop could spend it. The brief kept the worker on persistence: consumed attempts, latest disposition, latest note, note history, and resume distinctions. It passed without recorded recovery, which left the next sprint with a persisted counter and note trail instead of an in-memory assumption.
Retry Recovery Loop
2 agents 27m 59s wall time 202k peak context
The retry route is now expressed by the milestone and sprint patterns rather than the old driver module. A retry verdict stores the note, resets only the project tree, reruns the sprint, and stops with a handover when the budget is exhausted. Current tests exercise rollback, note injection, bounded retries, and the absence of the old immediate incomplete halt.
This was the first executable half of the ladder. The worker had to roll back incomplete work, pass the reviewer note into a fresh execution of the same brief, and stop after the shared budget was spent. The cut stayed green because the sprint consumed the earlier contract and state rather than redefining them while building the retry route.
Current Sprint Recovery
2 agents 59m 3s wall time 244k peak context
The specific current-sprint replanner from the old build driver has not survived as a distinct module in the current tree. The present pattern runtime instead routes plan changes through declared work-list replanning and rejects the retired replan verdict in the old review parser path. What remains from this sprint is the separation between retrying the active unit and preserving scoped plan edits before later execution relies on them.
This sprint carried the other branch: recovery by changing the current brief before rerunning it. Its brief was larger because it had to isolate a planning-altitude worker, protect production code, commit only plan edits, advance the rollback baseline, and then execute the revised brief. It still landed cleanly, which says the prior recovery state and rollback machinery gave the worker enough structure for the harder branch.
Audit And Forward Replan Coexistence
2 agents 52m 41s wall time 241k peak context
Recovery attempts are still durable events and still reach the current operator surfaces. History serializes attempted recovery with disposition, note, terminal halt state, and whether it was a current replan, while stats and terminal rendering turn those records into retry, replan, or halt rows. The current code also keeps future-work replanning on a separate declared input path, so recovery records do not collapse into ordinary plan-impact edits.
This sprint connected the recovery ladder to the surfaces operators read, while keeping it separate from success-path replanning of later work. It is the only unit whose facts show the gate running again after review, placing the stress at the visibility and coexistence boundary rather than inside the core retry mechanics. The sprint still finished green, so the extra pass appears as verification of the presentation layer, not a failed recovery attempt.
Recovery Scenario Coverage
2 agents 37m 25s wall time 191k peak context
The original smoke scenarios have been heavily rewritten, but their coverage survives in the pattern interpreter tests and current smoke harness. Tests now cover review retry routing, bounded exhaustion, stale verdict handling, resume note seeding, troubleshoot retry notes, and future-work replanning beside the recovery path. That means the feature is no longer isolated in the files this run first touched, but the behavioral contracts are still asserted in the active suite.
The final sprint was a proof pass over the full behavior rather than a new policy layer. Its job was to exercise realistic paths for replanning, retrying, cap exhaustion, autonomous brief repair, bar-lowering protection, resume, and coexistence with future-work replanning. It passed cleanly, closing the run by checking the assembled ladder as Gantry would actually drive it.