cclaw-cli 6.12.0 → 6.13.0

package/dist/artifact-linter/plan.js

@@ -4,9 +4,9 @@ import { exists } from "../fs-utils.js";
 import { FORBIDDEN_PLACEHOLDER_TOKENS, CONFIDENCE_FINDING_REGEX_SOURCE } from "../content/skills.js";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { PLAN_SPLIT_SMALL_PLAN_THRESHOLD, parseImplementationUnits } from "../internal/plan-split-waves.js";
+import { PLAN_SPLIT_SMALL_PLAN_THRESHOLD, parseImplementationUnits, parseImplementationUnitParallelFields } from "../internal/plan-split-waves.js";
 export async function lintPlanStage(ctx) {
-    const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
+    const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride, legacyContinuation } = ctx;
     evaluateInvestigationTrace(ctx, "Implementation Units");
     const strictPlanGuards = parsedFrontmatter.hasFrontmatter ||
         headingPresent(sections, "Plan Quality Scan") ||
@@ -219,4 +219,62 @@ export async function lintPlanStage(ctx) {
                 : `Unwaived FAIL/PARTIAL statuses: ${layeredDocumentReview.failOrPartialWithoutWaiver.join(", ")}.`
         });
     }
+    const planUnits = parseImplementationUnits(raw);
+    const parallelMetaApplies = strictPlanGuards && planUnits.length > 0;
+    if (parallelMetaApplies) {
+        const metaRulesRequired = !legacyContinuation;
+        const missingDepends = [];
+        const missingPaths = [];
+        const missingParallelMeta = [];
+        for (const unit of planUnits) {
+            const id = unit.id;
+            if (!/\bdependsOn\s*:/iu.test(unit.body)) {
+                missingDepends.push(id);
+            }
+            if (!/\bclaimedPaths\s*:/iu.test(unit.body)) {
+                missingPaths.push(id);
+            }
+            if (!/\bparallelizable\s*:/iu.test(unit.body) || !/\briskTier\s*:/iu.test(unit.body)) {
+                missingParallelMeta.push(id);
+            }
+        }
+        findings.push({
+            section: "plan_units_missing_dependsOn",
+            required: metaRulesRequired,
+            rule: "Every implementation unit must declare `dependsOn:` (v6.13.0) — use comma-separated unit ids or `none`.",
+            found: missingDepends.length === 0,
+            details: missingDepends.length === 0
+                ? "All implementation units declare dependsOn."
+                : `Missing dependsOn on: ${missingDepends.join(", ")}. Remediation: add a bullet \`- **dependsOn:** U-2, U-3\` or \`- **dependsOn:** none\`.`
+        });
+        findings.push({
+            section: "plan_units_missing_claimedPaths",
+            required: metaRulesRequired,
+            rule: "Every implementation unit must declare explicit `claimedPaths:` predictions for parallel scheduling (v6.13.0).",
+            found: missingPaths.length === 0,
+            details: missingPaths.length === 0
+                ? "All implementation units declare claimedPaths."
+                : `Missing claimedPaths on: ${missingPaths.join(", ")}. Remediation: add \`- **claimedPaths:** path/a, path/b\` (repo-relative globs or files).`
+        });
+        findings.push({
+            section: "plan_units_missing_parallel_metadata",
+            required: metaRulesRequired,
+            rule: "Every implementation unit must declare `parallelizable:` and `riskTier:` (low|standard|high) (v6.13.0).",
+            found: missingParallelMeta.length === 0,
+            details: missingParallelMeta.length === 0
+                ? "All implementation units carry parallelizable + riskTier."
+                : `Missing parallel metadata on: ${missingParallelMeta.join(", ")}. Remediation: add \`- **parallelizable:** true|false\` and \`- **riskTier:** low|standard|high\`.`
+        });
+        const parallelizableCount = planUnits.filter((u) => parseImplementationUnitParallelFields(u).parallelizable).length;
+        const advisorySerial = parallelizableCount === 0 && planUnits.length > 1;
+        findings.push({
+            section: "plan_no_parallel_lanes_detected",
+            required: false,
+            rule: "When multiple independent units exist, consider marking at least one `parallelizable: true` with disjoint claimedPaths.",
+            found: !advisorySerial,
+            details: advisorySerial
+                ? "All units are marked parallelizable false; scheduler will serialize. If surfaces are independent, opt units into parallelism explicitly."
+                : "Parallel-ready units detected or plan is single-unit."
+        });
+    }
 }

