Brief Repair and Prompt Truth
Reviewer Brief Authority
The build loop now records rejected attempts, lets review repair bad briefs, and bounds retry recursion.
2 milestones 0 tasks
8 plan 11 execute 13 review
2h 57m total
This run tightened the ordinary build loop around failed task attempts and scoped plan files. It split the work between attempt history plus brief repair, then convergence limits plus prompt truth, with green gates throughout and replan stages recorded outside sprint attribution.
How this walkthrough is structured
Feature
What did the run build and ship?
The surviving tree carries the sprint pattern's reviewer brief contract, attempt ceiling route, stop-record wording, and mirrored reference data.
Build
How did Gantry structure the work?
The cut separated task memory from convergence policy, so the first milestone could make retry context and brief repair trustworthy before the second milestone changed how retries stop.
Milestone 1
Attempt History Repair
The feature side is mostly folded into engine and prompt surfaces. Current `config/patterns/sprint.toml` still tells review to correct scoped plan files when a brief overlaps remaining run-plan files, and the stop text now relies on stop-record evidence rather than state-relative paths. The digest's nested commits also touched environment assembly, plan-change detection, and prompt text, but the measured survival tier keeps only the pattern and reference-data files in its final reach.
This milestone carried the retry loop's self-knowledge and the reviewer's authority over bad briefs. Its boundary was broad but coherent: rejected attempt records, later prompt exposure, task scoping, brief repair, and plan-change observation all belong to whether the next fresh worker receives true context. The run facts record green gates and no recovery for this part, so the stress shown in the record is planning churn rather than a red implementation gate.
Attempt History Contract
This sprint changed environment and agent plumbing so attempt context can be rendered into worker prompts. That work has since been revised by later commits, so its contribution is no longer isolated in the final measured reach. The current tree still contains attempt fields in the run identity journal and prompt environment machinery that later work uses.
The digest gives no sprint brief for this row, so the boundary has to be read from the row name, the milestone scope, and the commit. It was a narrow engine task: carry rejected attempt outcomes into the environment read by later agents on the same task. The recorded task attempt finished green, with no retry or recovery attributed to it.
Brief Repair Duty
The reviewer prompt and `config/patterns/sprint.toml` now say that an over-scoped brief is corrected in the scoped plan files rather than accepted as reduced work. The recovery prompt also names brief faults as material for handover or retry. Later edits preserved that contract while tightening stop wording and retry routing.
This sprint gave the reviewer and recovery rung their brief-repair duty before plan-change observation changed. That made it a prompt and sprint-pattern task rather than an engine rewrite, which a fresh worker could hold as a contract update. The ledger records a green first attempt.
Plan Change Observation
`src/engine/run/generic_pattern.rs` now treats declared output records under invocation state as outside observed plan-change review. The reference data mirrors the active pattern vocabulary. The current tree still has tests around declared output handling and plan-file observation.
This sprint isolated a subtle boundary: declared outputs and invocation state must not look like source-plan edits. That let the plan-change reviewer stay focused on real run-plan changes instead of agent bookkeeping. Its gate stayed green, and the row needed no recovery.
Overscoped Brief Rehearsal
The final surviving change from this row is the stop text and mirrored reference data that say stop records carry declared output documents. The broader rehearsal evidence is not preserved as an isolated product file in the current tree. What remains is the pattern wording that later stop-record cleanup refined again.
This was the milestone rehearsal: a real multi-task build had to prove that brief repair replaced a loop over the same bad instruction. It sat after the contract and observation work because it depended on both. The commit came from review, which means the final accepted change was a reviewer correction inside the rehearsal boundary.
Milestone 2
Convergence and Prompt Truth
The current tree carries this milestone most visibly in `config/patterns/sprint.toml`: retry verdicts route through `check_attempt_ceiling`, stop notes name outcomes rather than paths, and prompt references describe the resolved gate contract. The generated reference data and website reference copy mirror those pattern and prompt contracts. Some documentation-only edits from the milestone have been rewritten since.
This milestone picked up after retry history existed and changed when recursion is allowed to continue. Its boundary grouped attempt ceilings, gate resolution, stop-note cleanup, prompt catalog truth, and a final rehearsal because each one checked whether agent-facing claims matched engine behavior. The run facts show green gates and no recovery, with replan stages again recorded only at run level.
Attempt Ceiling
`config/patterns/sprint.toml` now declares `attempt_ceiling`, runs `attempt_ceiling_check`, and passes `next_attempt_ceiling` into the recursive sprint call. Interpreter tests cover bounded and unbounded behavior. Pattern documentation and mirrored website documents describe the ceiling in the shipped pattern format.
This sprint carried the convergence boundary itself. The task was right-sized because it could stay inside sprint recursion, command outputs, and the bundled ordinary-build callers instead of auditing the whole prompt corpus. It finished green, and the later milestone rows could rely on the ceiling route.
Gate Resolution Contract
The prompt reference now describes `GATE_PATH` as the resolved gate contract: either the exact command or a no-gate statement. The execute and troubleshoot prompt text use that contract through the same placeholder. Existing engine tests still cover the no-gate wording.
This sprint was a prompt-truth slice: align what agents read about gates with the gate the engine resolves. It was kept separate from stop notes and ceilings, so the worker could check the gate contract without changing retry semantics. The ledger records a green review commit.
Stop Note Truth
`config/patterns/sprint.toml` now keeps stop notes to the stop cause and has recovery positions refer to named evidence such as `executor_note` and `review_note`. The tutorial and mirrored website tutorial were updated with the same wording standard. The current pattern still follows that shape.
This sprint narrowed the stop-note problem to authored text. It did not need to redesign stop records; the brief asked it to remove stale path prose now that stop records carry evidence. The work stayed green and fed the later prompt audit.
Prompt Corpus Audit
The prompt reference and prompt README were tightened around active placeholders and shipped prompt behavior. Later changes have rewritten parts of those documents, so this sprint's exact prose is not fully separable today. The current reference still names active prompt placeholders and keeps retired retry-note placeholders out of the active contract.
This sprint was the corpus sweep after the mechanical prompt contracts had been corrected. Its brief was prose-heavy and had a clear stop rule: fix false engine promises, and record unrelated engine bugs instead of expanding the task. The row finished green without a recorded repair.
Convergence Rehearsal
The rehearsal left engine tests around prompt environment and plan-change behavior, plus prompt reference updates that describe the reviewer's convergence role. Its direct product is partly evidentiary rather than a standalone feature file. The current sprint pattern still routes reviewer retry through the same attempt ceiling used by red-gate recovery.
This final sprint rehearsed the combined behavior rather than adding another independent mechanism. It checked that brief edits, attempt notes, ceilings, and plan-role sessions composed under a real multi-task run. The ledger records a green build commit, and the top-level milestone review later made small pattern wording corrections.