From 2e7d681591dbae4ed58e4e400a7f4729a21a04c5 Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Thu, 30 Jul 2026 10:30:02 -0700 Subject: [PATCH 1/9] fix(sdd): implementers never dispatch subagents Depth-2 worker-spawned reviewers were 9/9 same-task duplicate reviews across four corpora in the codex-efficiency eval campaign. --- skills/subagent-driven-development/SKILL.md | 7 +++++++ .../implementer-prompt.md | 12 ++++++++++++ 2 files changed, 19 insertions(+) diff --git a/skills/subagent-driven-development/SKILL.md b/skills/subagent-driven-development/SKILL.md index 6c0b8349..96229e0a 100644 --- a/skills/subagent-driven-development/SKILL.md +++ b/skills/subagent-driven-development/SKILL.md @@ -223,6 +223,12 @@ and fix-round diffs need it. later dispatches — a real session's dispatch hit 42k chars of which 99% was pasted history. A fresh subagent needs its task, the interfaces it touches, and the global constraints. Nothing else. +- The dispatch carries the no-subagents contract (it is in the + implementer template): the implementer never dispatches subagents — + not helpers, and never a reviewer. Review arrives from you, after the + report. In real sessions, every reviewer a worker spawned duplicated + the task review the controller dispatched anyway — a full extra + review seat per task. - If an earlier task parked a finding in the area this task touches, carry a pointer to that ledger entry in the dispatch. - Record the implementer's agent identity from the dispatch result — @@ -434,6 +440,7 @@ Use superpowers:finishing-a-development-branch. | "The fix was small, skip the re-review" | Unreviewed fixes are how regressions land. Every round ends with a scoped re-review. | | "Reviews slow the loop down" | The loop without reviews is just unverified churn. Reviews are the loop's brakes and steering. | | "Ledger bookkeeping is overhead" | The ledger is what survives compaction. Controllers without one have re-dispatched entire completed task sequences. | +| "The implementer spawned its own reviewer — free extra assurance" | It's a duplicate seat reviewing the same diff; the task review is the gate. A worker-spawned reviewer is a defect to flag, not rigor. | ## Example Workflow diff --git a/skills/subagent-driven-development/implementer-prompt.md b/skills/subagent-driven-development/implementer-prompt.md index fbe441e2..5c8ecd61 100644 --- a/skills/subagent-driven-development/implementer-prompt.md +++ b/skills/subagent-driven-development/implementer-prompt.md @@ -47,6 +47,18 @@ Subagent (general-purpose): While iterating, run the focused test for what you're changing; run the full suite once before committing, not after every edit. + ## You Do Not Dispatch Subagents + + Do all of this task's work yourself. Never spawn a subagent to + implement part of the task, and above all never spawn a reviewer to + check your work. Self-review (below) means reading your own diff. + Review is the controller's job: after you report, it dispatches a + fresh reviewer against your diff. A reviewer you spawn duplicates + that review at full cost, and its approval counts for nothing in + the process. If you catch yourself thinking "an independent review + would strengthen my report" — that review is already scheduled. + Report instead. + ## Code Organization You reason best about code you can hold in context at once, and your edits are more From 75756d2900fc17e338f243886ade5998f5a4d78b Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Thu, 30 Jul 2026 10:32:01 -0700 Subject: [PATCH 2/9] fix(codex): correct multi-agent guidance against Codex source Five claims contradicted by the Codex CLI source (V2 has no close_agent; followup_task always reaches a child; role files attach via agent_type; full-history forks accept model/effort; V2 spawn allowlist). Citations: superpowers-autoresearch docs/2026-07-29-codex-multiagent-v2-capabilities.md. --- .../references/codex-tools.md | 29 ++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/skills/using-superpowers/references/codex-tools.md b/skills/using-superpowers/references/codex-tools.md index b14b5858..415638f6 100644 --- a/skills/using-superpowers/references/codex-tools.md +++ b/skills/using-superpowers/references/codex-tools.md @@ -7,7 +7,34 @@ Add to your Codex config (`~/.codex/config.toml`): multi_agent = true ``` -This enables `spawn_agent`, `wait_agent`, and `close_agent` for skills like `dispatching-parallel-agents` and `subagent-driven-development`. When using subagent-driven-development, close reviewer subagents when their review returns. Keep each implementer subagent open until its task's review passes — the fix loop resumes the implementer — then close it. If your harness cannot send another message to a spawned agent, dispatch each fix round as a fresh implementer carrying the brief, the report file, and the findings. +This enables the multi-agent tools that skills like +`dispatching-parallel-agents` and `subagent-driven-development` use. +Which tools you get depends on the multi-agent version your model +preset selects (current presets run V2; older ones run V1). Trust your +actual tool list over any table — including this one — when they +disagree. + +- **Spawning:** give children a clean context with + `spawn_agent {fork_turns: "none"}`; the default `"all"` copies your + entire transcript into the child. On Codex 0.145+, role files under + `~/.codex/agents/` attach to isolated forks via `agent_type`. + Full-history forks accept `model` and `reasoning_effort` overrides + (only `agent_type` is refused there) — isolated forks are the SDD + default for context hygiene, not because overrides require them. +- **Fix rounds:** resume the implementer with `followup_task` — it + delivers your message, triggers a turn, and transparently reloads a + child the harness evicted. Never dispatch a fresh implementer on the + theory that a spawned agent cannot be messaged again; on V2 it + always can. +- **Lifecycle:** V2 has no `close_agent`. Finished children are + evicted automatically when slots are needed; leaving them unclosed + costs nothing. Only V1 sessions have `close_agent` — there, close + reviewers when their review returns, and close each implementer + after its task's review passes. +- **Model names:** never copy a model name from a skill, table, or old + session into `spawn_agent` without checking it against your current + spawn allowlist — V2 accepts only V2-capable presets and hard-errors + on the rest. ## Environment Detection From 7c560e048b85e5bfa4d59a7f71d0bd012d7b8343 Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Thu, 30 Jul 2026 12:48:28 -0700 Subject: [PATCH 3/9] fix(sdd): reviewers never dispatch subagents either The first fix-cycle battery moved the depth-2 leak from implementers (9/9 baseline -> 0/6) to a final reviewer that spawned two sub-reviewers; the contract now reaches every dispatched role. --- skills/requesting-code-review/code-reviewer.md | 9 +++++++++ skills/subagent-driven-development/re-review-prompt.md | 9 +++++++++ .../subagent-driven-development/task-reviewer-prompt.md | 9 +++++++++ 3 files changed, 27 insertions(+) diff --git a/skills/requesting-code-review/code-reviewer.md b/skills/requesting-code-review/code-reviewer.md index db84ae2a..b898cb98 100644 --- a/skills/requesting-code-review/code-reviewer.md +++ b/skills/requesting-code-review/code-reviewer.md @@ -34,6 +34,15 @@ Subagent (general-purpose): Your review is read-only on this checkout. Do not mutate the working tree, the index, HEAD, or branch state in any way. Use tools like `git show`, `git diff`, and `git log` to inspect history. If you need a working copy of a different revision, check it out into a separate temporary directory (e.g. `git worktree add /tmp/review-[SHA] [SHA]`) — never move HEAD on this checkout. + ## You Do Not Dispatch Subagents + + Do all of this review yourself. Never spawn a subagent to review part + of the diff, and never spawn another reviewer for a second opinion. + This process already provides every review seat the work gets; a + reviewer you spawn duplicates one of them at full cost, and its + verdict counts for nothing. If the diff feels too large for one + pass, review it in passes yourself and say so in your report. + ## What to Check **Plan alignment:** diff --git a/skills/subagent-driven-development/re-review-prompt.md b/skills/subagent-driven-development/re-review-prompt.md index 18b0fb8a..ad74b10b 100644 --- a/skills/subagent-driven-development/re-review-prompt.md +++ b/skills/subagent-driven-development/re-review-prompt.md @@ -43,6 +43,15 @@ Subagent (general-purpose): Your review is read-only on this checkout. Do not mutate the working tree, the index, HEAD, or branch state in any way. + ## You Do Not Dispatch Subagents + + Do all of this review yourself. Never spawn a subagent to review part + of the diff, and never spawn another reviewer for a second opinion. + This process already provides every review seat the work gets; a + reviewer you spawn duplicates one of them at full cost, and its + verdict counts for nothing. If the diff feels too large for one + pass, review it in passes yourself and say so in your report. + ## Scope Your scope is the findings list and the fix diff. Verdict every finding. diff --git a/skills/subagent-driven-development/task-reviewer-prompt.md b/skills/subagent-driven-development/task-reviewer-prompt.md index fefaea8a..6ca4c1ca 100644 --- a/skills/subagent-driven-development/task-reviewer-prompt.md +++ b/skills/subagent-driven-development/task-reviewer-prompt.md @@ -52,6 +52,15 @@ Subagent (general-purpose): Your review is read-only on this checkout. Do not mutate the working tree, the index, HEAD, or branch state in any way. + ## You Do Not Dispatch Subagents + + Do all of this review yourself. Never spawn a subagent to review part + of the diff, and never spawn another reviewer for a second opinion. + This process already provides every review seat the work gets; a + reviewer you spawn duplicates one of them at full cost, and its + verdict counts for nothing. If the diff feels too large for one + pass, review it in passes yourself and say so in your report. + ## Do Not Trust the Report Treat the implementer's report as unverified claims about the code. It From 9b8b14fe12b2a1751ce7c58ba6f8d49bf38e3d1d Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Thu, 30 Jul 2026 10:33:59 -0700 Subject: [PATCH 4/9] fix(codex): event-driven waiting instead of short polls 60-78% of wait_agent calls timed out across every measured corpus; waits are event subscriptions, so one long wait replaces dozens of polls at identical wake latency. --- .../references/codex-tools.md | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/skills/using-superpowers/references/codex-tools.md b/skills/using-superpowers/references/codex-tools.md index 415638f6..cf2b70ee 100644 --- a/skills/using-superpowers/references/codex-tools.md +++ b/skills/using-superpowers/references/codex-tools.md @@ -36,6 +36,25 @@ disagree. spawn allowlist — V2 accepts only V2-capable presets and hard-errors on the rest. +## Waiting on children + +`wait_agent` is an event subscription, not a poll: a long wait wakes +the moment a child produces mailbox activity, with the same latency as +a short one. Short-timeout polling buys nothing and costs a tool call — +and a context rebill — per poll. In measured sessions, roughly +two-thirds of all wait calls were short polls that timed out. + +- While you still have local work, do not wait at all. A completed + child's final answer is pushed into your mailbox and arrives with + your next turn. +- When you are genuinely idle with children outstanding, issue ONE + `wait_agent` with a long `timeout_ms` — 900000 (15 minutes) or more — + and let the event wake you. +- Completion mail cannot wake an idle controller (it is delivered + without triggering a turn); covering that idle window is + `wait_agent`'s only job. If a long wait times out, check + `list_agents` for stuck children — do not fall back to short polls. + ## Environment Detection Skills that create worktrees or finish branches should detect their From db4538fcb849be0273c792064355546388410f12 Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Thu, 30 Jul 2026 12:50:42 -0700 Subject: [PATCH 5/9] fix(sdd): controllers wait long or not at all Docs-only wait guidance in the platform reference changed nothing (65.1% vs 67.1% baseline wait-timeout rate); the discipline now lives in the controller loop the session actually re-reads. --- skills/subagent-driven-development/SKILL.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/skills/subagent-driven-development/SKILL.md b/skills/subagent-driven-development/SKILL.md index 6c0b8349..cc4ad113 100644 --- a/skills/subagent-driven-development/SKILL.md +++ b/skills/subagent-driven-development/SKILL.md @@ -197,6 +197,14 @@ Everything you paste into a dispatch prompt — and everything a subagent prints back — stays resident in your context for the rest of the session and is re-read on every later turn. Hand artifacts over as files. +**Waiting on dispatched subagents:** never poll a wait interface with +short timeouts. While you have local work — ledger updates, packaging +the next review, reading reports — keep working; child results arrive +on their own. Wait only when you are genuinely idle, and then issue one +long wait (fifteen minutes or more, where your platform allows it) +instead of many short ones: a long wait wakes just as fast and costs +one call instead of dozens. + ### 1. Dispatch the implementer Record BASE (`git rev-parse HEAD`) before dispatching — the review package From d8189d1587ed29cbf7b01ed4138edc8799164898 Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Thu, 30 Jul 2026 15:57:32 -0700 Subject: [PATCH 6/9] fix(sdd,codex): bounded wait stretches with reconciliation Round 2 proved the long-wait mechanism (65.1%->0.0% timeouts) but 20-38 min silent waits starved graders and let 1/51 children vanish; bounded 5-10 min stretches with a status line and list_agents reconcile keep the efficiency and restore observability. --- skills/subagent-driven-development/SKILL.md | 15 +++++++++------ .../using-superpowers/references/codex-tools.md | 14 +++++++++----- 2 files changed, 18 insertions(+), 11 deletions(-) diff --git a/skills/subagent-driven-development/SKILL.md b/skills/subagent-driven-development/SKILL.md index cc4ad113..5a7da97b 100644 --- a/skills/subagent-driven-development/SKILL.md +++ b/skills/subagent-driven-development/SKILL.md @@ -198,12 +198,15 @@ prints back — stays resident in your context for the rest of the session and is re-read on every later turn. Hand artifacts over as files. **Waiting on dispatched subagents:** never poll a wait interface with -short timeouts. While you have local work — ledger updates, packaging -the next review, reading reports — keep working; child results arrive -on their own. Wait only when you are genuinely idle, and then issue one -long wait (fifteen minutes or more, where your platform allows it) -instead of many short ones: a long wait wakes just as fast and costs -one call instead of dozens. +short timeouts, and never sit in one silent, open-ended wait either. +While you have local work — ledger updates, packaging the next review, +reading reports — keep working; child results arrive on their own. +When you are genuinely idle, wait in bounded stretches (five to ten +minutes, where your platform allows), and between stretches post one +line of status and reconcile your live children: list them, and chase +any that finished without reporting. A bounded stretch keeps nearly +all of a long wait's efficiency while guaranteeing a stuck or lost +child is noticed within minutes, not at the end of the session. ### 1. Dispatch the implementer diff --git a/skills/using-superpowers/references/codex-tools.md b/skills/using-superpowers/references/codex-tools.md index cf2b70ee..077550e0 100644 --- a/skills/using-superpowers/references/codex-tools.md +++ b/skills/using-superpowers/references/codex-tools.md @@ -47,13 +47,17 @@ two-thirds of all wait calls were short polls that timed out. - While you still have local work, do not wait at all. A completed child's final answer is pushed into your mailbox and arrives with your next turn. -- When you are genuinely idle with children outstanding, issue ONE - `wait_agent` with a long `timeout_ms` — 900000 (15 minutes) or more — - and let the event wake you. +- When you are genuinely idle with children outstanding, wait in + bounded stretches: `wait_agent` with `timeout_ms` 300000-600000 + (5-10 minutes). After each stretch — wake or timeout — post one + status line, run `list_agents`, and chase any child that finished + without reporting. Never stack polls shorter than five minutes; the + event subscription wakes a bounded stretch just as fast as a short + one. - Completion mail cannot wake an idle controller (it is delivered without triggering a turn); covering that idle window is - `wait_agent`'s only job. If a long wait times out, check - `list_agents` for stuck children — do not fall back to short polls. + `wait_agent`'s only job. A stretch that times out with no activity + is your cue to reconcile, not to shorten the next stretch. ## Environment Detection From e9686d5c09b80323bfdc44be8804081e46ea0986 Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Thu, 30 Jul 2026 10:35:28 -0700 Subject: [PATCH 7/9] fix(codex): explicit model+effort on every spawn, config backstop Depth-2 child-issued spawns omitted model 2/2 at CLI 0.146; model without reasoning_effort resets effort to the model default. --- .../references/codex-tools.md | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/skills/using-superpowers/references/codex-tools.md b/skills/using-superpowers/references/codex-tools.md index 077550e0..e4488fb2 100644 --- a/skills/using-superpowers/references/codex-tools.md +++ b/skills/using-superpowers/references/codex-tools.md @@ -59,6 +59,25 @@ two-thirds of all wait calls were short polls that timed out. `wait_agent`'s only job. A stretch that times out with no activity is your cue to reconcile, not to shorten the next stretch. +## Model routing on spawns + +Every `spawn_agent` you issue — including when you are yourself a +spawned child running a fan-out — sets `model` AND `reasoning_effort` +explicitly, per the Model Selection rules of the skill you are +executing. Setting `model` alone is a trap: the child's effort +silently resets to that model's default, not to yours. + +Ask your human partner to add a machine-level backstop to +`~/.codex/config.toml` so any spawn that slips through still routes to +a deliberate tier instead of silently inheriting the session's most +expensive model: + +```toml +[agents] +default_subagent_model = "" +default_subagent_reasoning_effort = "medium" +``` + ## Environment Detection Skills that create worktrees or finish branches should detect their From 39f9602432c8115f1673e01e16cf2e79ea16bf12 Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Sun, 2 Aug 2026 11:14:01 -0700 Subject: [PATCH 8/9] =?UTF-8?q?fix(sdd):=20rule=20and=20continue=20?= =?UTF-8?q?=E2=80=94=20non-catastrophic=20conflicts=20get=20ledgered=20rul?= =?UTF-8?q?ings,=20not=20blocking=20questions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A donated session sat dormant 8h48m waiting for a plan-conflict answer that cost ~zero tokens to decide. Wrong-ruling rework is bounded; stalls are not. This encodes the never-stall doctrine: plan conflicts, ambiguities, and cap exceptions get a controller ruling recorded in the ledger and work proceeds; only irreversible/destructive actions, security-sensitive actions, out-of-worktree side effects (merge/push/ publish), and totally-broken plans remain hard stops. Rulings surface in the Finish report instead of as mid-run questions. Evals: 3/3 no-stall vs control 3/3 stall-at-preflight on a seeded-conflict SDD plan; catastrophic guard 5/5 (every rep reaching a seeded DROP TABLE step refused it); re-validated 3/3 after rebase onto the current fix-PR text; composes cleanly with the evidence-bearing preflight treatment. Claude-Session: https://claude.ai/code/session_0185AJr98gHx5EmwqNeft4Sy --- skills/subagent-driven-development/SKILL.md | 61 ++++++++++++++------- 1 file changed, 42 insertions(+), 19 deletions(-) diff --git a/skills/subagent-driven-development/SKILL.md b/skills/subagent-driven-development/SKILL.md index 6c0b8349..34169350 100644 --- a/skills/subagent-driven-development/SKILL.md +++ b/skills/subagent-driven-development/SKILL.md @@ -14,7 +14,21 @@ Execute plan by dispatching a fresh implementer subagent per task, a task review **Narration:** between tool calls, narrate at most one short line — the ledger and the tool results carry the record. -**Continuous execution:** Do not pause to check in with your human partner between tasks. Execute all tasks from the plan without stopping. The only reasons to stop are: BLOCKED status you cannot resolve, ambiguity that genuinely prevents progress, or all tasks complete. "Should I continue?" prompts and progress summaries waste their time — they asked you to execute the plan, so execute it. +**Continuous execution:** Do not pause to check in with your human partner between tasks. Execute all tasks from the plan without stopping. The only reasons to stop are the four named below, or all tasks complete. "Should I continue?" prompts and progress summaries waste their time — they asked you to execute the plan, so execute it. + +**Rulings, not stalls.** A running plan does not wait on a human. Conflicts, +ambiguities, plan defects, a cap you would have asked to exceed — decide +them. The spec is the binding authority, the plan is its argument, and your +judgment settles what neither answers. Record every decision in the ledger as +`Ruling: — — `, and keep +going. A wrong ruling costs rework your human partner can see and undo; a +session parked on a question costs their whole day and buys nothing. + +Four things stop you, and only these: an irreversible or destructive +operation; a security-sensitive action; a side effect outside this worktree +that norms say you ask about first (a merge, a push to a shared branch, a +publish); and a plan so broken that every path forward is a guess. For those, +stop and ask. ## When to Use @@ -57,14 +71,14 @@ digraph process { "Generate review package, dispatch task reviewer (./task-reviewer-prompt.md)" [shape=box]; "Spec ✅ and quality approved?" [shape=diamond]; "Finding conflicts with plan text?" [shape=diamond]; - "Ask human partner which governs" [shape=box]; + "Rule on the conflict, ledger the ruling" [shape=box]; "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model" [shape=box]; "Dispatch scoped re-review (./re-review-prompt.md)" [shape=box]; "All findings addressed?" [shape=diamond]; "R = 5?" [shape=diamond]; "Adjudicate each open finding" [shape=box]; "Any load-bearing finding?" [shape=diamond]; - "STOP: report BLOCKED to human partner" [shape=box]; + "Rule and continue; stop only if every path forward is a guess" [shape=box]; "Park findings in ledger with rulings" [shape=box]; "Append completion to ledger, mark todo complete" [shape=box]; } @@ -85,8 +99,8 @@ digraph process { "Generate review package, dispatch task reviewer (./task-reviewer-prompt.md)" -> "Spec ✅ and quality approved?"; "Spec ✅ and quality approved?" -> "Append completion to ledger, mark todo complete" [label="yes"]; "Spec ✅ and quality approved?" -> "Finding conflicts with plan text?" [label="no"]; - "Finding conflicts with plan text?" -> "Ask human partner which governs" [label="yes"]; - "Ask human partner which governs" -> "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model"; + "Finding conflicts with plan text?" -> "Rule on the conflict, ledger the ruling" [label="yes"]; + "Rule on the conflict, ledger the ruling" -> "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model"; "Finding conflicts with plan text?" -> "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model" [label="no"]; "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model" -> "Dispatch scoped re-review (./re-review-prompt.md)"; "Dispatch scoped re-review (./re-review-prompt.md)" -> "All findings addressed?"; @@ -95,7 +109,7 @@ digraph process { "R = 5?" -> "Fix round R of 5: R≤3 resume implementer; R≥4 fresh implementer, more capable model" [label="no - next round"]; "R = 5?" -> "Adjudicate each open finding" [label="yes - breaker trips"]; "Adjudicate each open finding" -> "Any load-bearing finding?"; - "Any load-bearing finding?" -> "STOP: report BLOCKED to human partner" [label="yes"]; + "Any load-bearing finding?" -> "Rule and continue; stop only if every path forward is a guess" [label="yes"]; "Any load-bearing finding?" -> "Park findings in ledger with rulings" [label="no"]; "Park findings in ledger with rulings" -> "Append completion to ledger, mark todo complete"; "Append completion to ledger, mark todo complete" -> "More tasks remain?"; @@ -148,9 +162,8 @@ Before dispatching Task 1, scan the plan once for conflicts: - anything the plan explicitly mandates that the review rubric treats as a defect (a test that asserts nothing, verbatim duplication of a logic block) -Present everything you find to your human partner as one batched question — -each finding beside the plan text that mandates it, asking which governs — -before execution begins, not one interrupt per discovery mid-plan. If the +Rule on everything you find before execution begins — each finding against +the plan text that mandates it — and record each ruling in the ledger. If the scan is clean, proceed without comment. The review loop remains the net for conflicts that only emerge from implementation. @@ -245,7 +258,7 @@ Implementer subagents report one of four statuses. Handle each appropriately: 1. If it's a context problem, provide more context and re-dispatch with the same model 2. If the task requires more reasoning, re-dispatch with a more capable model 3. If the task is too large, break it into smaller pieces -4. If the plan itself is wrong, escalate to the human +4. If the plan itself is wrong, rule on the correction, ledger it, and re-dispatch with the ruling carried in the dispatch **Never** ignore an escalation or force the same model to retry without changes. If the implementer said it's stuck, something needs to change. @@ -312,10 +325,11 @@ Before the loop starts, two routes leave it immediately: before merge. A roll-up nobody reads is a silent discard. Minor findings never enter the loop. - A finding labeled plan-mandated — or any finding that conflicts with - what the plan's text requires — is the human's decision, like any plan - contradiction: present the finding and the plan text, ask which governs. - Do not dismiss the finding because the plan mandates it, and do not - dispatch a fix that contradicts the plan without asking. + what the plan's text requires — is yours to rule on: weigh the finding + against the plan text, decide with the spec as the binding authority, and + ledger the ruling before you act on it. Do not dismiss the finding because + the plan mandates it, and do not dispatch a fix that contradicts the plan + without a recorded ruling. Everything else enters the loop. A fix round is one fix dispatch plus one scoped re-review. Five rounds maximum per task: @@ -365,10 +379,11 @@ the cross-task context the reviewer lacks: - **Real, but nothing downstream builds on it:** park it the same way, with a ruling that says it's real and deferred. - **Real and load-bearing** — a later task builds on it, or it reveals a - plan defect: STOP. Append `Task : BLOCKED — ` and report to - your human partner with the finding, the plan text it collides with, and - the fix history. Parking a structural failure lets every dependent task - build on it and hands the final review a problem it cannot fix either. + plan defect: rule on the smallest change that unblocks the dependent work, + ledger it as `Task : ruling — — `, + and carry it into the next task's dispatch. Parking a structural failure + silently lets every dependent task build on it. Stop only when the defect + leaves every path forward a guess. Adjudicate only at the cap. Adjudicating earlier to end a loop is pre-judging with a different name. Every adjudication is a ledger entry — @@ -409,12 +424,20 @@ Then run exactly one scoped re-review of the fix wave (`scripts/review-package PLAN_FILE FIX_BASE HEAD` over the fix range, [re-review-prompt.md](re-review-prompt.md)). Adjudicate any residual findings as in the task loop's breaker: park with -rulings, or stop on load-bearing ones. There is no second fix wave — +rulings, or rule on the load-bearing ones and ledger what you decided. Only +the four classes above stop you here. There is no second fix wave — residual load-bearing findings surface to your human partner when finishing-a-development-branch presents the options. ## Finish +Before you delete anything, collect every `Ruling:` line from the ledger into +your final message under "Rulings I made", in the order you made them, each +with what it costs if wrong. That list is the only place the decisions you +took on your human partner's behalf reach them — they read it and rework +whatever you got wrong. A ruling that dies with the workspace was a decision +made in secret. + When the final whole-branch review is clean and its fixes are merged, delete this plan's workspace (`rm -rf `) — the git history is the record now. Sibling directories belong to other plans; leave them From 7a01a0e83a2e53d2e5e5b70646a938df688d1cc7 Mon Sep 17 00:00:00 2001 From: Drew Ritter Date: Tue, 4 Aug 2026 14:13:42 -0700 Subject: [PATCH 9/9] fix(sdd): one Ruling: token everywhere, exhaustive finish roll-up The breaker's two ledger formats wrote lowercase 'ruling' (parked findings, load-bearing adjudications), so the Finish section's collect-every-`Ruling:`-line step missed exactly the rulings made under the most pressure. Field evidence from an independent eval rep: a breaker-cap run adjudicated correctly, wrote everything to the plan-scoped ledger, deleted the workspace at finish, and left no durable trace of the adjudication. Capitalize the two breaker formats to the canonical token, and make the finish roll-up explicitly exhaustive across preflight, parked, and breaker rulings. Co-Authored-By: Claude Fable 5 --- skills/subagent-driven-development/SKILL.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/skills/subagent-driven-development/SKILL.md b/skills/subagent-driven-development/SKILL.md index 34169350..a40ffdb6 100644 --- a/skills/subagent-driven-development/SKILL.md +++ b/skills/subagent-driven-development/SKILL.md @@ -374,13 +374,13 @@ dispatching. Adjudicate each open finding yourself — you hold the plan and the cross-task context the reviewer lacks: - **The reviewer is wrong, or the point is contestable:** park it — - `Task : parked — — ruling: `. The final + `Task : parked — — Ruling: `. The final review sees both sides. - **Real, but nothing downstream builds on it:** park it the same way, with a ruling that says it's real and deferred. - **Real and load-bearing** — a later task builds on it, or it reveals a plan defect: rule on the smallest change that unblocks the dependent work, - ledger it as `Task : ruling — — `, + ledger it as `Task : Ruling: — `, and carry it into the next task's dispatch. Parking a structural failure silently lets every dependent task build on it. Stop only when the defect leaves every path forward a guess. @@ -431,9 +431,11 @@ finishing-a-development-branch presents the options. ## Finish -Before you delete anything, collect every `Ruling:` line from the ledger into +Before you delete anything, collect every ledger line containing `Ruling:` — +preflight rulings, parked findings, breaker adjudications, all of them — into your final message under "Rulings I made", in the order you made them, each -with what it costs if wrong. That list is the only place the decisions you +with what it costs if wrong. The list is exhaustive: if the ledger holds a +ruling, the list holds it. That list is the only place the decisions you took on your human partner's behalf reach them — they read it and rework whatever you got wrong. A ruling that dies with the workspace was a decision made in secret.