cclaw-cli 6.11.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.d.ts

@@ -37,6 +37,35 @@ interface DocCoverageResult {
     missing: string[];
 }
 export declare function evaluateSliceDocumenterCoverage(slices: Map<string, DelegationEntry[]>): DocCoverageResult;
+interface ImplementerCoverageResult {
+    missing: string[];
+}
+/**
+ * v6.12.0 Phase M — slice-implementer must own GREEN. For each slice
+ * that recorded a phase=red event with non-empty evidenceRefs, require a
+ * phase=green event whose `agent === "slice-implementer"`. Slices whose
+ * GREEN event came from a different agent (e.g. controller wrote GREEN
+ * itself and recorded a green row under another agent name) are flagged.
+ */
+export declare function evaluateSliceImplementerCoverage(slices: Map<string, DelegationEntry[]>): ImplementerCoverageResult;
+interface RedCheckpointResult {
+    ok: boolean;
+    details: string;
+}
+/**
+ * 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.
+ *
+ * @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.
+ */
+export declare function evaluateRedCheckpoint(slices: Map<string, DelegationEntry[]>, waveMembers?: Map<string, Set<string>> | null): RedCheckpointResult;
 export declare function parseVerticalSliceCycle(body: string): ParsedSliceCycleResult;
 interface VerificationLadderResult {
     ok: boolean;

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);
@@ -135,19 +134,165 @@ export async function lintTddStage(ctx) {
             });
         }
     }
