cclaw-cli 6.8.0 → 6.10.0

package/dist/content/reference-patterns.js

@@ -36,7 +36,7 @@ export const REFERENCE_PATTERNS = [
                     "Discover tests and affected contracts before opening a RED vertical slice.",
                     "Map the slice to the active source item before editing production code."
                 ],
-                artifactSections: ["Test Discovery", "System-Wide Impact Check", "Acceptance Mapping"]
+                artifactSections: ["Test Discovery", "System-Wide Impact Check", "Acceptance & Failure Map"]
             },
             {
                 stage: "review",
@@ -143,7 +143,7 @@ export const REFERENCE_PATTERNS = [
                     "Open one packet as one vertical slice; do not mix unrelated packet evidence.",
                     "Close packet only when RED, GREEN, REFACTOR, and verification evidence align."
                 ],
-                artifactSections: ["Acceptance Mapping", "RED Evidence", "GREEN Evidence", "REFACTOR Notes"]
+                artifactSections: ["Acceptance & Failure Map", "RED Evidence", "GREEN Evidence", "REFACTOR Notes"]
             }
         ]
     },

package/dist/content/skills-elicitation.js

@@ -47,7 +47,7 @@ These behaviors are the exact reason this skill exists. The linter will block yo
 - Use harness-native question tools first; prose fallback is allowed only when the tool is unavailable.
 - Keep a running Q&A trace in the active artifact under \`## Q&A Log\` in \`${RUNTIME_ROOT}/artifacts/\` as append-only rows.
 - **Early-loop ledger discipline**: Never append \`.cclaw/state/early-loop-log.jsonl\` rows whose \`iteration\` exceeds the active \`maxIterations\`. If the cap fired, escalate or accept convergence outcomes—do not bump the iteration counter afterward. \`deriveEarlyLoopStatus\` clamps persistence, but the log source should stay honest too.
-- **Convergence floor**: do NOT advance the stage (do NOT call \`stage-complete.mjs\`) until Q&A converges. The machine contract matches \`evaluateQaLogFloor\` in \`src/artifact-linter/shared.ts\` (rule \`qa_log_unconverged\`). Pass when ANY holds: (a) every forcing-question topic id is tagged \`[topic:<id>]\` on at least one \`## Q&A Log\` row; (b) the Ralph-Loop detector fires (last 2 substantive rows are non-decision-changing: \`skip\`/\`continue\`/\`no-change\`/\`done\`/etc.) **and** the log has at least \`max(2, questionBudgetHint(discoveryMode, stage).min)\` substantive rows — **unless** \`discoveryMode\` is \`guided\` or \`deep\` with pending forcing-topic ids (then Ralph-Loop alone cannot pass until topics are tagged, a stop-signal is recorded, or \`--skip-questions\` downgrades the finding to advisory); (c) an explicit user stop-signal row; or (d) \`--skip-questions\` was persisted (unconverged is advisory only). Wave 24 (v6.0.0) made \`[topic:<id>]\` mandatory (no English keyword fallback).
+- **Convergence floor (a.k.a. "Q&A Ralph Loop" / "Elicitation Convergence")**: do NOT advance the stage (do NOT call \`stage-complete.mjs\`) until Q&A converges. The machine contract matches \`evaluateQaLogFloor\` in \`src/artifact-linter/shared.ts\` (rule \`qa_log_unconverged\`). Pass when ANY holds: (a) every forcing-question topic id is tagged \`[topic:<id>]\` on at least one \`## Q&A Log\` row; (b) the Q&A Ralph Loop detector fires (last 2 substantive rows are non-decision-changing: \`skip\`/\`continue\`/\`no-change\`/\`done\`/etc.) **and** the log has at least \`max(2, questionBudgetHint(discoveryMode, stage).min)\` substantive rows — **unless** \`discoveryMode\` is \`guided\` or \`deep\` with pending forcing-topic ids (then the Q&A Ralph Loop alone cannot pass until topics are tagged, a stop-signal is recorded, or \`--skip-questions\` downgrades the finding to advisory); (c) an explicit user stop-signal row; or (d) \`--skip-questions\` was persisted (unconverged is advisory only). Wave 24 (v6.0.0) made \`[topic:<id>]\` mandatory (no English keyword fallback). The "Q&A Ralph Loop" is the elicitation-stage convergence mechanism; the producer/critic Concern Ledger that drives early-stage iteration is the **Early-Loop**, persisted in \`.cclaw/state/early-loop-log.jsonl\` and \`early-loop.json\` — they are different machines, do not conflate them.
 - **NEVER run shell hash commands** (\`shasum\`, \`sha256sum\`, \`md5sum\`, \`Get-FileHash\`, \`certutil\`, etc.) to compute artifact hashes. If a linter ever asks you for a hash, that is a linter bug — report failure and stop, do not auto-fix in bash.
 - **NEVER paste cclaw command lines into chat** (e.g. \`node .cclaw/hooks/stage-complete.mjs ... --evidence-json '{...}'\`). Run them via the tool layer; report only the resulting summary. The user does not run cclaw manually and seeing the command line is noise.
 
@@ -107,7 +107,7 @@ Do not ask extra questions "for theater" on simple low-risk work.
 
 ## Question Budget Hint (\`questionBudgetHint\` — min rows feed the convergence floor)
 
-Source of truth: \`questionBudgetHint(discoveryMode, stage)\`. The \`Min\` column is **not advisory** for the Ralph-Loop exit: \`evaluateQaLogFloor\` requires at least \`max(2, Min)\` substantive rows before the no-new-decisions path can converge (other exits — full topic coverage, stop-signal, \`--skip-questions\` advisory — ignore that minimum). \`Recommended\` and \`Hard cap warning\` remain pacing hints for the harness.
+Source of truth: \`questionBudgetHint(discoveryMode, stage)\`. The \`Min\` column is **not advisory** for the Q&A Ralph Loop exit: \`evaluateQaLogFloor\` requires at least \`max(2, Min)\` substantive rows before the no-new-decisions path can converge (other exits — full topic coverage, stop-signal, \`--skip-questions\` advisory — ignore that minimum). \`Recommended\` and \`Hard cap warning\` remain pacing hints for the harness.
 
 ${budgetTable}
 

package/dist/content/skills.js

@@ -102,7 +102,7 @@ Any "the failure is real" claim (failing test, broken build, regression catch, d
 
 \`proof: <iso-ts> | <observed snippet — first 200 chars> | source: <command or log path>\`
 
-For TDD specifically, this is the watched-RED proof and is required per new test before \`stage-complete\` accepts the stage.
+For TDD specifically, this is the watched-RED proof and is required per new test before \`stage-complete\` accepts the stage. From v6.10.0 onward, record TDD slice transitions through the sidecar CLI \`cclaw-cli internal tdd-slice-record --slice <id> --status red|green|refactor-done|refactor-deferred ...\` rather than hand-editing the \`Watched-RED Proof\` or \`Vertical Slice Cycle\` markdown tables; the linter reads \`.cclaw/artifacts/06-tdd-slices.jsonl\` when present and treats the markdown as an auto-derived view.
 `;
 }
 /**

package/dist/content/stages/brainstorm.js

@@ -36,7 +36,7 @@ export const BRAINSTORM = {
     },
     executionModel: {
         checklist: [
-            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the brainstorm forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:pain]`). Continue until every forcing-question topic id is tagged on a row OR Ralph-Loop convergence detector says no new decision-changing rows in last 2 iterations OR user records an explicit stop-signal row. Only then proceed to delegations, drafts, or analysis. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
+            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the brainstorm forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:pain]`). Continue until every forcing-question topic id is tagged on a row OR the Q&A Ralph Loop convergence detector says no new decision-changing rows in last 2 iterations OR user records an explicit stop-signal row. Only then proceed to delegations, drafts, or analysis. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
             "**Explore project context** — after the elicitation loop converges, inspect existing files/docs/recent activity to refine the Discovered context section; capture matching files/patterns/seeds in `Context > Discovered context` so downstream stages don't redo discovery.",
             "**Brainstorm forcing questions (must be covered or explicitly waived)** — `pain: what pain are we solving`; `direct-path: what is the direct path`; `operator: who is the first operator/user affected`; `no-go: what no-go boundaries are non-negotiable`. Tag the matching `## Q&A Log` row's `Decision impact` cell with `[topic:<id>]` (e.g. `[topic:pain]`) so the linter can verify coverage in any natural language. Tags are MANDATORY for forcing-question rows; un-tagged rows do NOT count toward coverage. Round 6 (v6.7.0) removed the counterfactual `do-nothing` topic; the Problem Decision Record already captures `Do-nothing consequence`.",
             "**Discovery posture (flow-state `discoveryMode`)** — follow `lean` / `guided` / `deep` from the active run. Use lean for smallest safe discovery pass; guided as the default balanced pass; escalate to deep when ambiguity, architecture, external dependency, security/data risk, or explicit think-bigger requests warrant fuller option pressure and mandatory specialist coverage.",
@@ -52,7 +52,7 @@ export const BRAINSTORM = {
             "**Compare 2-3 distinct approaches with stable Role/Upside columns** — Role values are `baseline` | `challenger` | `wild-card`; Upside is `low` | `modest` | `high` | `higher`; include real trade-offs, reuse notes, and reference-pattern source/disposition when a known pattern influenced the option; include exactly one challenger with explicit `high` or `higher` upside.",
             "**Collect reaction before recommending** — ask which option feels closest and what concern remains, then recommend based on that reaction.",
             "**Write the `Not Doing` list** — name 3-5 things this brainstorm explicitly is not committing to (vs. deferred). This protects scope from silent enlargement and the next stage from rework.",
-            "**Run early Ralph loop discipline** — after each producer iteration, append a `Critic Pass` JSONL row to `.cclaw/state/early-loop-log.jsonl`, refresh `.cclaw/state/early-loop.json`, and iterate until open concerns clear or convergence guard escalates.",
+            "**Run Early-Loop / Concern Ledger discipline** — after each producer iteration, append a `Critic Pass` JSONL row to `.cclaw/state/early-loop-log.jsonl`, refresh `.cclaw/state/early-loop.json`, and iterate until open concerns clear or convergence guard escalates. (This is the producer-critic concern ledger, not the Q&A Ralph Loop used for elicitation convergence.)",
             "**Embedded Grill (post-pick, one-at-a-time)** — after `Selected Direction` is named, if grilling triggers fire (irreversibility, security/auth boundary, domain-model ambiguity per `adaptive-elicitation:Conditional Grilling`), continue the elicitation loop with sharper questions **one at a time**, appended to `## Q&A Log` and reflected as rows in `## Embedded Grill`. Do NOT batch the 3-5 grill checks — each one follows the Core Protocol (ask, wait, log, self-eval, ask next).",
             "**Self-review before user approval** — re-read the artifact and patch contradictions, weak trade-offs, placeholders, ambiguity, and weak handoff language. Record the result in `Self-Review Notes` using the calibrated review format: `- Status: Approved` (or `Issues Found`), `- Patches applied:` with inline note or sub-bullets, `- Remaining concerns:` with inline note or sub-bullets. Use `Patches applied: None` and `Remaining concerns: None` when there is nothing to record.",
             "**Request explicit approval to close the stage** — state exactly what direction is being approved after the adaptive elicitation loop converges; do not advance without approval and artifact review.",

package/dist/content/stages/design.js

@@ -41,7 +41,7 @@ export const DESIGN = {
     },
     executionModel: {
         checklist: [
-            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the design forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:data-flow]`). Continue until every forcing-question topic id is tagged on a row OR Ralph-Loop convergence detector says no new decision-changing rows in last 2 iterations OR user records an explicit stop-signal row. Only then proceed to research, investigator pass, architecture lock, or any delegations. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
+            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the design forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:data-flow]`). Continue until every forcing-question topic id is tagged on a row OR the Q&A Ralph Loop convergence detector says no new decision-changing rows in last 2 iterations OR user records an explicit stop-signal row. Only then proceed to research, investigator pass, architecture lock, or any delegations. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
             "**Design forcing questions (must be covered or explicitly waived)** — `data-flow: what is the end-to-end data flow`; `seams: where are seams/ownership boundaries`; `invariants: which invariants must hold`; `not-refactor: what will explicitly NOT be refactored now`. Tag the matching `## Q&A Log` row's `Decision impact` cell with `[topic:<id>]` (e.g. `[topic:data-flow]`) so the linter can verify coverage in any natural language. Tags are MANDATORY for forcing-question rows; un-tagged rows do NOT count toward coverage.",
             "**Out-of-scope carry-forward (do NOT re-author)** — scope OWNS the out-of-scope list. Cite scope's `## In Scope / Out of Scope > Out of Scope` via `## Upstream Handoff > Decisions carried forward`; do NOT add a separate `## NOT in scope` section in the design artifact. Add a row to `## Spec Handoff` only if a design-stage decision NEWLY excludes something not already in scope's out-of-scope.",
             "Compact design lock — design does not decide what to build; it decides how the approved scope works. For simple slices, produce a tight lock: upstream handoff, existing fit, architecture boundary, one labeled diagram, data/state flow, critical path, failure/rescue, trust boundaries, test/perf expectations, rollout/rollback, rejected alternative, and spec handoff.",
@@ -55,7 +55,7 @@ export const DESIGN = {
             "Review core risk areas — existing system fit, data/state flow, critical path, security/trust boundaries, tests, performance budget, observability/debuggability, rollout/rollback, rejected alternatives, and spec handoff.",
             "**ADR + pre-mortem contract** — capture ADR-style decision rows (context, decision, alternatives, consequences), run a pre-mortem on likely failures, and map each critical flow to a validating test and diagram anchor before lock.",
             "Critic pass — run/reconcile adversarial second opinion on architecture, coupling, failure modes, and cheaper alternatives; record outcomes per the Design Outside Voice Loop policy.",
-            "**Run early Ralph loop discipline** — after each producer iteration, append a `Critic Pass` JSONL row to `.cclaw/state/early-loop-log.jsonl`, refresh `.cclaw/state/early-loop.json`, and iterate until open concerns clear or convergence guard escalates.",
+            "**Run Early-Loop / Concern Ledger discipline** — after each producer iteration, append a `Critic Pass` JSONL row to `.cclaw/state/early-loop-log.jsonl`, refresh `.cclaw/state/early-loop.json`, and iterate until open concerns clear or convergence guard escalates. (This is the producer-critic concern ledger, not the Q&A Ralph Loop used for elicitation convergence.)",
             "Run stale-diagram audit as a design freshness gate (default-on; explicit config opt-out allowed).",
             "Capture leftovers — seed high-upside deferred ideas, list unresolved decisions with defaults, document distribution for new artifact types, and cross-reference deferred items to scope or unresolved decisions."
         ],

package/dist/content/stages/scope.js

@@ -46,7 +46,7 @@ export const SCOPE = {
     },
     executionModel: {
         checklist: [
-            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the scope forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:in-out]`). Continue until every forcing-question topic id is tagged on a row OR Ralph-Loop convergence detector says no new decision-changing rows in last 2 iterations OR user records an explicit stop-signal row. Only then propose the scope contract draft, recommend a mode, or dispatch any delegations. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
+            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the scope forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:in-out]`). Continue until every forcing-question topic id is tagged on a row OR the Q&A Ralph Loop convergence detector says no new decision-changing rows in last 2 iterations OR user records an explicit stop-signal row. Only then propose the scope contract draft, recommend a mode, or dispatch any delegations. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
             "**Scope forcing questions (must be covered or explicitly waived)** — `in-out: what is definitely in/out`; `locked-upstream: which upstream decisions are locked`. Tag the matching `## Q&A Log` row's `Decision impact` cell with `[topic:<id>]` (e.g. `[topic:in-out]`) so the linter can verify coverage in any natural language. Tags are MANDATORY for forcing-question rows; un-tagged rows do NOT count toward coverage. Round 6 (v6.7.0) removed the counterfactual `rollback` and `failure-modes` topics from scope forcing questions; Design still owns the Failure Mode Table and rollback evidence.",
             "**Scope contract first** — read brainstorm handoff, name upstream decisions used, explicit drift, confidence, unresolved questions, and next-stage risk hints; draft the in-scope/out-of-scope/deferred/discretion contract before any design choice.",
             "**Premise carry-forward (do NOT re-author)** — brainstorm OWNS the premise check (right problem / direct path). Cite brainstorm's `## Premise Check` section in `## Upstream Handoff > Decisions carried forward`. Add a row to `## Premise Drift` only when the scope-stage Q&A surfaced NEW evidence that materially changes the brainstorm answer (e.g. new constraint, new user signal). Otherwise mark `Premise Drift: None` — do not duplicate the brainstorm premise table.",
@@ -58,7 +58,7 @@ export const SCOPE = {
             "**Architecture handoff (do NOT pick architecture tier here)** — design OWNS architecture choice (minimum-viable / product-grade / ideal). Scope only picks the SCOPE MODE (HOLD/SELECTIVE/EXPAND/REDUCE) and boundary; record in `## Scope Contract > Design handoff` what design must decide (e.g. `architecture-tier`, `framework`, `data-model`). Do NOT enumerate Implementation Alternatives in scope.",
             "**Constraints (carry-forward from brainstorm/external sources)** — record explicit external/regulatory/system/integration constraints in `## Scope Contract > Constraints`. Spec OWNS testable assumptions (`## Assumptions Before Finalization`); do NOT duplicate constraint material as assumption material.",
             "**Run outside voice before final approval** — for simple/low-risk scope, record one concise adversarial self-check row; for complex/high-risk/configured scope, iterate until threshold. Record the loop summary in `## Scope Outside Voice Loop`, but do not treat it as user approval.",
-            "**Run early Ralph loop discipline** — after each producer iteration, append a `Critic Pass` JSONL row to `.cclaw/state/early-loop-log.jsonl`, refresh `.cclaw/state/early-loop.json`, and iterate until open concerns clear or convergence guard escalates.",
+            "**Run Early-Loop / Concern Ledger discipline** — after each producer iteration, append a `Critic Pass` JSONL row to `.cclaw/state/early-loop-log.jsonl`, refresh `.cclaw/state/early-loop.json`, and iterate until open concerns clear or convergence guard escalates. (This is the producer-critic concern ledger, not the Q&A Ralph Loop used for elicitation convergence.)",
             "**Ask only one decision-changing question** — if the user rejects the contract but is unsure, offer 3-4 concrete scope moves instead of open-ended interrogation.",
             "**Write the scope contract after approval** — include selected mode, in scope, out of scope, requirements, locked decisions, discretion areas, deferred ideas, accepted/rejected reference ideas, success definition, design handoff, completion dashboard, and explicit approval evidence."
         ],

package/dist/content/stages/tdd.js

@@ -42,14 +42,14 @@ export const TDD = {
             "Discover the test surface — inspect existing tests, fixtures, helpers, test commands, and nearby assertions before authoring RED. Reuse the local test style unless the slice genuinely needs a new pattern.",
             "Run a system-wide impact check — name callbacks, state transitions, interfaces, schemas, CLI/config/API contracts, persistence, or event boundaries that this slice can affect. Add RED coverage for each affected public contract or record why it is out of scope.",
             "Source/test preflight — before production edits, classify planned paths using test-path patterns; verify the RED touches a test path and the GREEN touches only source paths needed for the failing behavior.",
-            "Set execution posture — record whether this slice is sequential, batch-safe, or blocked; when the existing git workflow permits small commits, checkpoint after RED, GREEN, and REFACTOR (or record why commits are deferred).",
             "Use the mandatory `test-author` delegation for RED — after discovery and impact check, produce failing behavior tests and RED evidence only (no production edits). Set `CCLAW_ACTIVE_AGENT=tdd-red` when the harness supports phase labels.",
-            "RED: Capture failure output — copy the exact failure output as RED evidence. Record in artifact.",
+            "RED: Capture failure output — copy the exact failure output as RED evidence. Record the slice in `.cclaw/artifacts/06-tdd-slices.jsonl` via `cclaw-cli internal tdd-slice-record --slice <id> --status red --test-file <path> --command <cmd> --paths <comma-separated>` (the markdown `Watched-RED Proof` table is now auto-derived from this sidecar).",
             "Continue the same `test-author` delegation intent for GREEN — minimal implementation plus full-suite GREEN evidence. Set `CCLAW_ACTIVE_AGENT=tdd-green` when the harness supports phase labels.",
             "GREEN: Run full suite — execute ALL tests, not just the ones you wrote. The full suite must be GREEN.",
             "GREEN: Verify no regressions — if any existing test breaks, fix the regression before proceeding.",
             "Run verification-before-completion discipline for the slice — capture a fresh test command, explicit PASS/FAIL status, and a config-aware ref (commit SHA when VCS is present/required, or no-vcs attestation when allowed).",
-            "REFACTOR: continue the `test-author` evidence cycle (or a dedicated refactor mode when available) to improve code quality without behavior changes. Set `CCLAW_ACTIVE_AGENT=tdd-refactor` when the harness supports phase labels.",
+            "GREEN: append a `green` row to `.cclaw/artifacts/06-tdd-slices.jsonl` via `cclaw-cli internal tdd-slice-record --slice <id> --status green [--green-output-ref <path|spanId:...>]` so the Vertical Slice Cycle linter validates the sidecar instead of a hand-edited table.",
+            "REFACTOR: continue the `test-author` evidence cycle (or a dedicated refactor mode when available) to improve code quality without behavior changes, then record `--status refactor-done` (or `--status refactor-deferred --refactor-rationale \"<why>\"`) via the same `tdd-slice-record` CLI. Set `CCLAW_ACTIVE_AGENT=tdd-refactor` when the harness supports phase labels.",
             "Record evidence — capture test discovery, system-wide impact check, RED failure, GREEN output, and REFACTOR notes in the TDD artifact. When logging a `green` row, attach the closed acceptance-criterion IDs in `acIds` so Ralph Loop status counts them.",
             "Annotate traceability — link to the active track's source: plan task ID + spec criterion on standard/medium, or spec acceptance item / bug reproduction slice on quick.",
             "**Boundary with review (do NOT escalate single-slice findings to whole-diff review).** `tdd.Per-Slice Review` OWNS severity-classified findings WITHIN one slice (correctness, edge cases, regression). `review` OWNS whole-diff Layer 1 (spec compliance) plus Layer 2 (cross-slice integration, security sweep, dependency/version audit, observability). When a single-slice finding genuinely needs whole-diff escalation, surface it in `06-tdd.md > Per-Slice Review` first; review will cite it (not re-classify) and the cross-artifact-duplication linter requires matching severity/disposition.",
@@ -58,6 +58,7 @@ export const TDD = {
         ],
         interactionProtocol: [
             "Pick one vertical slice at a time: source item, RED test, GREEN implementation, REFACTOR, and verification evidence move together.",
+            "Slice implementers are sequential by default. Parallel implementers are allowed only when (a) lanes touch non-overlapping files, (b) the controller passes `--allow-parallel` on each ledger row, and (c) an `integration-overseer` is dispatched after the parallel lanes and writes cohesion-evidence into the artifact before the gate is marked passed.",
             "Controller owns orchestration; one mandatory `test-author` delegation carries phase-specific RED -> GREEN -> REFACTOR evidence instead of spawning separate workers by default.",
             "Before writing RED tests, discover relevant existing tests and commands so the new test extends the suite instead of fighting it.",
             "Before implementation, perform a system-wide impact check across callbacks, state, interfaces, schemas, and external contracts touched by the slice.",
@@ -157,10 +158,8 @@ export const TDD = {
             { section: "Upstream Handoff", required: false, validationRule: "Summarizes plan/spec/design decisions, constraints, open questions, and explicit drift before RED work." },
             { section: "Test Discovery", required: true, validationRule: "Before RED: lists existing tests, fixtures/helpers, exact commands, and the chosen local pattern to extend." },
             { section: "System-Wide Impact Check", required: true, validationRule: "Before implementation: names affected callbacks, state transitions, interfaces, schemas, public APIs/config/CLI, persistence, or event contracts, with coverage or explicit out-of-scope notes." },
-            { section: "Execution Posture", required: false, validationRule: "Records sequential/batch/blocked posture and vertical-slice RED/GREEN/REFACTOR checkpoint plan, including incremental commit boundaries when consistent with the repository git workflow." },
             { section: "RED Evidence", required: true, validationRule: "Failing test output captured per slice." },
-            { section: "Acceptance Mapping", required: false, validationRule: "Each RED test links to a plan task and spec criterion." },
-            { section: "Failure Analysis", required: false, validationRule: "Failure reason matches expected missing behavior." },
+            { section: "Acceptance & Failure Map", required: false, validationRule: "Each slice row carries Source ID, AC ID, expected behavior, and a RED-link (delegation spanId, evidence path, or sidecar redOutputRef)." },
             { section: "GREEN Evidence", required: true, validationRule: "Full suite pass output captured." },
             { section: "REFACTOR Notes", required: true, validationRule: "What changed, why, behavior preservation confirmed." },
             { section: "Traceability", required: true, validationRule: "Plan task ID and spec criterion linked." },
@@ -301,11 +300,11 @@ function tddStageVariantForTrack(track) {
                 traceabilityRule: "Every RED test traces to an acceptance criterion. Every GREEN change traces to a RED test. Evidence chain must be unbroken."
             },
             artifactValidation: TDD.artifactRules.artifactValidation.map((row) => {
-                if (row.section === "Acceptance Mapping") {
+                if (row.section === "Acceptance & Failure Map") {
                     return {
                         ...row,
                         required: true,
-                        validationRule: "Each RED test links to a spec acceptance criterion ID (for example AC-1)."
+                        validationRule: "Each slice row carries Source ID, AC ID (spec acceptance criterion ID, for example AC-1), expected behavior, and a RED-link (delegation spanId, evidence path, or sidecar redOutputRef)."
                     };
                 }
                 if (row.section === "Traceability") {

package/dist/content/subagents.js

@@ -176,7 +176,17 @@ Before parallel dispatch, answer yes to all gates: tasks are independent, write
    - Copy each task verbatim into a working queue (checklist is fine).
    - Normalize each task so it includes: goal, acceptance criteria, constraints, and explicit “out of scope.”
 
-2. **For each task sequentially (NEVER parallel implementation subagents — file conflicts):**
+2. **For each task — sequential by default; parallel only with cohesion controls:**
+   - Implementation subagents are sequential by default. Parallel implementers
+     are allowed only when ALL three conditions hold:
+     - (a) the lanes touch non-overlapping files (verify via the plan's task
+       file-set list before dispatch),
+     - (b) the controller passes \`--allow-parallel\` on each ledger row, and
+     - (c) an \`integration-overseer\` is dispatched after the parallel lanes
+       complete and writes cohesion-evidence (cross-file integration tests,
+       contract checks, or merge-conflict scan) into the artifact before any
+       gate is marked passed.
+     If any of the three conditions are unmet, serialize.
    1. **Dispatch implementer subagent** with the **full task text pasted in** (not a file reference).
    2. **Check return status:** \`DONE\` / \`DONE_WITH_CONCERNS\` / \`NEEDS_CONTEXT\` / \`BLOCKED\`
    3. If \`DONE\`: dispatch **reviewer** subagent to verify actual code matches spec and quality expectations.
@@ -668,7 +678,7 @@ You are a slice-implementer subagent.
 
 SLICE: {single vertical slice}
 RED_EVIDENCE: {failing test and expected failure}
-ALLOWED_FILES: {explicit file boundaries}
+ALLOWED_FILES: {explicit file boundaries — surfaced to scheduler as Files: <paths>}
 FORBIDDEN_CHANGES: {scope/compatibility limits}
 VERIFICATION: {commands expected}
 
@@ -676,6 +686,12 @@ Rules:
 - Implement only the minimal GREEN change for the existing RED evidence.
 - Keep REFACTOR behavior-preserving.
 - Return the strict worker JSON schema first.
+
+Slice ledger contract (v6.10.0):
+- After observing the failing test, run \`cclaw-cli internal tdd-slice-record --slice <id> --status red --test-file <path> --command <cmd> --paths <comma-separated> [--ac <id>] [--plan-unit <id>]\`. The command appends to \`.cclaw/artifacts/06-tdd-slices.jsonl\`.
+- After the same test passes, run \`cclaw-cli internal tdd-slice-record --slice <id> --status green [--green-output-ref <path|spanId:...>]\`.
+- After REFACTOR, run \`cclaw-cli internal tdd-slice-record --slice <id> --status refactor-done\` or \`--status refactor-deferred --refactor-rationale "<why>"\`.
+- Do NOT hand-edit the Watched-RED Proof or Vertical Slice Cycle markdown tables; the linter reads the JSONL sidecar when present and the markdown becomes an auto-derived view.
 ${MARKDOWN_CODE_FENCE}
 
 `;
@@ -921,10 +937,12 @@ Process (mandatory):
 1) If STAGE_MODE=TEST_RED_ONLY:
    - RED only — add failing tests proving the gap (show failing output excerpt).
    - Do NOT edit production code.
+   - Append the slice to the sidecar via \`cclaw-cli internal tdd-slice-record --slice <id> --status red --test-file <path> --command <cmd> --paths <comma-separated>\` instead of editing the Watched-RED Proof markdown table.
    - Report: TESTS_ADDED, RED_COMMAND_RUN, RED_EVIDENCE, STATUS: DONE|BLOCKED.
 2) If STAGE_MODE=BUILD_GREEN_REFACTOR:
    - GREEN — minimal production code to satisfy existing RED tests, rerun full suite.
    - REFACTOR — only after full suite is green; preserve behavior.
+   - Append \`--status green\` (and \`--status refactor-done\` or \`--status refactor-deferred --refactor-rationale "<why>"\` after refactor) via \`cclaw-cli internal tdd-slice-record\`. The Vertical Slice Cycle markdown stays auto-derived from this sidecar.
    - Report: FILES_EDITED, GREEN_COMMAND_RUN, REFACTOR_NOTES, STATUS: DONE|BLOCKED.
 ${MARKDOWN_CODE_FENCE}
 

package/dist/content/templates.js

@@ -986,27 +986,17 @@ ${renderBehaviorAnchorTemplateLine("tdd")}
 |---|---|---|
 | S-1 |  | covered/out-of-scope because  |
 
-## Execution Posture
-- Posture: sequential | dependency-batched | blocked
-- Vertical-slice RED/GREEN/REFACTOR checkpoint plan:
-- Incremental commits: yes/no/deferred because
-
 ## RED Evidence
 | Slice | Test name | Command | Failure output summary |
 |---|---|---|---|
 | S-1 |  |  |  |
 
-## Acceptance Mapping
-| Vertical slice | Source item ID | Spec criterion ID |
-|---|---|---|
-| S-1 | SRC-1 | AC-1 |
-
-> Map each slice to the active track's source item: plan slice on standard/medium, or the \`Quick Reproduction Contract\` bug slice / spec acceptance item on quick.
+## Acceptance & Failure Map
+| Slice | Source ID | AC ID | Expected behavior | RED-link |
+|---|---|---|---|---|
+| S-1 | SRC-1 | AC-1 |  |  |
 
-## Failure Analysis
-| Slice | Expected missing behavior | Actual failure reason |
-|---|---|---|
-| S-1 |  |  |
+> Each slice maps to the active track's source item (plan slice on standard/medium, or the \`Quick Reproduction Contract\` bug slice / spec acceptance item on quick) and to a spec criterion. The RED-link column is satisfied by either a \`spanId:<id>\` from the delegation ledger, an \`<artifacts-dir>/<file>\` evidence pointer, or a \`redOutputRef\` recorded via \`cclaw-cli internal tdd-slice-record\` in the sidecar ledger.
 
 ## GREEN Evidence
 - Full suite command:

package/dist/delegation.d.ts

@@ -129,6 +129,17 @@ export type DelegationEntry = {
      * coherent successor chain.
      */
     supersededBy?: string;
