cclaw-cli 6.12.0 → 6.13.1

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.d.ts

@@ -1,4 +1,4 @@
-import type { DelegationEntry } from "../delegation.js";
+import type { DelegationEntry, DelegationEvent } from "../delegation.js";
 import { type LintFinding, type StageLintContext } from "./shared.js";
 /**
  * v6.11.0 — TDD stage linter.
@@ -52,15 +52,28 @@ interface RedCheckpointResult {
     ok: boolean;
     details: string;
 }
+/**
+ * v6.13.1 — detect single-slice dispatch when the merged wave plan
+ * requires parallel ready slice-implementer fan-out.
+ */
+export declare function evaluateWavePlanDispatchIgnored(params: {
+    artifactsDir: string;
+    planMarkdown: string;
+    runEvents: DelegationEvent[];
+    runId: string;
+    slices: Map<string, DelegationEntry[]>;
+    legacyContinuation: boolean;
+}): Promise<LintFinding | null>;
 /**
  * v6.12.0 Phase W — RED checkpoint enforcement. The wave protocol
  * requires ALL Phase A REDs to land before ANY Phase B GREEN starts.
  * The rule is enforced on a per-wave basis, where a wave is defined by
- * `<artifacts-dir>/wave-plans/wave-NN.md` files (when present) listing
- * slice ids. When no wave manifest exists, the linter falls back to a
- * conservative implicit detection: a wave is a contiguous run of
- * `phase=red` events with no other-phase events between them; the rule
- * fires only when the implicit wave has 2+ members.
+ * the managed `## Parallel Execution Plan` block in `05-plan.md` and/or
+ * `<artifacts-dir>/wave-plans/wave-NN.md` files. When no wave manifest
+ * exists, the linter falls back to a conservative implicit detection: a
+ * wave is a contiguous run of `phase=red` events with no other-phase
+ * events between them; the rule fires only when the implicit wave has
+ * 2+ members.
  *
  * @param waveMembers Optional explicit wave manifest. Map key is wave
  * name (e.g. `"W-01"`); value is the set of slice ids in that wave.

package/dist/artifact-linter/tdd.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { readDelegationLedger } from "../delegation.js";
+import { loadTddReadySlicePool, readDelegationLedger, readDelegationEvents, selectReadySlices } from "../delegation.js";
+import { mergeParallelWaveDefinitions, parseParallelExecutionPlanWaves, parseWavePlanDirectory } from "../internal/plan-split-waves.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,9 +27,17 @@ 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, legacyContinuation } = ctx;
     void parsedFrontmatter;
+    const artifactsDir = path.dirname(absFile);
+    const planPath = path.join(artifactsDir, "05-plan.md");
+    let planRaw = "";
+    try {
+        planRaw = await fs.readFile(planPath, "utf8");
+    }
+    catch {
+        planRaw = "";
+    }
     evaluateInvestigationTrace(ctx, "Watched-RED Proof");
     const delegationLedger = await readDelegationLedger(ctx.projectRoot);
     const activeRunEntries = delegationLedger.entries.filter((entry) => entry.stage === "tdd" && entry.runId === delegationLedger.runId);
@@ -177,7 +186,7 @@ export async function lintTddStage(ctx) {
     // (size >= 2). Sequential per-slice runs (red→green→refactor in a
     // tight loop) form size-1 implicit waves and are unaffected.
     if (eventsActive) {
-        const waveManifest = await readWaveManifest(path.dirname(absFile));
+        const waveManifest = await readMergedWaveManifestForCheckpoint(artifactsDir, planRaw);
         const checkpointResult = evaluateRedCheckpoint(slicesByEvents, waveManifest);
         if (!checkpointResult.ok) {
             findings.push({
@@ -202,6 +211,118 @@ 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 && planRaw.length > 0) {
+        const ignoredWave = await evaluateWavePlanDispatchIgnored({
+            artifactsDir,
+            planMarkdown: planRaw,
+            runEvents,
+            runId: delegationLedger.runId,
+            slices: slicesByEvents,
+            legacyContinuation
+        });
+        if (ignoredWave) {
+            findings.push(ignoredWave);
+        }
+    }
+    if (eventsActive && worktreeExecutionMode === "worktree-first") {
+        const terminalPhases = new Set([
+            "refactor",
+            "refactor-deferred",
+            "resolve-conflict"
+        ]);
+        const missingGreenMeta = 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 (typeof ev.sliceId !== "string")
+                continue;
+            const tok = ev.claimToken?.trim() ?? "";
+            const lane = ev.ownerLaneId?.trim() ?? "";
+            const lease = ev.leasedUntil?.trim() ?? "";
+            if (tok.length === 0 || lane.length === 0 || lease.length === 0) {
+                missingGreenMeta.add(ev.sliceId);
+            }
+        }
+        if (missingGreenMeta.size > 0) {
+            findings.push({
+                section: "tdd_slice_lane_metadata_missing",
+                required: true,
+                rule: "Worktree-first: every completed slice-implementer phase=green row must record claimToken, ownerLaneId (--lane-id), and leasedUntil (--lease-until).",
+                found: false,
+                details: `Slices missing one or more lane fields on GREEN: ${[...missingGreenMeta].sort().join(", ")}. Remediation: include --claim-token, --lane-id, and --lease-until on every slice-implementer --phase green delegation-record write (schedule through completion); the hook fails fast with dispatch_lane_metadata_missing when they are omitted.`
+            });
+        }
+        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 (refactor / refactor-deferred / resolve-conflict) 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 non-GREEN terminal rows: ${[...missingClaim].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));
@@ -244,7 +365,6 @@ export async function lintTddStage(ctx) {
     const completedSliceImplementers = activeRunEntries.filter((entry) => entry.agent === "slice-implementer" && entry.status === "completed");
     const fanOutDetected = completedSliceImplementers.length > 1;
     if (fanOutDetected) {
-        const artifactsDir = path.dirname(absFile);
         const cohesionContractMarkdownPath = path.join(artifactsDir, "cohesion-contract.md");
         const cohesionContractJsonPath = path.join(artifactsDir, "cohesion-contract.json");
         let cohesionContractFound = true;
@@ -324,7 +444,6 @@ export async function lintTddStage(ctx) {
     // Phase S — sharded slice files. Validate per-slice file presence
     // and required headings. `tdd-slices/` is optional; missing folder
     // simply means main-only mode (legacy fallback).
-    const artifactsDir = path.dirname(absFile);
     const slicesDir = path.join(artifactsDir, "tdd-slices");
     const sliceFiles = await listSliceFiles(slicesDir);
     for (const sliceFile of sliceFiles) {
@@ -600,15 +719,110 @@ export function evaluateSliceImplementerCoverage(slices) {
     }
     return { missing };
 }
+async function readMergedWaveManifestForCheckpoint(artifactsDir, planMarkdown) {
+    try {
+        const merged = mergeParallelWaveDefinitions(parseParallelExecutionPlanWaves(planMarkdown), await parseWavePlanDirectory(artifactsDir));
+        if (merged.length === 0)
+            return null;
+        const map = new Map();
+        for (const w of merged) {
+            map.set(w.waveId, new Set(w.members.map((m) => m.sliceId)));
+        }
+        return map.size > 0 ? map : null;
+    }
+    catch {
+        return null;
+    }
+}
+function sliceRefactorTerminal(sliceId, slices) {
+    const rows = slices.get(sliceId);
+    if (!rows)
+        return false;
+    return rows.some((e) => e.agent === "slice-implementer" &&
+        (e.phase === "refactor" || e.phase === "refactor-deferred") &&
+        (e.status === "completed" || e.status === "failed"));
+}
+/**
+ * v6.13.1 — detect single-slice dispatch when the merged wave plan
+ * requires parallel ready slice-implementer fan-out.
+ */
+export async function evaluateWavePlanDispatchIgnored(params) {
+    let merged;
+    try {
+        merged = mergeParallelWaveDefinitions(parseParallelExecutionPlanWaves(params.planMarkdown), await parseWavePlanDirectory(params.artifactsDir));
+    }
+    catch {
+        return null;
+    }
+    if (merged.length === 0)
+        return null;
+    let pool;
+    try {
+        pool = await loadTddReadySlicePool(params.planMarkdown, params.artifactsDir, {
+            legacyParallelDefaultSerial: params.legacyContinuation
+        });
+    }
+    catch {
+        return null;
+    }
+    if (pool.length === 0)
+        return null;
+    const completedUnitIds = new Set();
+    for (const u of pool) {
+        if (sliceRefactorTerminal(u.sliceId, params.slices)) {
+            completedUnitIds.add(u.unitId);
+        }
+    }
+    const scoped = params.runEvents.filter((e) => e.runId === params.runId);
+    const tail = scoped.slice(-20);
+    const implInTail = new Set();
+    for (const e of tail) {
+        if (e.agent === "slice-implementer" && typeof e.sliceId === "string" && e.sliceId.length > 0) {
+            implInTail.add(e.sliceId);
+        }
+    }
+    if (implInTail.size !== 1)
+        return null;
+    for (const wave of merged) {
+        const waveSliceSet = new Set(wave.members.map((m) => m.sliceId));
+        const wavePool = pool.filter((u) => waveSliceSet.has(u.sliceId));
+        if (wavePool.length < 2)
+            continue;
+        const waveIncomplete = wave.members.some((m) => !sliceRefactorTerminal(m.sliceId, params.slices));
+        if (!waveIncomplete)
+            continue;
+        const ready = selectReadySlices(wavePool, {
+            cap: Math.max(32, wavePool.length),
+            completedUnitIds,
+            activePathHolders: [],
+            legacyContinuation: params.legacyContinuation
+        });
+        if (ready.length < 2)
+            continue;
+        const only = [...implInTail][0];
+        const missed = ready.map((r) => r.sliceId).filter((s) => s !== only);
+        if (missed.length === 0)
+            continue;
+        return {
+            section: "tdd_wave_plan_ignored",
+            required: true,
+            rule: "When the Parallel Execution Plan (or wave-plans/) defines an open wave with two or more ready parallelizable slices, the controller must fan out slice-implementer work for each ready slice instead of serializing to one slice only.",
+            found: false,
+            details: `Wave ${wave.waveId}: scheduler-ready members ${ready.map((r) => r.sliceId).join(", ")}; last 20 delegation events show slice-implementer only for ${only}. Missed parallel dispatch: ${missed.join(", ")}. Remediation: load \`05-plan.md\` (Parallel Execution Plan) and \`wave-plans/\` before routing, launch the wave (AskQuestion only when waveCount>=2 and single-slice is a real alternative), then dispatch GREEN+DOC for every ready slice with mandatory worktree-first flags on GREEN.`
+        };
+    }
+    return null;
+}
 /**
  * v6.12.0 Phase W — RED checkpoint enforcement. The wave protocol
  * requires ALL Phase A REDs to land before ANY Phase B GREEN starts.
  * The rule is enforced on a per-wave basis, where a wave is defined by
- * `<artifacts-dir>/wave-plans/wave-NN.md` files (when present) listing
- * slice ids. When no wave manifest exists, the linter falls back to a
- * conservative implicit detection: a wave is a contiguous run of
- * `phase=red` events with no other-phase events between them; the rule
- * fires only when the implicit wave has 2+ members.
+ * the managed `## Parallel Execution Plan` block in `05-plan.md` and/or
+ * `<artifacts-dir>/wave-plans/wave-NN.md` files. When no wave manifest
+ * exists, the linter falls back to a conservative implicit detection: a
+ * wave is a contiguous run of `phase=red` events with no other-phase
+ * events between them; the rule fires only when the implicit wave has
+ * 2+ members.
  *
  * @param waveMembers Optional explicit wave manifest. Map key is wave
  * name (e.g. `"W-01"`); value is the set of slice ids in that wave.
@@ -689,42 +903,6 @@ export function evaluateRedCheckpoint(slices, waveMembers = null) {
             "Dispatch ALL Phase A test-author --phase red calls in one message, verify every phase=red event lands with non-empty evidenceRefs, and only then dispatch Phase B slice-implementer --phase green + slice-documenter --phase doc fan-out."
     };
 }
-/**
- * Read explicit wave manifest from `<artifacts-dir>/wave-plans/wave-NN.md`
- * files. Returns a map from wave name to the set of slice ids it
- * contains. Slice ids are extracted via `S-<digits>` regex matches in
- * each wave file. Returns null when no wave files exist or all are
- * empty/unparseable.
- */
-async function readWaveManifest(artifactsDir) {
-    const wavePlansDir = path.join(artifactsDir, "wave-plans");
-    let entries = [];
-    try {
-        entries = await fs.readdir(wavePlansDir);
-    }
-    catch {
-        return null;
-    }
-    const waves = new Map();
-    for (const name of entries) {
-        const match = /^wave-(\d+)\.md$/u.exec(name);
-        if (!match)
-            continue;
-        const wavePath = path.join(wavePlansDir, name);
-        let body = "";
-        try {
-            body = await fs.readFile(wavePath, "utf8");
-        }
-        catch {
-            continue;
-        }
-        const ids = extractSliceIdsFromBody(body);
-        if (ids.length === 0)
-            continue;
-        waves.set(`W-${match[1]}`, new Set(ids));
-    }
-    return waves.size > 0 ? waves : null;
-}
 const LEGACY_PER_SLICE_SECTIONS = [
     "Test Discovery",
     "RED Evidence",

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

@@ -294,6 +294,19 @@ async function readRunId(root) {
   }
 }
 
