cclaw-cli 6.7.0 → 6.9.0

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

@@ -236,6 +236,8 @@ ${rows}
 Mandatory: ${mandatoryList}. Record lifecycle rows in \`${delegationLogRel}\` and append-only \`${delegationEventsRel}\` before completion.${runPhaseLegend}
 ### Harness Dispatch Contract — use true harness dispatch: Claude Task, Cursor generic dispatch, OpenCode \`.opencode/agents/<agent>.md\` via Task/@agent, Codex \`.codex/agents/<agent>.toml\`. Do not collapse OpenCode or Codex to role-switch by default. Worker ACK Contract: ACK must include \`spanId\`, \`dispatchId\`, \`dispatchSurface\`, \`agentDefinitionPath\`, and \`ackTs\`; never claim \`fulfillmentMode: "isolated"\` without matching lifecycle proof. Canonical helper (same flags as \`delegation-record.mjs --help\`): \`node .cclaw/hooks/delegation-record.mjs --stage=<stage> --agent=<agent> --mode=<mandatory|proactive> --status=<scheduled|launched|acknowledged|completed|...> --span-id=<id> --dispatch-id=<id> --dispatch-surface=<surface> --agent-definition-path=<path> [--ack-ts=<iso>] [--evidence-ref=<ref>] --json\`. Lifecycle order: \`scheduled → launched → acknowledged → completed\` on one span (reuse the same span id); completed isolated/generic rows require a prior ACK event for that span or \`--ack-ts=<iso>\`. For a partial audit trail, \`--repair --span-id=<id> --repair-reason="<why>"\` appends missing phases (see \`--help\`) instead of inventing shortcuts.
 
+If you must re-dispatch the same agent in the same stage before the previous span has a terminal row, pass \`--supersede=<prevSpanId>\` (closes the previous span as \`stale\` with \`supersededBy=<newSpanId>\`) or \`--allow-parallel\` (records both spans as concurrently active and tags the new row with \`allowParallel: true\`). Without one of those flags, a duplicate scheduled write on the same \`(stage, agent)\` pair fails with \`exit 2\` and \`{ ok: false, error: "dispatch_duplicate" }\`. Lifecycle timestamps are also validated: \`startTs ≤ launchedTs ≤ ackTs ≤ completedTs\` and per-span \`ts\` is non-decreasing — non-monotonic values fail with \`exit 2\` and \`{ ok: false, error: "delegation_timestamp_non_monotonic" }\`.
+
 ${perHarnessLifecycleRecipeBlock()}`;
 }
 function perHarnessLifecycleRecipeBlock() {

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

@@ -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.",

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.

package/dist/delegation.d.ts

@@ -116,6 +116,19 @@ export type DelegationEntry = {
      *   `dispatchSurface`, `agentDefinitionPath`, and ACK timestamp
      */
     schemaVersion?: 1 | 2 | 3;
+    /**
+     * v6.8.0 — when set, the operator explicitly opted into running this
+     * scheduled span concurrently with another active span on the same
+     * `(stage, agent)` pair. Bypasses the dispatch-dedup check.
+     */
+    allowParallel?: boolean;
+    /**
+     * v6.8.0 — set on synthetic terminal `stale` rows written via
+     * `--supersede=<prevSpanId>`. References the new spanId that
+     * superseded this span. Helps `/cc tree` and the linter report a
+     * coherent successor chain.
+     */
+    supersededBy?: string;
 };
 export declare const DELEGATION_LEDGER_SCHEMA_VERSION: 3;
 export type DelegationLedger = {
@@ -144,6 +157,98 @@ export declare function readDelegationEvents(projectRoot: string): Promise<{
     events: DelegationEvent[];
     corruptLines: number[];
 }>;
+/**
+ * Fold ledger entries to the latest row per `spanId` and keep only spans
+ * whose latest status is still active (`scheduled | launched |
+ * acknowledged`). Used by the `state/subagents.json` writer so the
+ * tracker never reports a span that already has a terminal row.
+ *
+ * Output is ordered by ascending `startTs ?? ts` so existing UI
+ * consumers see a stable presentation order.
+ *
+ * Rows without a `spanId` are skipped — they are not addressable by
+ * the tracker contract and would collide on the empty key.
+ *
+ * Callers are expected to pass entries already filtered to the active
+ * `runId`; cross-run rows are therefore not re-filtered here.
+ *
+ * keep in sync with the inline copy in
+ * `src/content/hooks.ts::delegationRecordScript`.
+ */
+export declare function computeActiveSubagents(entries: DelegationEntry[]): DelegationEntry[];
+/**
+ * v6.8.0 — thrown by `validateMonotonicTimestamps` when an incoming row
+ * would push a span's timeline backwards. Carries enough context that
+ * the CLI / hook surface can format a `delegation_timestamp_non_monotonic`
+ * JSON payload without re-deriving the offending field.
+ *
+ * keep in sync with the inline copy in
+ * `src/content/hooks.ts::delegationRecordScript`.
+ */
+export declare class DelegationTimestampError extends Error {
+    readonly field: string;
+    readonly actual: string;
+    readonly priorBound: string;
+    constructor(field: string, actual: string, priorBound: string);
+}
+/**
+ * v6.8.0 — enforce that lifecycle timestamps on a delegation span move
+ * forward (or stay equal). Validates both per-row invariants
+ * (`startTs ≤ launchedTs ≤ ackTs ≤ completedTs`) and a cross-row
+ * invariant: the union of prior rows for this `spanId` plus the
+ * incoming row must have non-decreasing `ts`.
+ *
+ * Equality is allowed because fast-completing dispatches legitimately
+ * collapse multiple lifecycle markers onto the same instant.
+ *
+ * keep in sync with the inline copy in
+ * `src/content/hooks.ts::delegationRecordScript`.
+ */
+export declare function validateMonotonicTimestamps(stamped: DelegationEntry, prior: DelegationEntry[]): void;
+/**
+ * v6.8.0 — thrown by `appendDelegation` when the operator opens a
+ * second `scheduled` span on the same `(stage, agent)` pair while an
+ * earlier span on the same pair is still active. Callers can catch and
+ * either pass the existing span id via `--supersede=<id>` (which
+ * pre-writes a synthetic `stale` row) or `--allow-parallel` to record
+ * concurrent spans intentionally.
+ */
+export declare class DispatchDuplicateError extends Error {
+    readonly existingSpanId: string;
+    readonly existingStatus: DelegationStatus;
+    readonly newSpanId: string;
+    readonly pair: {
+        stage: string;
+        agent: string;
+    };
+    constructor(params: {
+        existingSpanId: string;
+        existingStatus: DelegationStatus;
+        newSpanId: string;
+        pair: {
+            stage: string;
+            agent: string;
+        };
+    });
+}
+/**
+ * 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`).
+ *
+ * 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 declare function findActiveSpanForPair(stage: string, agent: string, runId: string, ledger: DelegationLedger): DelegationEntry | null;
 export declare function appendDelegation(projectRoot: string, entry: DelegationEntry): Promise<void>;
 /**
  * Aggregate the fulfillment mode cclaw expects for the active harness set.

package/dist/delegation.js

@@ -222,7 +222,9 @@ function isDelegationEntry(value) {
         retryOk &&
         (o.evidenceRefs === undefined || (Array.isArray(o.evidenceRefs) && o.evidenceRefs.every((item) => typeof item === "string"))) &&
         (o.skill === undefined || typeof o.skill === "string") &&
-        (o.schemaVersion === undefined || o.schemaVersion === 1 || o.schemaVersion === 2 || o.schemaVersion === 3));
+        (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"));
 }
 function isDelegationDispatchSurface(value) {
     return typeof value === "string" && DELEGATION_DISPATCH_SURFACES.includes(value);
@@ -378,10 +380,205 @@ async function appendDelegationEvent(projectRoot, event) {
     await fs.mkdir(path.dirname(filePath), { recursive: true });
     await fs.appendFile(filePath, `${JSON.stringify(event)}\n`, { encoding: "utf8", mode: 0o600 });
 }
+/**
+ * Effective timestamp used to order rows that share a `spanId`. Newest
+ * lifecycle column wins. Returns the empty string when nothing is set
+ * so the caller still has a stable lexicographic compare key.
+ *
+ * keep in sync with the inline copy in
+ * `src/content/hooks.ts::delegationRecordScript`.
+ */
+function effectiveSpanTs(entry) {
+    return entry.completedTs ?? entry.ackTs ?? entry.launchedTs ?? entry.endTs ?? entry.startTs ?? entry.ts ?? "";
+}
+const ACTIVE_DELEGATION_STATUSES = new Set([
+    "scheduled",
+    "launched",
+    "acknowledged"
+]);
+/**
+ * Fold ledger entries to the latest row per `spanId` and keep only spans
+ * whose latest status is still active (`scheduled | launched |
+ * acknowledged`). Used by the `state/subagents.json` writer so the
+ * tracker never reports a span that already has a terminal row.
+ *
+ * Output is ordered by ascending `startTs ?? ts` so existing UI
+ * consumers see a stable presentation order.
+ *
+ * Rows without a `spanId` are skipped — they are not addressable by
+ * the tracker contract and would collide on the empty key.
+ *
+ * Callers are expected to pass entries already filtered to the active
+ * `runId`; cross-run rows are therefore not re-filtered here.
+ *
+ * keep in sync with the inline copy in
+ * `src/content/hooks.ts::delegationRecordScript`.
+ */
+export function computeActiveSubagents(entries) {
+    const latestBySpan = new Map();
+    for (const entry of entries) {
+        if (!entry.spanId)
+            continue;
+        const existing = latestBySpan.get(entry.spanId);
+        if (!existing) {
+            latestBySpan.set(entry.spanId, entry);
+            continue;
+        }
+        const existingTs = effectiveSpanTs(existing);
+        const incomingTs = effectiveSpanTs(entry);
+        if (incomingTs >= existingTs) {
+            latestBySpan.set(entry.spanId, entry);
+        }
+    }
+    const folded = [];
+    for (const entry of latestBySpan.values()) {
+        if (ACTIVE_DELEGATION_STATUSES.has(entry.status)) {
+            folded.push(entry);
+        }
+    }
+    folded.sort((a, b) => {
+        const aKey = a.startTs ?? a.ts ?? "";
+        const bKey = b.startTs ?? b.ts ?? "";
+        if (aKey === bKey)
+            return 0;
+        return aKey < bKey ? -1 : 1;
+    });
+    return folded;
+}
+/**
+ * v6.8.0 — thrown by `validateMonotonicTimestamps` when an incoming row
+ * would push a span's timeline backwards. Carries enough context that
+ * the CLI / hook surface can format a `delegation_timestamp_non_monotonic`
+ * JSON payload without re-deriving the offending field.
+ *
+ * keep in sync with the inline copy in
+ * `src/content/hooks.ts::delegationRecordScript`.
+ */
+export class DelegationTimestampError extends Error {
+    field;
+    actual;
+    priorBound;
+    constructor(field, actual, priorBound) {
+        super(`delegation_timestamp_non_monotonic — ${field}: ${actual} < ${priorBound}`);
+        this.name = "DelegationTimestampError";
+        this.field = field;
+        this.actual = actual;
+        this.priorBound = priorBound;
+    }
+}
+/**
+ * v6.8.0 — enforce that lifecycle timestamps on a delegation span move
+ * forward (or stay equal). Validates both per-row invariants
+ * (`startTs ≤ launchedTs ≤ ackTs ≤ completedTs`) and a cross-row
+ * invariant: the union of prior rows for this `spanId` plus the
+ * incoming row must have non-decreasing `ts`.
+ *
+ * Equality is allowed because fast-completing dispatches legitimately
+ * collapse multiple lifecycle markers onto the same instant.
+ *
+ * keep in sync with the inline copy in
+ * `src/content/hooks.ts::delegationRecordScript`.
+ */
+export function validateMonotonicTimestamps(stamped, prior) {
+    const startTs = stamped.startTs;
+    if (stamped.launchedTs && startTs && stamped.launchedTs < startTs) {
+        throw new DelegationTimestampError("launchedTs", stamped.launchedTs, startTs);
+    }
+    if (stamped.ackTs) {
+        const ackBound = stamped.launchedTs ?? startTs;
+        if (ackBound && stamped.ackTs < ackBound) {
+            throw new DelegationTimestampError("ackTs", stamped.ackTs, ackBound);
+        }
+    }
+    if (stamped.completedTs) {
+        const completedBound = stamped.ackTs ?? stamped.launchedTs ?? startTs;
+        if (completedBound && stamped.completedTs < completedBound) {
+            throw new DelegationTimestampError("completedTs", stamped.completedTs, completedBound);
+        }
+    }
+    if (!stamped.spanId)
+        return;
+    const priorForSpan = prior.filter((entry) => entry.spanId === stamped.spanId);
+    if (priorForSpan.length === 0)
+        return;
+    const timeline = [...priorForSpan, stamped]
+        .map((entry) => ({ entry, ts: entry.ts ?? entry.startTs ?? "" }))
+        .filter((row) => row.ts.length > 0)
+        .sort((a, b) => (a.ts === b.ts ? 0 : a.ts < b.ts ? -1 : 1));
+    for (let i = 1; i < timeline.length; i += 1) {
+        const previous = timeline[i - 1];
+        const current = timeline[i];
+        if (current.ts < previous.ts) {
+            throw new DelegationTimestampError("ts", current.ts, previous.ts);
+        }
+    }
+    // Find the latest existing row by `ts` for the same spanId; if the
+    // new row's `ts` is older than that latest, the timeline regressed.
+    const latestPrior = priorForSpan
+        .map((entry) => entry.ts ?? entry.startTs ?? "")
+        .filter((ts) => ts.length > 0)
+        .sort()
+        .at(-1);
+    const stampedTs = stamped.ts ?? stamped.startTs ?? "";
+    if (latestPrior && stampedTs && stampedTs < latestPrior) {
+        throw new DelegationTimestampError("ts", stampedTs, latestPrior);
+    }
+}
+/**
+ * v6.8.0 — thrown by `appendDelegation` when the operator opens a
+ * second `scheduled` span on the same `(stage, agent)` pair while an
+ * earlier span on the same pair is still active. Callers can catch and
+ * either pass the existing span id via `--supersede=<id>` (which
+ * pre-writes a synthetic `stale` row) or `--allow-parallel` to record
+ * concurrent spans intentionally.
+ */
+export class DispatchDuplicateError extends Error {
+    existingSpanId;
+    existingStatus;
+    newSpanId;
+    pair;
+    constructor(params) {
+        super(`dispatch_duplicate — already-active spanId=${params.existingSpanId} (status=${params.existingStatus}) on stage=${params.pair.stage}, agent=${params.pair.agent}. ` +
+            `pass --supersede=${params.existingSpanId} to close the previous span as stale, or --allow-parallel to record both as concurrent.`);
+        this.name = "DispatchDuplicateError";
+        this.existingSpanId = params.existingSpanId;
+        this.existingStatus = params.existingStatus;
+        this.newSpanId = params.newSpanId;
+        this.pair = params.pair;
+    }
+}
+/**
+ * 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`).
+ *
+ * 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 (typeof entry.runId !== "string" || entry.runId.length === 0)
+            return false;
+        if (entry.runId !== runId)
+            return false;
+        return entry.stage === stage && entry.agent === agent;
+    });
+    for (const entry of computeActiveSubagents(sameRun)) {
+        return entry;
+    }
+    return null;
+}
 async function writeSubagentTracker(projectRoot, entries) {
-    const active = entries
-        .filter((entry) => entry.status === "scheduled" || entry.status === "launched" || entry.status === "acknowledged")
-        .map((entry) => ({
+    const active = computeActiveSubagents(entries).map((entry) => ({
         spanId: entry.spanId,
         dispatchId: entry.dispatchId,
         workerRunId: entry.workerRunId,
@@ -392,7 +589,8 @@ async function writeSubagentTracker(projectRoot, entries) {
         agentDefinitionPath: entry.agentDefinitionPath,
         startedAt: entry.startTs,
         launchedAt: entry.launchedTs,
-        acknowledgedAt: entry.ackTs
+        acknowledgedAt: entry.ackTs,
+        allowParallel: entry.allowParallel
     }));
     await writeFileSafe(subagentsStatePath(projectRoot), `${JSON.stringify({ active, updatedAt: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
 }
@@ -401,7 +599,20 @@ export async function appendDelegation(projectRoot, entry) {
     await withDirectoryLock(delegationLockPath(projectRoot), async () => {
         const filePath = delegationLogPath(projectRoot);
         const prior = await readDelegationLedger(projectRoot);
-        const startTs = entry.startTs ?? entry.ts ?? new Date().toISOString();
+        // Span start anchor: prefer explicit `startTs`; otherwise fall back to
+        // the earliest provided lifecycle marker so the monotonic validator
+        // never sees a synthetic `now` overshoot a real event timestamp.
+        const lifecycleCandidates = [
+            entry.startTs,
+            entry.launchedTs,
+            entry.ackTs,
+            entry.completedTs,
+            entry.ts
+        ].filter((value) => typeof value === "string" && value.length > 0);
+        const earliestLifecycle = lifecycleCandidates.length > 0
+            ? lifecycleCandidates.reduce((min, candidate) => (candidate < min ? candidate : min))
+            : undefined;
+        const startTs = entry.startTs ?? earliestLifecycle ?? new Date().toISOString();
         if (entry.status === "waived" && !hasValidWaiverReason(entry.waiverReason)) {
             throw new Error("waived delegation entries require a non-empty waiverReason");
         }
@@ -445,6 +656,18 @@ export async function appendDelegation(projectRoot, entry) {
         if (prior.entries.some((existing) => existing.spanId === stamped.spanId && existing.status === stamped.status)) {
             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 }
+                });
+            }
+        }
         await appendDelegationEvent(projectRoot, eventFromEntry(stamped));
         const ledger = {
             runId: activeRunId,

package/dist/early-loop.js

@@ -137,9 +137,23 @@ export function parseEarlyLoopLog(text, options = {}) {
                 continue;
             }
         }
+        // v6.9.0 schema repair: legacy logs may carry rows with no runId
+        // (the prior parser silently coerced them to "active", which then
+        // collided across runs). Surface a structured warning on read but
+        // skip the row so derived status doesn't fold cross-run state.
+        // Writers must always provide a runId (enforced upstream in the
+        // CLI/hook surface).
+        if (runId.length === 0) {
+            issues?.push({
+                lineNumber,
+                reason: "missing-runId: legacy entry skipped to avoid cross-run pollution",
+                rawLine: raw
+            });
+            continue;
+        }
         entries.push({
             ts: normalizeText(parsed.ts, ""),
-            runId: runId.length > 0 ? runId : "active",
+            runId,
             stage: stage.length > 0 ? stage : "brainstorm",
             iteration,
             concerns,

package/dist/gate-evidence.js

@@ -9,8 +9,8 @@ import { readDelegationLedger } from "./delegation.js";
 import { exists } from "./fs-utils.js";
 import { computeEarlyLoopStatus, isEarlyLoopStage, normalizeEarlyLoopMaxIterations } from "./early-loop.js";
 import { detectPublicApiChanges } from "./internal/detect-public-api-changes.js";
+import { detectSupplyChainChanges } from "./internal/detect-supply-chain-changes.js";
 import { readFlowState, writeFlowState } from "./runs.js";
-import { parseTddCycleLog, validateTddCycleOrder } from "./tdd-cycle.js";
 import { validateTddVerificationEvidence } from "./tdd-verification-evidence.js";
 async function currentStageArtifactExists(projectRoot, stage, track) {
     const resolved = await resolveArtifactPath(stage, {
@@ -376,35 +376,20 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState, opt
         }
         if (stage === "tdd") {
             const docsDriftDetection = await detectPublicApiChanges(projectRoot);
-            if (docsDriftDetection.triggered) {
+            const supplyChainDetection = await detectSupplyChainChanges(projectRoot);
+            if (docsDriftDetection.triggered || supplyChainDetection.triggered) {
                 const ledger = await readDelegationLedger(projectRoot);
                 const hasDocUpdaterCompletion = ledger.entries.some((entry) => entry.runId === flowState.activeRunId &&
                     entry.stage === "tdd" &&
                     entry.agent === "doc-updater" &&
                     entry.status === "completed");
                 if (!hasDocUpdaterCompletion) {
-                    issues.push(`tdd docs drift gate blocked (tdd_docs_drift_check): public surface changes detected (${docsDriftDetection.changedFiles.join(", ")}) but no completed doc-updater delegation exists for the active run.`);
-                }
-            }
-            const tddLogPath = path.join(projectRoot, RUNTIME_ROOT, "state", "tdd-cycle-log.jsonl");
-            if (await exists(tddLogPath)) {
-                try {
-                    const tddLogRaw = await fs.readFile(tddLogPath, "utf8");
-                    const parsedCycles = parseTddCycleLog(tddLogRaw);
-                    const tddOrderValidation = validateTddCycleOrder(parsedCycles, {
-                        runId: flowState.activeRunId
-                    });
-                    if (!tddOrderValidation.ok) {
-                        const details = [...tddOrderValidation.issues];
-                        if (tddOrderValidation.openRedSlices.length > 0) {
-                            details.push(`open red slices: ${tddOrderValidation.openRedSlices.join(", ")}`);
-                        }
-                        issues.push(`tdd cycle order gate blocked: ${details.join("; ")}`);
+                    if (docsDriftDetection.triggered) {
+                        issues.push(`tdd docs drift gate blocked (tdd_docs_drift_check): public surface changes detected (${docsDriftDetection.changedFiles.join(", ")}) but no completed doc-updater delegation exists for the active run.`);
+                    }
+                    if (supplyChainDetection.triggered) {
+                        issues.push(`tdd docs drift gate blocked (tdd_docs_drift_check): supply-chain changes detected (${supplyChainDetection.changedFiles.join(", ")}) but no completed doc-updater delegation exists for the active run.`);
                     }
-                }
-                catch (err) {
-                    const reason = err instanceof Error ? err.message : String(err);
-                    issues.push(`tdd cycle order gate blocked: unable to read tdd-cycle-log.jsonl (${reason}).`);
                 }
             }
         }
@@ -477,6 +462,13 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState, opt
             forcingPending: floor.forcingPending,
             noNewDecisions: floor.noNewDecisions
         };
+        // v6.9.0 — when the QA log floor is blocking, mirror that decision into
+        // `gates.issues` so the harness has a single structured source of truth
+        // for "this stage is blocked". The `qa_log_unconverged` linter rule
+        // remains the verbose detail/fallback channel.
+        if (qaLogFloor.blocking) {
+            issues.push(`qa log floor blocked (qa_log_unconverged): ${qaLogFloor.count}/${qaLogFloor.min} entries on stage "${stage}" (track=${flowState.track}, discoveryMode=${flowState.discoveryMode ?? "default"}). Continue elicitation or pass --skip-questions to record the stop.`);
+        }
     }
     return {
         ok: issues.length === 0,

package/dist/harness-adapters.js

@@ -293,9 +293,11 @@ export function harnessesByTier() {
     });
 }
 function ironLawsAgentsMdBlock() {
+    // v6.9.0: keep this set in sync with `ironLawsSkillMarkdown()` —
+    // post-Phase A, only `stop-clean-or-handoff` is still hook-enforced
+    // (Stop hook). All other iron laws live in stage HARD-GATE blocks.
     const enforcedLawIds = new Set([
-        "stop-clean-or-handoff",
-        "review-coverage-complete-before-ship"
+        "stop-clean-or-handoff"
     ]);
     const enforcedRows = IRON_LAWS
         .filter((law) => enforcedLawIds.has(law.id))