package/dist/artifact-linter/shared.d.ts

@@ -630,4 +630,13 @@ export interface StageLintContext {
      * expansion-strategist delegation) from required → advisory.
      */
     taskClass: "software-standard" | "software-trivial" | "software-bugfix" | null;
+    /**
+     * v6.13.0 — when true, plan parallel-metadata rules downgrade to advisory
+     * for legacy continuation projects (hox-style).
+     */
+    legacyContinuation: boolean;
+    /**
+     * v6.13.0 — effective worktree execution mode for TDD linters.
+     */
+    worktreeExecutionMode: "single-tree" | "worktree-first";
 }

package/dist/artifact-linter/spec.js

@@ -127,4 +127,18 @@ export async function lintSpecStage(ctx) {
                 : `Unwaived FAIL/PARTIAL statuses: ${layeredDocumentReview.failOrPartialWithoutWaiver.join(", ")}.`
         });
     }
+    const acceptanceCriteriaBody = sectionBodyByName(sections, "Acceptance Criteria");
+    if (acceptanceCriteriaBody !== null && /\|/u.test(acceptanceCriteriaBody)) {
+        const hasParallel = /\bparallelSafe\b/iu.test(acceptanceCriteriaBody);
+        const hasTouch = /\btouchSurface\b/iu.test(acceptanceCriteriaBody);
+        findings.push({
+            section: "spec_acs_not_sliceable",
+            required: false,
+            rule: "Acceptance criteria should declare `parallelSafe` and `touchSurface` per row (v6.13.0) so plan/TDD can schedule slices safely.",
+            found: hasParallel && hasTouch,
+            details: hasParallel && hasTouch
+                ? "Acceptance Criteria mentions parallelSafe and touchSurface."
+                : "Add columns or inline markers for parallelSafe (true|false) and touchSurface (short area description) for each AC."
+        });
+    }
 }

package/dist/artifact-linter/tdd.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { readDelegationLedger } from "../delegation.js";
+import { readDelegationLedger, readDelegationEvents } from "../delegation.js";
 import { evaluateInvestigationTrace, sectionBodyByName } from "./shared.js";
 const SLICE_SUMMARY_START = "<!-- auto-start: tdd-slice-summary -->";
 const SLICE_SUMMARY_END = "<!-- auto-end: tdd-slice-summary -->";