+async function readWorktreeExecutionModeInline(root) {
+  try {
+    const raw = await fs.readFile(path.join(root, RUNTIME_ROOT, "state", "flow-state.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && parsed.worktreeExecutionMode === "worktree-first") {
+      return "worktree-first";
+    }
+    return "single-tree";
+  } catch {
+    return "single-tree";
+  }
+}
+
 async function readDelegationEvents(root) {
   try {
     const raw = await fs.readFile(path.join(root, RUNTIME_ROOT, "state", "delegation-events.jsonl"), "utf8");
@@ -350,6 +363,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 +502,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 +562,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
   };
 }
 
@@ -1218,6 +1278,33 @@ async function main() {
     }
   }
 
+  if (
+    clean.stage === "tdd" &&
+    clean.agent === "slice-implementer" &&
+    clean.phase === "green" &&
+    (await readWorktreeExecutionModeInline(root)) === "worktree-first"
+  ) {
+    const tok = typeof clean.claimToken === "string" ? clean.claimToken.trim() : "";
+    const lane = typeof clean.ownerLaneId === "string" ? clean.ownerLaneId.trim() : "";
+    const lease = typeof clean.leasedUntil === "string" ? clean.leasedUntil.trim() : "";
+    if (tok.length === 0 || lane.length === 0 || lease.length === 0) {
+      const missing = [];
+      if (tok.length === 0) missing.push("--claim-token");
+      if (lane.length === 0) missing.push("--lane-id");
+      if (lease.length === 0) missing.push("--lease-until");
+      emitErrorJson(
+        "dispatch_lane_metadata_missing",
+        {
+          missing,
+          remediation:
+            "worktree-first mode requires --claim-token, --lane-id, and --lease-until on every slice-implementer --phase green delegation-record write (from scheduled through completed)."
+        },
+        json
+      );
+      return;
+    }
+  }
+
   await persistEntry(root, runId, clean, event);
   process.stdout.write(JSON.stringify({ ok: true, event }, null, 2) + "\\n");
 }