-    // Phase C — slice-documenter coverage. When discoveryMode=deep, every
-    // slice with a green phase event must also carry a phase=doc event with
-    // non-empty evidenceRefs pointing at `tdd-slices/S-<id>.md`.
+    // v6.12.0 Phase R — slice-documenter coverage is mandatory on every
+    // TDD run regardless of discoveryMode. `discoveryMode` is now strictly
+    // an early-stage knob (brainstorm/scope/design); TDD parallelism must
+    // be uniform across lean/guided/deep so the controller cannot quietly
+    // skip per-slice prose by picking a non-deep mode.
+    void discoveryMode;
     if (eventsActive) {
         const docResult = evaluateSliceDocumenterCoverage(slicesByEvents);
         if (docResult.missing.length > 0) {
-            const isDeep = discoveryMode === "deep";
             findings.push({
-                section: "tdd_slice_documenter_missing_for_deep",
-                required: isDeep,
-                rule: "On discoveryMode=deep, every TDD slice with a phase=green event must also carry a slice-documenter `phase=doc` event whose evidenceRefs reference `<artifacts-dir>/tdd-slices/S-<id>.md`. On other discovery modes the requirement is advisory.",
+                section: "tdd_slice_documenter_missing",
+                required: true,
+                rule: "Every TDD slice with a phase=green event must also carry a slice-documenter `phase=doc` event whose evidenceRefs reference `<artifacts-dir>/tdd-slices/S-<id>.md`. The requirement is independent of discoveryMode (v6.12.0 Phase R).",
+                found: false,
+                details: `Slices missing slice-documenter coverage: ${docResult.missing.join(", ")}. Dispatch slice-documenter --slice <id> --phase doc in parallel with slice-implementer --phase green for each slice.`
+            });
+        }
+    }
+    // v6.12.0 Phase M — slice-implementer must own GREEN. For each slice
+    // with a phase=red row carrying non-empty evidenceRefs, require a
+    // matching phase=green event whose `agent === "slice-implementer"`.
+    // This catches "controller wrote GREEN itself" — the most common
+    // backslide we have observed in fresh runs (hox S-11).
+    if (eventsActive) {
+        const implResult = evaluateSliceImplementerCoverage(slicesByEvents);
+        if (implResult.missing.length > 0) {
+            findings.push({
+                section: "tdd_slice_implementer_missing",
+                required: true,
+                rule: "Every TDD slice that recorded a phase=red event with non-empty evidenceRefs must reach phase=green via the `slice-implementer` agent. Controller writing GREEN production code itself is forbidden (v6.12.0 Phase M).",
                 found: false,
-                details: `Slices missing slice-documenter coverage: ${docResult.missing.join(", ")}.`
+                details: `Slices missing slice-implementer GREEN coverage: ${implResult.missing.join(", ")}. Dispatch slice-implementer --slice <id> --phase green --paths <comma-separated production paths>.`
+            });
+        }
+    }
+    // v6.12.0 Phase W — RED checkpoint enforcement. The wave protocol
+    // requires ALL Phase A REDs to land before ANY Phase B GREEN starts.
+    // Enforced per-wave: explicit `wave-plans/wave-NN.md` manifest if
+    // present, otherwise implicit detection via contiguous red blocks
+    // (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 checkpointResult = evaluateRedCheckpoint(slicesByEvents, waveManifest);
+        if (!checkpointResult.ok) {
+            findings.push({
+                section: "tdd_red_checkpoint_violation",
+                required: true,
+                rule: "Wave Batch Mode (v6.12.0 Phase W): every slice in a wave must complete phase=red before any slice in the same wave starts phase=green. Detected: a phase=green completedTs precedes the last phase=red completedTs of the same wave.",
+                found: false,
+                details: checkpointResult.details
+            });
+        }
+    }
+    // v6.12.0 Phase L — advisory backslide detection. When a cutover is
+    // recorded in flow-state, slice-id rows in the legacy per-slice
+    // sections of `06-tdd.md` that exceed the cutover boundary should
+    // migrate to `tdd-slices/S-<id>.md`. Surface as advisory so it does
+    // not block the gate but does keep the controller honest.
+    const cutoverFinding = await evaluateLegacySectionBackslide({
+        projectRoot,
+        raw,
+        sections
+    });
+    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(", ")}.`
             });
         }
     }
@@ -522,6 +667,248 @@ export function evaluateSliceDocumenterCoverage(slices) {
     }
     return { missing };
 }
+/**
+ * v6.12.0 Phase M — slice-implementer must own GREEN. For each slice
+ * that recorded a phase=red event with non-empty evidenceRefs, require a
+ * phase=green event whose `agent === "slice-implementer"`. Slices whose
+ * GREEN event came from a different agent (e.g. controller wrote GREEN
+ * itself and recorded a green row under another agent name) are flagged.
+ */
+export function evaluateSliceImplementerCoverage(slices) {
+    const missing = [];
+    for (const [sliceId, rows] of slices.entries()) {
+        const reds = rows.filter((entry) => entry.phase === "red");
+        if (reds.length === 0)
+            continue;
+        const hasRedEvidence = reds.some((red) => {
+            const refs = Array.isArray(red.evidenceRefs) ? red.evidenceRefs : [];
+            return refs.some((ref) => typeof ref === "string" && ref.trim().length > 0);
+        });
+        if (!hasRedEvidence)
+            continue;
+        const greens = rows.filter((entry) => entry.phase === "green");
+        const ownedByImplementer = greens.some((entry) => entry.agent === "slice-implementer");
+        if (!ownedByImplementer) {
+            missing.push(sliceId);
+        }
+    }
+    return { missing };
+}
+/**
+ * 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.
+ *
+ * @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.
+ */
+export function evaluateRedCheckpoint(slices, waveMembers = null) {
+    const events = [];
+    for (const [sliceId, rows] of slices.entries()) {
+        for (const entry of rows) {
+            const ts = entry.completedTs ?? entry.endTs ?? entry.ts;
+            if (typeof ts !== "string" || ts.length === 0)
+                continue;
+            if (typeof entry.phase !== "string")
+                continue;
+            events.push({ sliceId, phase: entry.phase, ts });
+        }
+    }
+    events.sort((a, b) => (a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0));
+    // Build the canonical wave list. Explicit manifest wins; otherwise
+    // derive implicit waves from contiguous red event blocks.
+    const waves = [];
+    if (waveMembers && waveMembers.size > 0) {
+        for (const [name, members] of waveMembers.entries()) {
+            if (members.size === 0)
+                continue;
+            waves.push({ name, members });
+        }
+    }
+    else {
+        let current = null;
+        let waveIdx = 0;
+        for (const evt of events) {
+            if (evt.phase === "red") {
+                if (current === null)
+                    current = new Set();
+                current.add(evt.sliceId);
+            }
+            else if (current !== null) {
+                if (current.size >= 2) {
+                    waveIdx += 1;
+                    waves.push({ name: `implicit-${waveIdx}`, members: current });
+                }
+                current = null;
+            }
+        }
+        if (current !== null && current.size >= 2) {
+            waveIdx += 1;
+            waves.push({ name: `implicit-${waveIdx}`, members: current });
+        }
+    }
+    if (waves.length === 0) {
+        return {
+            ok: true,
+            details: "RED checkpoint inactive: no wave manifest detected and no implicit wave (2+ contiguous reds) found."
+        };
+    }
+    const violations = [];
+    for (const wave of waves) {
+        const memberReds = events.filter((e) => e.phase === "red" && wave.members.has(e.sliceId));
+        const memberGreens = events.filter((e) => e.phase === "green" && wave.members.has(e.sliceId));
+        if (memberReds.length === 0 || memberGreens.length === 0)
+            continue;
+        const lastRedTs = memberReds.reduce((acc, e) => (e.ts > acc ? e.ts : acc), memberReds[0].ts);
+        for (const g of memberGreens) {
+            if (g.ts < lastRedTs) {
+                violations.push(`${wave.name}: ${g.sliceId} phase=green at ${g.ts} precedes wave's last phase=red completedTs at ${lastRedTs}`);
+            }
+        }
+    }
+    if (violations.length === 0) {
+        return {
+            ok: true,
+            details: `RED checkpoint holds across ${waves.length} wave(s): all phase=green events follow the last phase=red of their wave.`
+        };
+    }
+    return {
+        ok: false,
+        details: `RED checkpoint violation: ${violations.join("; ")}. ` +
+            "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",
+    "GREEN Evidence",
+    "Watched-RED Proof",
+    "Vertical Slice Cycle",
+    "Per-Slice Review",
+    "Failure Analysis",
+    "Acceptance Mapping"
+];
+/**
+ * v6.12.0 Phase L — advisory finding when post-cutover slice ids appear
+ * in legacy per-slice sections of `06-tdd.md`. Reads
+ * `flow-state.json::tddCutoverSliceId` (e.g. `"S-10"`) and scans each
+ * legacy section for `S-<N>` references with N > cutover.
+ */
+async function evaluateLegacySectionBackslide(ctx) {
+    const cutover = await readTddCutoverSliceId(ctx.projectRoot);
+    if (cutover === null)
+        return null;
+    const cutoverNum = parseSliceNumber(cutover);
+    if (cutoverNum === null)
+        return null;
+    const offenders = [];
+    for (const sectionName of LEGACY_PER_SLICE_SECTIONS) {
+        const body = sectionBodyByName(ctx.sections, sectionName);
+        if (body === null)
+            continue;
+        const ids = extractSliceIdsFromBody(body);
+        for (const id of ids) {
+            const num = parseSliceNumber(id);
+            if (num === null)
+                continue;
+            if (num > cutoverNum) {
+                offenders.push({ section: sectionName, sliceId: id });
+            }
+        }
+    }
+    if (offenders.length === 0)
+        return null;
+    const summary = offenders
+        .map((row) => `${row.sliceId} appears in legacy section \`## ${row.section}\``)
+        .join("; ");
+    return {
+        section: "tdd_legacy_section_writes_after_cutover",
+        required: false,
+        rule: "After v6.12.0 cutover, per-slice prose for slices > cutoverSliceId must live in `tdd-slices/S-<id>.md`, not in legacy `06-tdd.md` sections (Test Discovery, RED Evidence, GREEN Evidence, Watched-RED Proof, Vertical Slice Cycle, Per-Slice Review, Failure Analysis, Acceptance Mapping).",
+        found: false,
+        details: `${summary}. Move post-cutover slice prose into \`tdd-slices/<id>.md\` and let slice-documenter own the writes.`
+    };
+}
+async function readTddCutoverSliceId(projectRoot) {
+    const flowStatePath = path.join(projectRoot, ".cclaw/state/flow-state.json");
+    let raw;
+    try {
+        raw = await fs.readFile(flowStatePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+    const value = parsed.tddCutoverSliceId;
+    if (typeof value !== "string" || value.length === 0)
+        return null;
+    return value;
+}
+function parseSliceNumber(sliceId) {
+    const match = /^S-(\d+)\b/u.exec(sliceId);
+    if (!match)
+        return null;
+    const num = Number.parseInt(match[1], 10);
+    return Number.isFinite(num) ? num : null;
+}
+function extractSliceIdsFromBody(body) {
+    const ids = new Set();
+    const regex = /\bS-(\d+)\b/gu;
+    let match;
+    while ((match = regex.exec(body)) !== null) {
+        ids.add(`S-${match[1]}`);
+    }
+    return [...ids];
+}
 function pickEventTs(rows) {
     for (const entry of rows) {
         const ts = entry.completedTs ?? entry.endTs ?? entry.ts;

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/core-agents.d.ts

@@ -209,10 +209,10 @@ export declare const CCLAW_AGENTS: readonly [{
     readonly body: string;
 }, {
     readonly name: "slice-documenter";
-    readonly description: "PARALLEL with slice-implementer in TDD GREEN. Writes per-slice prose summary to `<artifacts-dir>/tdd-slices/S-<id>.md`. Does NOT implement, does NOT write tests. Mandatory on discoveryMode=deep, opt-in elsewhere.";
+    readonly description: "MANDATORY in PARALLEL with slice-implementer for every TDD slice (regardless of discoveryMode, v6.12.0 Phase R). Writes per-slice prose summary to `<artifacts-dir>/tdd-slices/S-<id>.md`. Does NOT implement, does NOT write tests. Linter rule `tdd_slice_documenter_missing` blocks the gate when a `phase=doc` event is missing for a green slice.";
     readonly tools: ["Read", "Write", "Edit", "Grep", "Glob"];
     readonly model: "fast";
-    readonly activation: "on-demand";
+    readonly activation: "mandatory";
     readonly relatedStages: ["tdd"];
     readonly returnSchema: {
         readonly statusField: "status";

package/dist/content/core-agents.js

@@ -546,10 +546,10 @@ export const CCLAW_AGENTS = [
     },
     {
         name: "slice-documenter",
-        description: "PARALLEL with slice-implementer in TDD GREEN. Writes per-slice prose summary to `<artifacts-dir>/tdd-slices/S-<id>.md`. Does NOT implement, does NOT write tests. Mandatory on discoveryMode=deep, opt-in elsewhere.",
+        description: "MANDATORY in PARALLEL with slice-implementer for every TDD slice (regardless of discoveryMode, v6.12.0 Phase R). Writes per-slice prose summary to `<artifacts-dir>/tdd-slices/S-<id>.md`. Does NOT implement, does NOT write tests. Linter rule `tdd_slice_documenter_missing` blocks the gate when a `phase=doc` event is missing for a green slice.",
         tools: ["Read", "Write", "Edit", "Grep", "Glob"],
         model: "fast",
-        activation: "on-demand",
+        activation: "mandatory",
         relatedStages: ["tdd"],
         returnSchema: {
             statusField: "status",
@@ -729,7 +729,7 @@ ${(() => {
         const mode = activationModeSummary();
         return `- **Mandatory:** ${mode.mandatory}.
 - **Proactive:** ${mode.proactive}.
-- **On-demand:** slice-implementer, fixer. Research playbooks are in-thread procedures.`;
+- **On-demand:** fixer. Research playbooks are in-thread procedures.`;
     })()}
 
 ### Cost-aware routing