@@ -26,8 +26,7 @@ const SLICES_INDEX_END = "<!-- auto-end: slices-index -->";
  *    via `## Slices Index`.
  */
 export async function lintTddStage(ctx) {
-    const { projectRoot, discoveryMode, raw, absFile, sections, findings, parsedFrontmatter } = ctx;
-    void projectRoot;
+    const { projectRoot, discoveryMode, raw, absFile, sections, findings, parsedFrontmatter, worktreeExecutionMode } = ctx;
     void parsedFrontmatter;
     evaluateInvestigationTrace(ctx, "Watched-RED Proof");
     const delegationLedger = await readDelegationLedger(ctx.projectRoot);
@@ -202,6 +201,101 @@ export async function lintTddStage(ctx) {
     if (cutoverFinding) {
         findings.push(cutoverFinding);
     }
+    const { events: jsonlEvents, fanInAudits } = await readDelegationEvents(projectRoot);
+    const runEvents = jsonlEvents.filter((e) => e.runId === delegationLedger.runId);
+    if (eventsActive && worktreeExecutionMode === "worktree-first") {
+        const terminalPhases = new Set([
+            "green",
+            "refactor",
+            "refactor-deferred",
+            "resolve-conflict"
+        ]);
+        const missingClaim = new Set();
+        for (const ev of runEvents) {
+            if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
+                continue;
+            if (ev.status !== "completed" && ev.status !== "failed")
+                continue;
+            if (!ev.phase || !terminalPhases.has(ev.phase))
+                continue;
+            const tok = ev.claimToken?.trim() ?? "";
+            if (tok.length === 0 && typeof ev.sliceId === "string") {
+                missingClaim.add(ev.sliceId);
+            }
+        }
+        if (missingClaim.size > 0) {
+            findings.push({
+                section: "tdd_slice_claim_token_missing",
+                required: true,
+                rule: "Worktree-first: terminal slice-implementer rows must echo --claim-token. Remediation: pass the same --claim-token used on the scheduled row for every completed/failed terminal phase.",
+                found: false,
+                details: `Slices missing claim token on terminal rows: ${[...missingClaim].join(", ")}.`
+            });
+        }
+        const missingLane = new Set();
+        for (const ev of runEvents) {
+            if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
+                continue;
+            if (ev.status !== "completed" || ev.phase !== "green")
+                continue;
+            if (!ev.ownerLaneId?.trim() && typeof ev.sliceId === "string") {
+                missingLane.add(ev.sliceId);
+            }
+        }
+        if (missingLane.size > 0) {
+            findings.push({
+                section: "tdd_slice_worktree_metadata_missing",
+                required: true,
+                rule: "Worktree-first: completed GREEN rows must record --lane-id (ownerLaneId) for the lane worktree.",
+                found: false,
+                details: `Slices missing ownerLaneId on GREEN completion: ${[...missingLane].join(", ")}.`
+            });
+        }
+        const conflictSlices = [
+            ...new Set([
+                ...runEvents
+                    .filter((e) => e.integrationState === "conflict")
+                    .map((e) => e.sliceId)
+                    .filter((s) => typeof s === "string"),
+                ...fanInAudits
+                    .filter((a) => a.runId === delegationLedger.runId &&
+                    a.event === "cclaw_fanin_conflict" &&
+                    Array.isArray(a.sliceIds))
+                    .flatMap((a) => a.sliceIds ?? [])
+            ].filter((s) => typeof s === "string" && s.length > 0))
+        ];
+        if (conflictSlices.length > 0) {
+            findings.push({
+                section: "tdd_fanin_conflict_unresolved",
+                required: true,
+                rule: "Resolve fan-in conflicts before stage-complete: dispatch slice-implementer --phase resolve-conflict or abandon the slice explicitly.",
+                found: false,
+                details: `integrationState=conflict for slice(s): ${conflictSlices.join(", ")}. Remediation: finish deterministic fan-in or mark integrationState=resolved after manual merge evidence.`
+            });
+        }
+        const now = Date.now();
+        const leaseStale = new Set();
+        for (const ev of runEvents) {
+            if (typeof ev.leasedUntil !== "string")
+                continue;
+            const until = Date.parse(ev.leasedUntil);
+            if (!Number.isFinite(until) || until >= now)
+                continue;
+            if (ev.leaseState === "reclaimed" || ev.leaseState === "released")
+                continue;
+            if (typeof ev.sliceId === "string")
+                leaseStale.add(ev.sliceId);
+        }
+        if (leaseStale.size > 0) {
+            findings.push({
+                section: "tdd_lease_expired_unreclaimed",
+                required: true,
+                rule: "Leases past leasedUntil must be reclaimed or released. Remediation: run scheduler reclaim or emit leaseState=reclaimed audit rows after controller action.",
+                found: false,
+                details: `Expired leases not reclaimed for slice(s): ${[...leaseStale].join(", ")}.`
+            });
+        }
+    }
     const assertionBody = sectionBodyByName(sections, "Assertion Correctness Notes");
     if (assertionBody !== null) {
         const tableRows = assertionBody.split("\n").filter((line) => /^\|/u.test(line));

package/dist/artifact-linter.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveArtifactPath as resolveStageArtifactPath } from "./artifact-paths.js";
+import { effectiveWorktreeExecutionMode } from "./flow-state.js";
 import { exists } from "./fs-utils.js";
 import { stageSchema } from "./content/stage-schema.js";
 import { readFlowState } from "./run-persistence.js";
@@ -121,6 +122,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
     let activeRunId = null;
     let completedStagesForAudit = [];
     let completedStageMetaForAudit;
+    let legacyContinuation = false;
+    let worktreeExecutionMode = "single-tree";
     try {
         const flowState = await readFlowState(projectRoot);
         const hint = flowState.interactionHints?.[stage];
@@ -131,6 +134,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         activeRunId = flowState.activeRunId ?? null;
         completedStagesForAudit = flowState.completedStages;
         completedStageMetaForAudit = flowState.completedStageMeta;
+        legacyContinuation = flowState.legacyContinuation === true;
+        worktreeExecutionMode = effectiveWorktreeExecutionMode(flowState);
     }
     catch {
         activeStageFlags = [];
@@ -139,6 +144,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         activeRunId = null;
         completedStagesForAudit = [];
         completedStageMetaForAudit = undefined;
+        legacyContinuation = false;
+        worktreeExecutionMode = "single-tree";
     }
     for (const extra of options.extraStageFlags ?? []) {
         if (typeof extra === "string" && extra.length > 0 && !activeStageFlags.includes(extra)) {
@@ -274,7 +281,9 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         isTrivialOverride,
         overrideSet,
         activeStageFlags,
-        taskClass
+        taskClass,
+        legacyContinuation,
+        worktreeExecutionMode
     };
     switch (stage) {
         case "brainstorm":

package/dist/content/hooks.js

@@ -350,6 +350,11 @@ function usage() {
     "  --slice=<id>              TDD slice identifier (e.g. S-1) used by the linter to auto-derive the Watched-RED + Vertical Slice Cycle tables.",
     "  --phase=<phase>           one of " + VALID_DELEGATION_PHASES.join(", ") + ". Pair with --slice to record a TDD slice phase event.",
     "  --refactor-rationale=<t>  required when --phase=refactor-deferred unless --evidence-ref carries the rationale text.",
+    "  --claim-token=<opaque>    v6.13 — required for worktree-first slice-implementer schedules with --slice (echo on all terminal rows for the span).",
+    "  --lane-id=<id>            v6.13 — worktree lane id (ownerLaneId metadata).",
+    "  --lease-until=<iso>       v6.13 — ISO8601 lease expiry for reclaim tooling.",
+    "  --depends-on=<a,b>       v6.13 — comma-separated plan unit ids for scheduler diagnostics.",
+    "  --integration-state=<s>  v6.13 — one of pending|applied|conflict|resolved|abandoned.",
     ""
   ].join("\\n") + "\\n");
 }
@@ -484,6 +489,42 @@ function buildRow(args, status, runId, now, options) {
       resolvedEvidenceRefs = [rationale, ...resolvedEvidenceRefs];
     }
   }
+  const integrationStateRaw =
+    typeof args["integration-state"] === "string" ? args["integration-state"].trim() : "";
+  const integrationStateAllowed = new Set([
+    "pending",
+    "applied",
+    "conflict",
+    "resolved",
+    "abandoned"
+  ]);
+  const integrationState =
+    integrationStateRaw.length > 0 && integrationStateAllowed.has(integrationStateRaw)
+      ? integrationStateRaw
+      : undefined;
+  const claimToken =
+    typeof args["claim-token"] === "string" && args["claim-token"].trim().length > 0
+      ? args["claim-token"].trim()
+      : undefined;
+  const ownerLaneId =
+    typeof args["lane-id"] === "string" && args["lane-id"].trim().length > 0
+      ? args["lane-id"].trim()
+      : undefined;
+  const leasedUntil =
+    typeof args["lease-until"] === "string" && args["lease-until"].trim().length > 0
+      ? args["lease-until"].trim()
+      : undefined;
+  const dependsOnRaw =
+    typeof args["depends-on"] === "string" ? args["depends-on"].trim() : "";
+  const dependsOn =
+    dependsOnRaw.length > 0
+      ? dependsOnRaw
+        .split(",")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0)
+      : undefined;
+  const leaseState =
+    leasedUntil && status === "scheduled" ? "claimed" : undefined;
   return {
     stage: args.stage,
     agent: args.agent,
@@ -508,7 +549,13 @@ function buildRow(args, status, runId, now, options) {
     allowParallel: args["allow-parallel"] === true ? true : undefined,
     claimedPaths: claimedPaths.length > 0 ? claimedPaths : undefined,
     sliceId,
-    phase
+    phase,
+    claimToken,
+    ownerLaneId,
+    leasedUntil,
+    leaseState,
+    dependsOn,
+    integrationState
   };
 }
 