+    /**
+     * v6.10.0 (P1) — repo-relative paths the delegated unit will edit.
+     * Used by the slice-implementer file-overlap scheduler to either
+     * auto-allow parallel dispatch (disjoint paths) or block the row
+     * with `DispatchOverlapError` (overlapping paths). For agents
+     * other than slice-implementer the field is advisory.
+     *
+     * keep in sync with the inline copy in
+     * `src/content/hooks.ts::delegationRecordScript`.
+     */
+    claimedPaths?: string[];
 };
 export declare const DELEGATION_LEDGER_SCHEMA_VERSION: 3;
 export type DelegationLedger = {
@@ -232,11 +243,99 @@ export declare class DispatchDuplicateError extends Error {
     });
 }
 /**
- * v6.8.0 — find the latest active span for a given `(stage, agent)`
+ * v6.10.0 (P1) — thrown by `validateFileOverlap` when a new
+ * `slice-implementer` is scheduled on a TDD stage with at least one
+ * `claimedPaths` entry that overlaps an active span. The cclaw scheduler
+ * auto-allows parallel dispatch when paths are disjoint, so an explicit
+ * overlap is treated as a serialization signal: the operator must wait
+ * for the existing span to terminate or pass `--allow-parallel`
+ * deliberately to acknowledge the conflict.
+ */
+export declare class DispatchOverlapError extends Error {
+    readonly existingSpanId: string;
+    readonly newSpanId: string;
+    readonly pair: {
+        stage: string;
+        agent: string;
+    };
+    readonly conflictingPaths: string[];
+    constructor(params: {
+        existingSpanId: string;
+        newSpanId: string;
+        pair: {
+            stage: string;
+            agent: string;
+        };
+        conflictingPaths: string[];
+    });
+}
+/**
+ * v6.10.0 (P2) — thrown when the count of active `slice-implementer`
+ * spans (after fold) reaches `MAX_PARALLEL_SLICE_IMPLEMENTERS` and a new
+ * scheduled row would push it past the cap. Cap can be overridden once
+ * via `--override-cap=N` on the hook flag or globally via
+ * `CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS=<N>` env.
+ */
+export declare class DispatchCapError extends Error {
+    readonly cap: number;
+    readonly active: number;
+    readonly pair: {
+        stage: string;
+        agent: string;
+    };
+    constructor(params: {
+        cap: number;
+        active: number;
+        pair: {
+            stage: string;
+            agent: string;
+        };
+    });
+}
+/**
+ * v6.10.0 (P2) — default cap on active `slice-implementer` spans in a
+ * single TDD run. Aligned with evanflow's parallel cap. Override via
+ * `CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS=<int>` (validated `>=1`).
+ */
+export declare const MAX_PARALLEL_SLICE_IMPLEMENTERS: 5;
+/**
+ * v6.10.0 (P1) — when scheduling a `slice-implementer` on a TDD stage,
+ * compare `claimedPaths` against every currently active span on the
+ * same `(stage, agent)` pair. Overlap → throw `DispatchOverlapError`;
+ * disjoint paths → return `{ autoParallel: true }` so the caller can
+ * mark the new entry `allowParallel = true` without explicit operator
+ * intent. When the agent is not a slice-implementer or no
+ * `claimedPaths` are supplied, the function returns
+ * `{ autoParallel: false }` and the legacy dedup path takes over.
+ */
+export declare function validateFileOverlap(stamped: DelegationEntry, activeEntries: DelegationEntry[]): {
+    autoParallel: boolean;
+};
+/**
+ * v6.10.0 (P2) — enforce the slice-implementer fan-out cap. The new
+ * scheduled row pushes the active count from N to N+1; if that would
+ * exceed the cap (default 5, env-overridable), throw `DispatchCapError`.
+ *
+ * Caller passes the already-folded list of active entries (latest row
+ * per spanId, ACTIVE statuses only). The function counts entries that
+ * match the agent on the same `stage`. The new row's own spanId is
+ * excluded so re-recording a `scheduled` doesn't trip the cap on a
+ * span that's already counted.
+ */
+export declare function validateFanOutCap(stamped: DelegationEntry, activeEntries: DelegationEntry[], override?: number | null): void;
+/**
+ * v6.9.0 — find the latest active span for a given `(stage, agent)`
  * pair in the supplied ledger entries. Returns the row whose latest
  * status (after the latest-by-spanId fold) is still in the active set
- * (`scheduled | launched | acknowledged`). Caller is responsible for
- * filtering to the current run.
+ * (`scheduled | launched | acknowledged`).
+ *
+ * Run-scope is **strict**: only entries whose `runId` matches the
+ * supplied `runId` are folded. Entries with empty/missing `runId`
+ * (legacy ledgers from v6.8 and earlier) are treated as NOT belonging
+ * to the current run, so they cannot keep an old span "active" across
+ * a fresh dispatch and trip a spurious `dispatch_duplicate`. This
+ * fixes R7: a slice-implementer that ran in run-1 must not block a
+ * slice-implementer scheduled in run-2.
  *
  * keep in sync with the inline copy in
  * `src/content/hooks.ts::delegationRecordScript`.

package/dist/delegation.js

@@ -224,7 +224,9 @@ function isDelegationEntry(value) {
         (o.skill === undefined || typeof o.skill === "string") &&
         (o.schemaVersion === undefined || o.schemaVersion === 1 || o.schemaVersion === 2 || o.schemaVersion === 3) &&
         (o.allowParallel === undefined || typeof o.allowParallel === "boolean") &&
-        (o.supersededBy === undefined || typeof o.supersededBy === "string"));
+        (o.supersededBy === undefined || typeof o.supersededBy === "string") &&
+        (o.claimedPaths === undefined ||
+            (Array.isArray(o.claimedPaths) && o.claimedPaths.every((item) => typeof item === "string"))));
 }
 function isDelegationDispatchSurface(value) {
     return typeof value === "string" && DELEGATION_DISPATCH_SURFACES.includes(value);
@@ -548,18 +550,159 @@ export class DispatchDuplicateError extends Error {
     }
 }
 /**
- * v6.8.0 — find the latest active span for a given `(stage, agent)`
+ * v6.10.0 (P1) — thrown by `validateFileOverlap` when a new
+ * `slice-implementer` is scheduled on a TDD stage with at least one
+ * `claimedPaths` entry that overlaps an active span. The cclaw scheduler
+ * auto-allows parallel dispatch when paths are disjoint, so an explicit
+ * overlap is treated as a serialization signal: the operator must wait
+ * for the existing span to terminate or pass `--allow-parallel`
+ * deliberately to acknowledge the conflict.
+ */
+export class DispatchOverlapError extends Error {
+    existingSpanId;
+    newSpanId;
+    pair;
+    conflictingPaths;
+    constructor(params) {
+        super(`dispatch_overlap — slice-implementer span ${params.newSpanId} claims path(s) ${params.conflictingPaths.join(", ")} already held by active spanId=${params.existingSpanId} on stage=${params.pair.stage}. ` +
+            `Wait for ${params.existingSpanId} to finish, dispatch a non-overlapping slice, or pass --allow-parallel to acknowledge the conflict.`);
+        this.name = "DispatchOverlapError";
+        this.existingSpanId = params.existingSpanId;
+        this.newSpanId = params.newSpanId;
+        this.pair = params.pair;
+        this.conflictingPaths = params.conflictingPaths;
+    }
+}
+/**
+ * v6.10.0 (P2) — thrown when the count of active `slice-implementer`
+ * spans (after fold) reaches `MAX_PARALLEL_SLICE_IMPLEMENTERS` and a new
+ * scheduled row would push it past the cap. Cap can be overridden once
+ * via `--override-cap=N` on the hook flag or globally via
+ * `CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS=<N>` env.
+ */
+export class DispatchCapError extends Error {
+    cap;
+    active;
+    pair;
+    constructor(params) {
+        super(`dispatch_cap — ${params.active} active ${params.pair.agent}(s) at the cap of ${params.cap}. ` +
+            `Complete one before scheduling another, or pass --override-cap=N (or CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS=N) to lift the cap for this run.`);
+        this.name = "DispatchCapError";
+        this.cap = params.cap;
+        this.active = params.active;
+        this.pair = params.pair;
+    }
+}
+/**
+ * v6.10.0 (P2) — default cap on active `slice-implementer` spans in a
+ * single TDD run. Aligned with evanflow's parallel cap. Override via
+ * `CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS=<int>` (validated `>=1`).
+ */
+export const MAX_PARALLEL_SLICE_IMPLEMENTERS = 5;
+function readMaxParallelOverrideFromEnv() {
+    const raw = process.env.CCLAW_MAX_PARALLEL_SLICE_IMPLEMENTERS;
+    if (typeof raw !== "string" || raw.trim().length === 0)
+        return null;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 1)
+        return null;
+    return parsed;
+}
+/**
+ * v6.10.0 (P1) — when scheduling a `slice-implementer` on a TDD stage,
+ * compare `claimedPaths` against every currently active span on the
+ * same `(stage, agent)` pair. Overlap → throw `DispatchOverlapError`;
+ * disjoint paths → return `{ autoParallel: true }` so the caller can
+ * mark the new entry `allowParallel = true` without explicit operator
+ * intent. When the agent is not a slice-implementer or no
+ * `claimedPaths` are supplied, the function returns
+ * `{ autoParallel: false }` and the legacy dedup path takes over.
+ */
+export function validateFileOverlap(stamped, activeEntries) {
+    if (stamped.agent !== "slice-implementer" || stamped.stage !== "tdd") {
+        return { autoParallel: false };
+    }
+    const newPaths = Array.isArray(stamped.claimedPaths) ? stamped.claimedPaths : [];
+    if (newPaths.length === 0) {
+        return { autoParallel: false };
+    }
+    const sameLane = activeEntries.filter((entry) => entry.stage === stamped.stage &&
+        entry.agent === stamped.agent &&
+        entry.spanId !== stamped.spanId);
+    if (sameLane.length === 0) {
+        return { autoParallel: true };
+    }
+    for (const existing of sameLane) {
+        const existingPaths = Array.isArray(existing.claimedPaths) ? existing.claimedPaths : [];
+        if (existingPaths.length === 0) {
+            // We can't prove disjoint without the other side declaring paths;
+            // be conservative and let the legacy dedup error path fire.
+            return { autoParallel: false };
+        }
+        const overlap = newPaths.filter((p) => existingPaths.includes(p));
+        if (overlap.length > 0) {
+            throw new DispatchOverlapError({
+                existingSpanId: existing.spanId ?? "unknown",
+                newSpanId: stamped.spanId ?? "unknown",
+                pair: { stage: stamped.stage, agent: stamped.agent },
+                conflictingPaths: overlap
+            });
+        }
+    }
+    return { autoParallel: true };
+}
+/**
+ * v6.10.0 (P2) — enforce the slice-implementer fan-out cap. The new
+ * scheduled row pushes the active count from N to N+1; if that would
+ * exceed the cap (default 5, env-overridable), throw `DispatchCapError`.
+ *
+ * Caller passes the already-folded list of active entries (latest row
+ * per spanId, ACTIVE statuses only). The function counts entries that
+ * match the agent on the same `stage`. The new row's own spanId is
+ * excluded so re-recording a `scheduled` doesn't trip the cap on a
+ * span that's already counted.
+ */
+export function validateFanOutCap(stamped, activeEntries, override) {
+    if (stamped.agent !== "slice-implementer" || stamped.stage !== "tdd")
+        return;
+    if (stamped.status !== "scheduled")
+        return;
+    const cap = (override !== null && override !== undefined && Number.isInteger(override) && override >= 1)
+        ? override
+        : (readMaxParallelOverrideFromEnv() ?? MAX_PARALLEL_SLICE_IMPLEMENTERS);
+    const sameLaneActive = activeEntries.filter((entry) => entry.stage === stamped.stage &&
+        entry.agent === stamped.agent &&
+        entry.spanId !== stamped.spanId);
+    if (sameLaneActive.length + 1 > cap) {
+        throw new DispatchCapError({
+            cap,
+            active: sameLaneActive.length,
+            pair: { stage: stamped.stage, agent: stamped.agent }
+        });
+    }
+}
+/**
+ * v6.9.0 — find the latest active span for a given `(stage, agent)`
  * pair in the supplied ledger entries. Returns the row whose latest
  * status (after the latest-by-spanId fold) is still in the active set
- * (`scheduled | launched | acknowledged`). Caller is responsible for
- * filtering to the current run.
+ * (`scheduled | launched | acknowledged`).
+ *
+ * Run-scope is **strict**: only entries whose `runId` matches the
+ * supplied `runId` are folded. Entries with empty/missing `runId`
+ * (legacy ledgers from v6.8 and earlier) are treated as NOT belonging
+ * to the current run, so they cannot keep an old span "active" across
+ * a fresh dispatch and trip a spurious `dispatch_duplicate`. This
+ * fixes R7: a slice-implementer that ran in run-1 must not block a
+ * slice-implementer scheduled in run-2.
  *
  * keep in sync with the inline copy in
  * `src/content/hooks.ts::delegationRecordScript`.
  */
 export function findActiveSpanForPair(stage, agent, runId, ledger) {
     const sameRun = ledger.entries.filter((entry) => {
-        if (entry.runId && entry.runId !== runId)
+        if (typeof entry.runId !== "string" || entry.runId.length === 0)
+            return false;
+        if (entry.runId !== runId)
             return false;
         return entry.stage === stage && entry.agent === agent;
     });
@@ -648,15 +791,30 @@ export async function appendDelegation(projectRoot, entry) {
             return;
         }
         validateMonotonicTimestamps(stamped, prior.entries);
-        if (stamped.status === "scheduled" && stamped.allowParallel !== true) {
-            const existing = findActiveSpanForPair(stamped.stage, stamped.agent, activeRunId, prior);
-            if (existing && existing.spanId && existing.spanId !== stamped.spanId) {
-                throw new DispatchDuplicateError({
-                    existingSpanId: existing.spanId,
-                    existingStatus: existing.status,
-                    newSpanId: stamped.spanId,
-                    pair: { stage: stamped.stage, agent: stamped.agent }
-                });
+        if (stamped.status === "scheduled") {
+            // v6.10.0 (P1+P2): for slice-implementer rows with declared
+            // claimedPaths, the file-overlap scheduler runs first. Disjoint
+            // paths auto-promote the row to allowParallel so the legacy
+            // dispatch_duplicate guard does not fire. Overlapping paths
+            // throw DispatchOverlapError. The fan-out cap then runs against
+            // the active set (excluding the new row's spanId).
+            const sameRunPrior = prior.entries.filter((entry) => entry.runId === activeRunId);
+            const activeForRun = computeActiveSubagents(sameRunPrior);
+            const overlap = validateFileOverlap(stamped, activeForRun);
+            if (overlap.autoParallel && stamped.allowParallel !== true) {
+                stamped.allowParallel = true;
+            }
+            validateFanOutCap(stamped, activeForRun);
+            if (stamped.allowParallel !== true) {
+                const existing = findActiveSpanForPair(stamped.stage, stamped.agent, activeRunId, prior);
+                if (existing && existing.spanId && existing.spanId !== stamped.spanId) {
+                    throw new DispatchDuplicateError({
+                        existingSpanId: existing.spanId,
+                        existingStatus: existing.status,
+                        newSpanId: stamped.spanId,
+                        pair: { stage: stamped.stage, agent: stamped.agent }
+                    });
+                }
             }
         }
         await appendDelegationEvent(projectRoot, eventFromEntry(stamped));