package/dist/content/skills.js

@@ -224,7 +224,11 @@ Task("slice-documenter  --slice S-2 --phase doc   --paths <artifacts-dir>/tdd-sl
 \`\`\`
 Launch ALL Phase B pairs in ONE message. **Never serialize independent work.**
 
-**Fan-in** — when 2+ \`slice-implementer\` rows complete in a wave, dispatch \`integration-overseer\` to verify cohesion contract (shared types, touchpoints, invariants, integration tests).
+**Phase C — REFACTOR per slice** — after GREEN+DOC evidence is recorded, dispatch \`slice-implementer --phase refactor\` or \`--phase refactor-deferred\` per slice (may be parallelized when lanes stay disjoint).
+
+**Fan-in (v6.13.0+, worktree-first default)** — each \`slice-implementer\` GREEN row should record \`--claim-token\`, \`--lane-id\`, and \`--lease-until\` per the delegation hook. On successful TDD stage-complete, the runtime performs deterministic \`git apply --3way\` fan-in from each lane worktree onto the current integration branch (no \`-X ours/theirs\`). Conflicts emit \`cclaw_fanin_conflict\` audit rows; resolve with \`slice-implementer --phase resolve-conflict\` then re-run stage-complete. When 2+ parallel lanes finish a wave, still dispatch \`integration-overseer\` so cohesion-contract evidence exists before review.
+
+**slice-documenter** may mark prose \`provisional\` until GREEN is proven; finalize \`tdd-slices/S-<id>.md\` after GREEN evidence is recorded.
 
 `;
 }

package/dist/content/stages/plan.js

@@ -46,6 +46,7 @@ export const PLAN = {
             "Slice into vertical tasks — each task targets 2-5 minutes, produces one testable outcome, and touches one coherent area.",
             "Task Contract — every task has one coherent outcome, AC mapping, exact verification command/manual step, and expected evidence snippet or pass condition. Avoid vague `run tests` wording.",
             "Annotate slice-review metadata — task rows may carry `touchCount` (rough number of files expected to change), `touchPaths` (glob hints, e.g. `migrations/**`, `src/auth/**`), and optional `highRisk: true` to force a review pass. These fields feed the TDD stage's Per-Slice Review point.",
+            "For every `### Implementation Unit U-<n>`, declare v6.13.0 parallel metadata bullets: `id`, `dependsOn` (unit ids or `none`), `claimedPaths` (repo-relative), `parallelizable` (true|false), `riskTier` (low|standard|high), optional `lane` — used for conflict-aware wave plans and schedulers.",
             "Map scope Locked Decisions — every D-XX ID from scope is referenced by at least one plan task (or explicitly marked deferred with reason).",
             "Run anti-placeholder + anti-scope-reduction scans — block `TODO/TBD/...` and phrasing like `v1`, `for now`, `later` for locked boundaries.",
             "Define validation points — mark where progress must be checked before continuing, with concrete command and expected evidence.",
@@ -135,7 +136,7 @@ export const PLAN = {
             { section: "Locked Decision Coverage", required: false, validationRule: "Every locked decision ID (D-XX) from scope is listed with linked task IDs or explicit defer rationale." },
             { section: "Risk Assessment", required: false, validationRule: "If present: per-task or per-batch risk identification with likelihood, impact, and mitigation strategy." },
             { section: "Boundary Map", required: false, validationRule: "If present: per-batch or per-task interface contracts listing what each task produces (exports) and consumes (imports) from other tasks." },
-            { section: "Implementation Units", required: false, validationRule: "If present: each `### Implementation Unit U-<n>` includes Goal, Files, Approach, Test scenarios, and Verification fields." },
+            { section: "Implementation Units", required: false, validationRule: "If present: each `### Implementation Unit U-<n>` includes Goal, Files, Approach, Test scenarios, Verification fields, plus v6.13.0 bullets (`id`, `dependsOn`, `claimedPaths`, `parallelizable`, `riskTier`, optional `lane`)." },
             { section: "Calibrated Findings", required: false, validationRule: "If present: either `None this stage` or one or more lines in `[P1|P2|P3] (confidence: <n>/10) <path>[:<line>] — <description>` format." },
             { section: "Regression Iron Rule", required: false, validationRule: "If present: includes `Iron rule acknowledged: yes`." },
             { section: "WAIT_FOR_CONFIRM", required: true, validationRule: "Explicit marker present. Status: pending until user approves." },

package/dist/content/stages/spec.js

@@ -62,7 +62,7 @@ export const SPEC = {
             "Define measurable acceptance criteria.",
             "Capture constraints, assumptions, and edge cases.",
             "Review assumptions before finalization: source/confidence, validation path, and accepted/rejected/open disposition.",
-            "Build Acceptance Mapping: AC -> design decision -> observable evidence -> verification method -> likely test level.",
+            "Annotate parallel-slice metadata on each acceptance criterion: `parallelSafe` (true|false) and `touchSurface` (repo-relative paths/modules expected to change) so downstream plan units and TDD lanes stay conflict-aware (v6.13.0).",
             "Confirm every verification method is concrete enough for plan/TDD to use later.",
             "Present acceptance criteria to the user in 3-5-item batches, pausing for explicit ACK between batches (see Interaction Protocol).",
             "Write spec artifact and request approval."
@@ -118,7 +118,7 @@ export const SPEC = {
         },
         artifactValidation: [
             { section: "Upstream Handoff", required: false, validationRule: "Summarizes scope/design decisions, constraints, open questions, and explicit drift before acceptance criteria." },
-            { section: "Acceptance Criteria", required: true, validationRule: "Each criterion is observable, measurable, and falsifiable. Standard track should include Requirement Ref and Design Decision Ref columns; quick track may instead link each AC to the reproduction contract or bug slice. AC IDs (AC-1, AC-2…) are stable across revisions — dropped ACs stay with Priority `DROPPED`." },
+            { section: "Acceptance Criteria", required: true, validationRule: "Each criterion is observable, measurable, and falsifiable. Standard track should include Requirement Ref and Design Decision Ref columns; quick track may instead link each AC to the reproduction contract or bug slice. AC IDs (AC-1, AC-2…) are stable across revisions — dropped ACs stay with Priority `DROPPED`. v6.13.0: each AC declares `parallelSafe` (true|false) and `touchSurface` (paths/modules) for parallel slice planning." },
             { section: "Quick Reproduction Contract", required: false, validationRule: "Quick bug-fix specs own the reproduction contract: symptom, repro steps, expected RED test behavior, and acceptance criterion." },
             { section: "Edge Cases", required: true, validationRule: "At least one boundary and one error condition per criterion." },
             { section: "Constraints and Assumptions", required: false, validationRule: "Constraints are CARRIED FORWARD from scope's `## Scope Contract > Constraints` (cite with `See scope: <ref>` or copy with attribution). New spec-stage constraints (rare) get a citation to the spec-stage Q&A row that surfaced them. Assumptions are owned by `## Assumptions Before Finalization` — do NOT duplicate them here. Section may be `- See scope: 02-scope.md#constraints.` for the common case." },

package/dist/content/stages/tdd.js

@@ -49,7 +49,8 @@ export const TDD = {
             "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: re-dispatch the `slice-implementer` (or `test-author`) with `--phase refactor` once GREEN holds, OR `--phase refactor-deferred --refactor-rationale \"<why>\"` to close the slice without a refactor pass. Both options are recorded as a delegation event; the linter accepts either as REFACTOR coverage. Set `CCLAW_ACTIVE_AGENT=tdd-refactor` when the harness supports phase labels.",
-            "DOC (parallel, mandatory v6.12.0): dispatch `slice-documenter --slice S-<id> --phase doc --paths <artifacts-dir>/tdd-slices/S-<id>.md` IN PARALLEL with `slice-implementer --phase green` for the same slice — ONE message with TWO concurrent Task calls. The documenter only writes `tdd-slices/S-<id>.md`, so its `--paths` are disjoint from the implementer's production code and the file-overlap scheduler auto-allows the parallel dispatch. Linter rule `tdd_slice_documenter_missing` blocks the gate when the `phase=doc` event is absent (regardless of `discoveryMode`).",
+            "DOC (parallel, mandatory v6.12.0): dispatch `slice-documenter --slice S-<id> --phase doc --paths <artifacts-dir>/tdd-slices/S-<id>.md` IN PARALLEL with `slice-implementer --phase green` for the same slice — ONE message with TWO concurrent Task calls. The documenter only writes `tdd-slices/S-<id>.md`, so its `--paths` are disjoint from the implementer's production paths and the file-overlap scheduler auto-allows the parallel dispatch. Linter rule `tdd_slice_documenter_missing` blocks the gate when the `phase=doc` event is absent (regardless of `discoveryMode`). v6.13.0: documenter output may remain `provisional` until GREEN evidence exists; finalize the slice file after GREEN is recorded.",
+            "## Wave Batch Mode (v6.13+) — (A) RED checkpoint across all wave members before any GREEN in that wave. (B) Parallel implementer+documenter fan-out across multiple slices when paths are disjoint and claims/leases are valid (`--claim-token`, `--lane-id`, `--lease-until`). (C) Per-lane REFACTOR or refactor-deferred. (D) Deterministic git fan-in at TDD stage-complete merges lane diffs with `git apply --3way`; unresolved conflicts block advance until `--phase resolve-conflict` succeeds.",
             "**slice-documenter writes per-slice prose** (test discovery, system-wide impact check, RED/GREEN/REFACTOR notes, acceptance mapping, failure analysis) into `tdd-slices/S-<id>.md`. Controller does NOT touch this content. 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.",

package/dist/content/templates.js

@@ -739,11 +739,11 @@ ${renderBehaviorAnchorTemplateLine("spec")}
 - Drift from upstream (or \`None\`):
 
 ## Acceptance Criteria
-| ID | Requirement Ref (R#) | Criterion (observable/measurable/falsifiable) | Design Decision Ref (D-XX) |
-|---|---|---|---|
-| AC-1 | R1 |  |  |
+| ID | Requirement Ref (R#) | Criterion (observable/measurable/falsifiable) | Design Decision Ref (D-XX) | parallelSafe (true/false) | touchSurface (paths/modules) |
+|---|---|---|---|---|---|
+| AC-1 | R1 |  |  | false |  |
 
-> Standard ACs reference at least one \`R#\` from \`02-scope.md\`. Quick-track ACs may instead put \`Quick Reproduction Contract\` / bug-slice refs in the Requirement Ref column and \`N/A\` for Design Decision Ref. ACs are stable (never renumber): dropped ACs stay with Priority \`DROPPED\`; new ones append with the next free \`AC-#\`.
+> Standard ACs reference at least one \`R#\` from \`02-scope.md\`. Quick-track ACs may instead put \`Quick Reproduction Contract\` / bug-slice refs in the Requirement Ref column and \`N/A\` for Design Decision Ref. ACs are stable (never renumber): dropped ACs stay with Priority \`DROPPED\`; new ones append with the next free \`AC-#\`. **v6.13.0:** \`parallelSafe\` states whether this AC can be proven in parallel with others; \`touchSurface\` lists repo-relative globs or modules this AC is expected to touch (scheduler + slice planning).
 
 ## Quick Reproduction Contract
 > Required for quick bug-fix specs; use \`N/A\` for non-bugfix or standard/medium tracks. TDD turns this contract into the RED reproduction test.
@@ -907,6 +907,12 @@ Execution rule: complete and verify each batch before starting the next batch.
 > Required structural form per implementation unit. Use ≥1 unit; bite-sized 2-5 minute steps inside each. The linter validates shape, not topic.
 
 ### Implementation Unit U-1
+- **id:** U-1
+- **dependsOn:** none
+- **claimedPaths:** (repo-relative, comma-separated globs or files this unit expects to own)
+- **parallelizable:** true
+- **riskTier:** standard
+- **lane:** (optional advisory lane tag for human-readable batching)
 - **Goal:**
 - **Requirements (from Spec):**
 - **Dependencies (other units):**

package/dist/delegation.d.ts

@@ -1,7 +1,7 @@
 import { type SubagentFallback } from "./harness-adapters.js";
 import { type MandatoryDelegationTaskClass } from "./content/stage-schema.js";
 import type { FlowStage } from "./types.js";
-import type { FlowState } from "./flow-state.js";
+import { type FlowState } from "./flow-state.js";
 export type DelegationMode = "mandatory" | "proactive";
 export type DelegationStatus = "scheduled" | "launched" | "acknowledged" | "completed" | "failed" | "waived" | "stale";
 export declare const DELEGATION_DISPATCH_SURFACES: readonly ["claude-task", "cursor-task", "opencode-agent", "codex-agent", "generic-task", "role-switch", "manual"];
@@ -164,9 +164,26 @@ export type DelegationEntry = {
      * keep in sync with the inline copy in
      * `src/content/hooks.ts::delegationRecordScript`.
      */
-    phase?: "red" | "green" | "refactor" | "refactor-deferred" | "doc";
+    phase?: "red" | "green" | "refactor" | "refactor-deferred" | "doc" | "resolve-conflict";
+    /**
+     * v6.13.0 — opaque token tying scheduled work to terminal lifecycle rows
+     * under worktree-first execution (mandatory on new schedules).
+     */
+    claimToken?: string;
+    /** v6.13.0 — lane / worktree id owning the slice checkout. */
+    ownerLaneId?: string;
+    /** v6.13.0 — ISO lease expiry for reclaim sweeps. */
+    leasedUntil?: string;
+    /** v6.13.0 — lease bookkeeping for audit + reclaim tooling. */
+    leaseState?: "claimed" | "expired" | "released" | "reclaimed";
+    /** v6.13.0 — plan unit dependency ids echoed for scheduler diagnostics. */
+    dependsOn?: string[];
+    /**
+     * v6.13.0 — integration branch merge status after deterministic fan-in.
+     */
+    integrationState?: "pending" | "applied" | "conflict" | "resolved" | "abandoned";
 };
-export declare const DELEGATION_PHASES: readonly ["red", "green", "refactor", "refactor-deferred", "doc"];
+export declare const DELEGATION_PHASES: readonly ["red", "green", "refactor", "refactor-deferred", "doc", "resolve-conflict"];
 export type DelegationPhase = (typeof DELEGATION_PHASES)[number];
 export declare const DELEGATION_LEDGER_SCHEMA_VERSION: 3;
 export type DelegationLedger = {
@@ -191,9 +208,31 @@ export type DelegationEvent = DelegationEntry & {
  */
 export declare function isTrustBoundaryPath(filePath: string): boolean;
 export declare function readDelegationLedger(projectRoot: string): Promise<DelegationLedger>;
+/** Parsed `cclaw_fanin_*` audit rows from `delegation-events.jsonl`. */
+export interface FanInAuditRecord {
+    event: "cclaw_fanin_applied" | "cclaw_fanin_conflict" | "cclaw_fanin_resolved" | "cclaw_fanin_abandoned";
+    runId?: string;
+    laneId?: string;
+    sliceIds?: string[];
+    integrationBranch?: string;
+    details?: string;
+    ts: string;
+}
+/**
+ * Append a deterministic fan-in audit row (not a delegation lifecycle event).
+ */
+export declare function recordCclawFanInAudit(projectRoot: string, params: {
+    kind: FanInAuditRecord["event"];
+    runId: string;
+    laneId: string;
+    sliceIds: string[];
+    integrationBranch: string;
+    details?: string;
+}): Promise<void>;
 export declare function readDelegationEvents(projectRoot: string): Promise<{
     events: DelegationEvent[];
     corruptLines: number[];
+    fanInAudits: FanInAuditRecord[];
 }>;
 /**
  * Fold ledger entries to the latest row per `spanId` and keep only spans
@@ -319,12 +358,38 @@ export declare class DispatchCapError extends Error {
         };
     });
 }
+/**
+ * v6.13.0 — claim / lease contract violation for worktree-first TDD rows.
+ */
+export declare class DispatchClaimInvalidError extends Error {
+    constructor(message: 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;
+export interface ReadySliceUnit {
+    unitId: string;
+    sliceId: string;
+    dependsOn: string[];
+    claimedPaths: string[];
+    parallelizable: boolean;
+}
+export interface SelectReadySlicesOptions {
+    cap: number;
+    completedUnitIds: ReadonlySet<string>;
+    activePathHolders: ReadonlyArray<{
+        paths: string[];
+    }>;
+    legacyContinuation: boolean;
+}
+/**
+ * Return up to `cap` slice units whose dependsOn are satisfied, avoiding
+ * `claimedPaths` intersections with already-selected units and active holders.
+ */
+export declare function selectReadySlices(units: ReadySliceUnit[], opts: SelectReadySlicesOptions): ReadySliceUnit[];
 /**
  * v6.10.0 (P1) — when scheduling a `slice-implementer` on a TDD stage,
  * compare `claimedPaths` against every currently active span on the
@@ -369,6 +434,11 @@ export declare function validateFanOutCap(stamped: DelegationEntry, activeEntrie
  */
 export declare function findActiveSpanForPair(stage: string, agent: string, runId: string, ledger: DelegationLedger): DelegationEntry | null;
 export declare function appendDelegation(projectRoot: string, entry: DelegationEntry): Promise<void>;
+/**
+ * Scan delegation events for expired `leasedUntil` timestamps and append
+ * best-effort `cclaw_slice_lease_expired` audit rows (one per span/slice key).
+ */
+export declare function reclaimExpiredDelegationClaims(projectRoot: string, now?: Date): Promise<number>;
 /**
  * Aggregate the fulfillment mode cclaw expects for the active harness set.
  * Priority native > generic-dispatch > role-switch > waiver — the best