cclaw-cli 6.11.0 → 6.12.0

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

@@ -135,22 +135,73 @@ 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-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: `Slices missing slice-documenter coverage: ${docResult.missing.join(", ")}.`
+                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 assertionBody = sectionBodyByName(sections, "Assertion Correctness Notes");
     if (assertionBody !== null) {
         const tableRows = assertionBody.split("\n").filter((line) => /^\|/u.test(line));
@@ -522,6 +573,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/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

package/dist/content/examples.js

@@ -36,10 +36,10 @@ export const BEHAVIOR_ANCHORS = [
     },
     {
         stage: "tdd",
-        section: "Watched-RED Proof",
-        bad: "Hand-edit Watched-RED Proof rows directly in the TDD artifact; the next lint overwrites the auto-rendered region and the slice still lacks a provable RED in delegation events.",
-        good: "Dispatch `test-author --slice S-1 --phase red`, then `slice-implementer --slice S-1 --phase green`. The linter auto-renders the slice cycle from `delegation-events.jsonl`.",
-        ruleHint: "RED/GREEN/REFACTOR transitions are recorded as `delegation-events.jsonl` rows via slice-tagged dispatches; the markdown tables are auto-rendered between `auto-start: tdd-slice-summary` markers from v6.11.0 onward."
+        section: "Vertical Slice Cycle",
+        bad: "Controller writes the failing test, the GREEN fix, AND per-slice prose into `06-tdd.md` itself, then hand-edits Watched-RED / Vertical Slice Cycle tables. `phase=red`/`green`/`doc` events missing; `tdd_slice_implementer_missing` and `tdd_slice_documenter_missing` block the gate.",
+        good: "Per slice: (1) `Task(\"test-author --slice S-1 --phase red\")`. Verify the event. (2) ONE message, TWO Tasks — `slice-implementer --phase green` AND `slice-documenter --phase doc`. (3) `slice-implementer --phase refactor` (or `refactor-deferred`). Linter auto-renders Vertical Slice Cycle from events.",
+        ruleHint: "Per-Slice Ritual (v6.12.0+): RED → verify → GREEN+DOC fan-out (one message, two Tasks) → REFACTOR. Controller never writes GREEN code or per-slice prose. Mandatory regardless of `discoveryMode`."
     },
     {
         stage: "review",

package/dist/content/skills.d.ts

@@ -18,6 +18,16 @@ export declare function watchedFailProofBlock(): string;
 export declare const INVESTIGATION_DISCIPLINE_STAGES: ReadonlySet<FlowStage>;
 export declare function investigationDisciplineBlock(): string;
 export declare function behaviorAnchorBlock(stage: FlowStage): string;
+/**
+ * v6.12.0 Phase Ritual + Phase W — TDD-only top-of-skill sections that
+ * sit immediately after the `<EXTREMELY-IMPORTANT>` Iron Law block and
+ * before `## Quick Start`. They establish the per-slice three-dispatch
+ * ritual + wave batch mode in imperative voice with literal commands so
+ * pattern-matching on read works in our favor.
+ *
+ * Empty for non-TDD stages.
+ */
+export declare function tddTopOfSkillBlock(stage: FlowStage): string;
 export declare function stageSkillFolder(stage: FlowStage): string;
 export declare function stageSkillMarkdown(stage: FlowStage, track?: FlowTrack): string;
 export declare function executingWavesSkillMarkdown(): string;

package/dist/content/skills.js

@@ -102,7 +102,7 @@ Any "the failure is real" claim (failing test, broken build, regression catch, d
 
 \`proof: <iso-ts> | <observed snippet — first 200 chars> | source: <command or log path>\`
 
-For TDD specifically, this is the watched-RED proof and is required per new test before \`stage-complete\` accepts the stage. From v6.11.0 onward, the controller dispatches \`test-author --slice S-<id> --phase red\` (and later \`slice-implementer --phase green\`, \`--phase refactor\` or \`--phase refactor-deferred --refactor-rationale "<why>"\`) and the linter auto-derives the \`Watched-RED Proof\` and \`Vertical Slice Cycle\` tables in \`06-tdd.md\` from \`.cclaw/state/delegation-events.jsonl\`. Do NOT hand-edit those tables. v6.10.0 sidecar (\`06-tdd-slices.jsonl\`) is removed; \`cclaw-cli sync\` cleans the file from existing installs.
+For TDD specifically, this is the watched-RED proof and is required per new test before \`stage-complete\` accepts the stage. From v6.12.0 onward, every slice on every TDD run dispatches three roles in this exact order: (1) \`test-author --slice S-<id> --phase red\`, (2) ONE message with TWO concurrent Task calls — \`slice-implementer --slice S-<id> --phase green --paths <production paths>\` AND \`slice-documenter --slice S-<id> --phase doc --paths <artifacts-dir>/tdd-slices/S-<id>.md\`, (3) \`slice-implementer --phase refactor\` or \`--phase refactor-deferred --refactor-rationale "<why>"\`. The linter auto-derives the \`Watched-RED Proof\` and \`Vertical Slice Cycle\` tables in \`06-tdd.md\` from \`.cclaw/state/delegation-events.jsonl\`. Do NOT hand-edit those tables. \`slice-implementer\` and \`slice-documenter\` are mandatory regardless of \`discoveryMode\` (v6.12.0 Phase R/M); the controller MUST NOT write GREEN production code or per-slice prose itself. v6.10.0 sidecar (\`06-tdd-slices.jsonl\`) is removed; \`cclaw-cli sync\` cleans the file from existing installs.
 `;
 }
 /**
@@ -168,6 +168,64 @@ function whenNotToUseBlock(items) {
     return `## When Not to Use
 ${items.map((item) => `- ${item}`).join("\n")}
 
+`;
+}
+/**
+ * v6.12.0 Phase Ritual + Phase W — TDD-only top-of-skill sections that
+ * sit immediately after the `<EXTREMELY-IMPORTANT>` Iron Law block and
+ * before `## Quick Start`. They establish the per-slice three-dispatch
+ * ritual + wave batch mode in imperative voice with literal commands so
+ * pattern-matching on read works in our favor.
+ *
+ * Empty for non-TDD stages.
+ */
+export function tddTopOfSkillBlock(stage) {
+    if (stage !== "tdd")
+        return "";
+    return `## Per-Slice Ritual (v6.12.0+)
+
+ONE slice = THREE dispatches, in this order. Do not skip, do not collapse.
+
+1. **RED** — \`Task("test-author --slice S-<id> --phase red")\`.
+2. **Verify RED** — wait for the \`phase=red\` event in \`.cclaw/state/delegation-events.jsonl\` with non-empty \`evidenceRefs\`. No production edits.
+3. **GREEN+DOC fan-out** — ONE message, TWO concurrent Tasks:
+   \`\`\`
+   Task("slice-implementer --slice S-<id> --phase green --paths <prod paths>")
+   Task("slice-documenter  --slice S-<id> --phase doc   --paths <artifacts-dir>/tdd-slices/S-<id>.md")
+   \`\`\`
+   The file-overlap scheduler auto-allows parallel dispatch because \`claimedPaths\` are disjoint. Fire BOTH calls in the same message — never serialize independent work.
+4. **REFACTOR** — \`Task("slice-implementer --slice S-<id> --phase refactor")\` OR \`--phase refactor-deferred --refactor-rationale '<why>'\`.
+
+**FORBIDDEN:**
+- Controller writing GREEN production code. ALL GREEN goes through \`slice-implementer\` — linter rule \`tdd_slice_implementer_missing\` blocks the gate.
+- Controller writing per-slice prose into legacy \`06-tdd.md\` sections (Test Discovery / RED Evidence / GREEN Evidence / Watched-RED Proof / Vertical Slice Cycle / Per-Slice Review / Failure Analysis / Acceptance Mapping). \`slice-documenter\` owns \`tdd-slices/S-<id>.md\` — \`tdd_slice_documenter_missing\` blocks the gate.
+- Hand-editing auto-render blocks between \`auto-start: tdd-slice-summary\` / \`auto-start: slices-index\` markers — overwritten every lint.
+
+Delegation-record signature: \`node .cclaw/hooks/delegation-record.mjs --stage=tdd --agent=<agent> --mode=mandatory --status=<...> --span-id=<id> --dispatch-id=<id> --dispatch-surface=<surface> --agent-definition-path=<path> --slice=S-<id> --phase=<red|green|refactor|refactor-deferred|doc> [--paths=<csv>] [--refactor-rationale=<why>] [--ack-ts=<iso>] [--evidence-ref=<ref>] --json\`.
+
+## Wave Batch Mode (v6.12.0+)
+
+Trigger: any \`<artifacts-dir>/wave-plans/wave-NN.md\` exists, OR 2+ slices have disjoint \`claimedPaths\`. Cap = 5 \`slice-implementer\` lanes (10 subagents incl. paired documenters) via \`MAX_PARALLEL_SLICE_IMPLEMENTERS\`.
+
+**Phase A — RED checkpoint** — ONE message, all test-authors:
+\`\`\`
+Task("test-author --slice S-1 --phase red")
+Task("test-author --slice S-2 --phase red")
+Task("test-author --slice S-3 --phase red")
+\`\`\`
+Wait for ALL Phase A REDs to land with non-empty \`evidenceRefs\` before Phase B. Linter \`tdd_red_checkpoint_violation\` (required: true) blocks any wave where a \`phase=green\` \`completedTs\` precedes the wave's last \`phase=red\` \`completedTs\`.
+
+**Phase B — GREEN+DOC fan-out** — ONE message, paired implementer+documenter Tasks per slice:
+\`\`\`
+Task("slice-implementer --slice S-1 --phase green --paths <S-1 prod>")
+Task("slice-documenter  --slice S-1 --phase doc   --paths <artifacts-dir>/tdd-slices/S-1.md")
+Task("slice-implementer --slice S-2 --phase green --paths <S-2 prod>")
+Task("slice-documenter  --slice S-2 --phase doc   --paths <artifacts-dir>/tdd-slices/S-2.md")
+\`\`\`
+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).
+
 `;
 }
 function artifactTemplatePathForStage(stage) {
@@ -593,7 +651,7 @@ If you are about to violate the Iron Law, STOP. No amount of urgency, partial pr
 
 </EXTREMELY-IMPORTANT>
 
-${quickStartBlock(stage, track)}
+${tddTopOfSkillBlock(stage)}${quickStartBlock(stage, track)}
 
 ${STAGE_LANGUAGE_POLICY_POINTER}
 ## Philosophy

package/dist/content/stage-schema.js

@@ -117,6 +117,7 @@ function defaultReturnSchemaForAgent(agent) {
         case "feasibility-reviewer":
             return "review-return";
         case "slice-implementer":
+        case "slice-documenter":
             return "worker-return";
         case "release-reviewer":
             return "release-return";
@@ -143,7 +144,7 @@ function defaultReturnSchemaForAgent(agent) {
 function dispatchClassForRow(row) {
     if (row.dispatchClass)
         return row.dispatchClass;
-    if (row.agent === "fixer" || row.agent === "slice-implementer")
+    if (row.agent === "fixer" || row.agent === "slice-implementer" || row.agent === "slice-documenter")
         return "worker";
     return row.skill?.includes("review") || row.agent === "reviewer" || row.agent === "security-reviewer" || row.agent.endsWith("-reviewer")
         ? "review-lens"
@@ -721,10 +722,18 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         },
         {
             agent: "slice-implementer",
-            mode: "proactive",
+            mode: "mandatory",
+            requiredAtTier: "lightweight",
+            when: "Always for GREEN and REFACTOR phases. Controller MUST NOT write production code itself.",
+            purpose: "Implement the minimal passing slice inside explicit file boundaries and return strict worker evidence. v6.12.0 Phase M makes this dispatch mandatory; the linter rule `tdd_slice_implementer_missing` blocks the gate when GREEN was authored by anyone other than `slice-implementer`.",
+            requiresUserGate: false
+        },
+        {
+            agent: "slice-documenter",
+            mode: "mandatory",
             requiredAtTier: "lightweight",
-            when: "When a bounded GREEN/REFACTOR slice has non-overlapping file ownership and a clear RED failure.",
-            purpose: "Implement the minimal passing slice inside explicit file boundaries and return strict worker evidence.",
+            when: "Always in PARALLEL with `slice-implementer --phase green` for the same slice.",
+            purpose: "Write per-slice prose into `<artifacts-dir>/tdd-slices/S-<id>.md` while production code is being implemented. v6.12.0 Phase R makes this mandatory regardless of `discoveryMode`; the linter rule `tdd_slice_documenter_missing` blocks the gate when a `phase=doc` event is missing.",
             requiresUserGate: false
         },
         {

package/dist/content/stages/schema-types.d.ts

@@ -20,7 +20,7 @@ export interface ArtifactValidation {
     tier?: "required" | "recommended";
     validationRule: string;
 }
-export type StageSubagentName = "researcher" | "architect" | "spec-validator" | "spec-document-reviewer" | "coherence-reviewer" | "scope-guardian-reviewer" | "feasibility-reviewer" | "slice-implementer" | "release-reviewer" | "planner" | "product-discovery" | "divergent-thinker" | "critic" | "reviewer" | "security-reviewer" | "integration-overseer" | "test-author" | "doc-updater" | "fixer";
+export type StageSubagentName = "researcher" | "architect" | "spec-validator" | "spec-document-reviewer" | "coherence-reviewer" | "scope-guardian-reviewer" | "feasibility-reviewer" | "slice-implementer" | "slice-documenter" | "release-reviewer" | "planner" | "product-discovery" | "divergent-thinker" | "critic" | "reviewer" | "security-reviewer" | "integration-overseer" | "test-author" | "doc-updater" | "fixer";
 export type StageSubagentDispatchClass = "stage-specialist" | "worker" | "review-lens";
 export type StageSubagentReturnSchema = "planning-return" | "product-return" | "critic-return" | "review-return" | "security-return" | "tdd-return" | "docs-return" | "worker-return" | "fixer-return" | "research-return" | "architecture-return" | "spec-validation-return" | "release-return";
 export interface StageAutoSubagentDispatch {

package/dist/content/stages/tdd.js

@@ -49,8 +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): when `discoveryMode === \"deep\"` is active, dispatch `slice-documenter --slice S-<id> --phase doc` IN PARALLEL with `slice-implementer` for the same slice. The documenter only writes `<artifacts-dir>/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.",
-            "Record evidence — capture test discovery, system-wide impact check, RED failure, GREEN output, and REFACTOR notes in the TDD artifact. When logging a `green` row, attach the closed acceptance-criterion IDs in `acIds` so Ralph Loop status counts them.",
+            "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`).",
+            "**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.",
             "Per-Slice Review (conditional) — if the slice meets any trigger (touchCount >= filesChangedThreshold, touchPaths match touchTriggers, or highRisk=true), append a `## Per-Slice Review` entry for this slice before moving on (see the dedicated section below).",
@@ -62,7 +62,7 @@ export const TDD = {
             "Controller owns orchestration. For each slice S-<id>, dispatch in this order: (1) `test-author --slice S-<id> --phase red` (RED-only, no production edits), (2) `slice-implementer --slice S-<id> --phase green --paths <comma-separated>` for GREEN, (3) re-dispatch `--phase refactor` or `--phase refactor-deferred --refactor-rationale \"<why>\"` to close REFACTOR. Each dispatch records a row in `delegation-events.jsonl` and the linter auto-derives the Watched-RED + Vertical Slice Cycle tables from those rows. Do NOT hand-edit those tables.",
             "Before writing RED tests, discover relevant existing tests and commands so the new test extends the suite instead of fighting it.",
             "Before implementation, perform a system-wide impact check across callbacks, state, interfaces, schemas, and external contracts touched by the slice.",
-            "Slice-documenter (Phase C, opt-in / mandatory on discoveryMode=deep): in parallel with `slice-implementer --phase green`, dispatch `slice-documenter --slice S-<id> --phase doc` whose only `claimedPaths` is `<artifacts-dir>/tdd-slices/S-<id>.md`. The two dispatches run concurrently because their paths are disjoint. The documenter writes per-slice prose so the main `06-tdd.md` stays thin.",
+            "Slice-documenter (mandatory v6.12.0, regardless of `discoveryMode`): in PARALLEL with `slice-implementer --phase green`, dispatch `slice-documenter --slice S-<id> --phase doc` whose only `claimedPaths` is `<artifacts-dir>/tdd-slices/S-<id>.md`. The two dispatches run concurrently because their paths are disjoint. The documenter writes per-slice prose so the main `06-tdd.md` stays thin. Controller MUST NOT author per-slice prose; controller MUST NOT author GREEN production code (use `slice-implementer`).",
             "Run source/test preflight using configured TDD path patterns where feasible; if path classification is impossible (generated files, non-file side effect), record why.",
             "Write behavior-focused tests before changing implementation (RED).",
             "Capture and store failing output as RED evidence.",
@@ -109,16 +109,16 @@ export const TDD = {
             "Relevant existing test files, helpers, fixtures, and exact commands identified before RED.",
             "Callbacks, state transitions, interfaces, schemas, and contracts checked for impact before implementation.",
             "Execution posture and vertical-slice RED/GREEN/REFACTOR checkpoint plan recorded, including commit boundaries when the repo workflow supports them.",
-            "RED observability: a `phase=red` event in `delegation-events.jsonl` for each slice with non-empty evidenceRefs (test path, span ref, or pasted-output pointer). Legacy `## Watched-RED Proof` / `## RED Evidence` markdown tables remain valid as a fallback.",
-            "GREEN observability: a `phase=green` event in `delegation-events.jsonl` per slice whose `completedTs` >= the matching `phase=red` `completedTs` and whose evidenceRefs name the failing-now-passing test. Legacy `## GREEN Evidence` block remains valid as a fallback.",
+            "RED observability: a `phase=red` event in `delegation-events.jsonl` for each slice with non-empty evidenceRefs (test path, span ref, or pasted-output pointer). Slices created **before the v6.12.0 cutover marker** in `flow-state.json::tddCutoverSliceId` may retain legacy `## Watched-RED Proof` / `## RED Evidence` markdown tables; slices created **after the cutover marker** MUST use phase events + slice-documenter doc, and legacy table writes are surfaced by the advisory `tdd_legacy_section_writes_after_cutover` rule.",
+            "GREEN observability: a `phase=green` event in `delegation-events.jsonl` per slice whose `completedTs` >= the matching `phase=red` `completedTs`, authored by `slice-implementer` (linter rule `tdd_slice_implementer_missing` blocks the gate otherwise), and whose evidenceRefs name the failing-now-passing test. Pre-cutover slices may keep legacy `## GREEN Evidence` markdown.",
             "REFACTOR observability: per slice, a `phase=refactor` event OR a `phase=refactor-deferred` event whose evidenceRefs / refactor rationale captures why refactor was deferred.",
+            "Per slice, a `phase=doc` event from `slice-documenter` whose evidenceRefs name `<artifacts-dir>/tdd-slices/S-<id>.md`. Mandatory regardless of `discoveryMode` (v6.12.0 Phase R). Linter rule `tdd_slice_documenter_missing` blocks the gate when missing.",
             "Fresh verification evidence recorded with command, PASS/FAIL status, and commit SHA or no-VCS reason plus content/artifact hash before completion.",
             "Iron Law Acknowledgement section explicitly states `Acknowledged: yes`.",
             "Acceptance mapping documented.",
             "Failure reason analysis recorded.",
             "Refactor rationale captured.",
-            "Traceability to task identifier is documented.",
-            "On discoveryMode=deep: per slice, a `phase=doc` event from `slice-documenter` whose evidenceRefs name `<artifacts-dir>/tdd-slices/S-<id>.md`. On other discovery modes the documenter event is advisory."
+            "Traceability to task identifier is documented."
         ],
         inputs: ["approved plan slice", "spec acceptance criterion", "test harness configuration", "coding standards and constraints"],
         requiredContext: ["plan artifact", "spec artifact", "existing test patterns", "affected contracts and state boundaries"],

package/dist/flow-state.d.ts

@@ -121,6 +121,21 @@ export interface FlowState {
     completedStageMeta?: Partial<Record<FlowStage, {
         completedAt: string;
     }>>;
+    /**
+     * v6.12.0 — TDD migration cutover marker. When `cclaw-cli sync` detects an
+     * existing `06-tdd.md` with legacy per-slice tables but no auto-render
+     * markers, it inserts the markers and records the highest legacy slice id
+     * here (e.g. `"S-10"`). The TDD linter uses this value to:
+     *   - exempt slices `<= cutoverSliceId` from new mandatory rules (legacy
+     *     slices keep their markdown tables);
+     *   - emit `tdd_legacy_section_writes_after_cutover` advisory when a slice
+     *     id `> cutoverSliceId` appears in legacy per-slice sections of
+     *     `06-tdd.md` (post-cutover prose belongs in `tdd-slices/S-<id>.md`).
+     *
+     * Optional + best-effort: omitted on fresh installs and on legacy files
+     * sync hasn't visited yet.
+     */
+    tddCutoverSliceId?: string;
 }
 export interface StageInteractionHint {
     skipQuestions?: boolean;

package/dist/install.js

@@ -835,6 +835,112 @@ async function writeState(projectRoot, config, forceReset = false) {
     const state = createInitialFlowState({ track: "standard" });
     await writeFileSafe(statePath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
 }
+/**
+ * v6.12.0 — TDD auto-cutover sync. When sync detects a legacy `06-tdd.md`
+ * (no auto-render markers) carrying observable slice activity (e.g. `S-N`
+ * referenced ≥3 times in slice-section bodies), insert the v6.11.0 marker
+ * skeleton + a one-line cutover banner and stamp the highest legacy slice
+ * id into `flow-state.json::tddCutoverSliceId`. Idempotent: re-running sync
+ * is byte-stable once markers are present.
+ *
+ * Design notes:
+ *   - Best-effort: read failures, missing flow-state, or unparseable JSON
+ *     all short-circuit silently. We never throw inside sync for migration
+ *     bookkeeping.
+ *   - We use `writeFlowState({ allowReset: true })` so we don't trip
+ *     `validateFlowTransition` (the only field we mutate is the new
+ *     additive `tddCutoverSliceId`; transition rules don't apply).
+ *   - The banner mirrors the language in the `## Per-Slice Ritual`
+ *     skill section so a reader of `06-tdd.md` who hasn't seen v6.12.0
+ *     understands the contract change.
+ */
+async function applyTddCutoverIfNeeded(projectRoot) {
+    const tddArtifactPath = runtimePath(projectRoot, "artifacts", "06-tdd.md");
+    let existing;
+    try {
+        existing = await fs.readFile(tddArtifactPath, "utf8");
+    }
+    catch {
+        return;
+    }
+    if (existing.includes("<!-- auto-start: tdd-slice-summary -->")) {
+        return;
+    }
+    const sliceMatches = [...existing.matchAll(/\bS-(\d+)\b/gu)];
+    if (sliceMatches.length < 3) {
+        return;
+    }
+    let maxSliceNum = 0;
+    for (const match of sliceMatches) {
+        const n = Number.parseInt(match[1], 10);
+        if (Number.isFinite(n) && n > maxSliceNum) {
+            maxSliceNum = n;
+        }
+    }
+    if (maxSliceNum <= 0) {
+        return;
+    }
+    const cutoverSliceId = `S-${maxSliceNum}`;
+    const banner = [
+        `<!-- v6.12.0 cutover: slices S-1..${cutoverSliceId} use legacy per-slice tables.`,
+        `     New slices (S-${maxSliceNum + 1}+) use phase events + tdd-slices/<id>.md.`,
+        "     Controller MUST NOT add new rows to legacy sections. -->"
+    ].join("\n");
+    const slicesIndexBlock = [
+        "<!-- auto-start: slices-index -->",
+        "## Slices Index",
+        "",
+        "_Auto-rendered from `tdd-slices/S-*.md` once slice-documenter or controller writes per-slice files. Do not edit by hand._",
+        "<!-- auto-end: slices-index -->"
+    ].join("\n");
+    const summaryBlock = [
+        "<!-- auto-start: tdd-slice-summary -->",
+        "<!-- auto-end: tdd-slice-summary -->"
+    ].join("\n");
+    let nextRaw;
+    if (existing.startsWith("---\n")) {
+        const fmEnd = existing.indexOf("\n---", 4);
+        if (fmEnd >= 0) {
+            const fmClose = fmEnd + 4;
+            const head = existing.slice(0, fmClose);
+            const tail = existing.slice(fmClose);
+            nextRaw = `${head}\n\n${banner}\n\n${slicesIndexBlock}\n\n${summaryBlock}\n${tail}`;
+        }
+        else {
+            nextRaw = `${banner}\n\n${slicesIndexBlock}\n\n${summaryBlock}\n\n${existing}`;
+        }
+    }
+    else {
+        nextRaw = `${banner}\n\n${slicesIndexBlock}\n\n${summaryBlock}\n\n${existing}`;
+    }
+    await writeFileSafe(tddArtifactPath, nextRaw);
+    const slicesDir = runtimePath(projectRoot, "artifacts", "tdd-slices");
+    await ensureDir(slicesDir);
+    const flowStatePath = runtimePath(projectRoot, "state", "flow-state.json");
+    let flowStateRaw;
+    try {
+        flowStateRaw = await fs.readFile(flowStatePath, "utf8");
+    }
+    catch {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(flowStateRaw);
+    }
+    catch {
+        return;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return;
+    }
+    const obj = parsed;
+    if (typeof obj.tddCutoverSliceId === "string" && obj.tddCutoverSliceId.length > 0) {
+        return;
+    }
+    obj.tddCutoverSliceId = cutoverSliceId;
+    await writeFileSafe(flowStatePath, `${JSON.stringify(obj, null, 2)}\n`, { mode: 0o600 });
+}
 async function cleanLegacyArtifacts(projectRoot) {
     for (const legacyFolder of DEPRECATED_UTILITY_SKILL_FOLDERS) {
         await removeBestEffort(runtimePath(projectRoot, "skills", legacyFolder), true);
@@ -985,6 +1091,9 @@ async function materializeRuntime(projectRoot, config, forceStateReset, operatio
             writeRulebook(projectRoot)
         ]);
         await writeState(projectRoot, config, forceStateReset);
+        if (operation === "sync" || operation === "upgrade") {
+            await applyTddCutoverIfNeeded(projectRoot);
+        }
         try {
             await ensureRunSystem(projectRoot, { createIfMissing: false });
         }

package/dist/run-persistence.js

@@ -471,6 +471,7 @@ function coerceFlowState(parsed) {
     const taskClass = coerceTaskClass(parsed.taskClass);
     const repoSignals = coerceRepoSignals(parsed.repoSignals);
     const completedStageMeta = sanitizeCompletedStageMeta(parsed.completedStageMeta);
+    const tddCutoverSliceId = coerceTddCutoverSliceId(parsed.tddCutoverSliceId);
     const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
@@ -483,6 +484,7 @@ function coerceFlowState(parsed) {
         ...(taskClass !== undefined ? { taskClass } : {}),
         ...(repoSignals ? { repoSignals } : {}),
         ...(completedStageMeta ? { completedStageMeta } : {}),
+        ...(tddCutoverSliceId ? { tddCutoverSliceId } : {}),
         skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
         staleStages: sanitizeStaleStages(parsed.staleStages),
         rewinds: sanitizeRewinds(parsed.rewinds),
@@ -492,6 +494,17 @@ function coerceFlowState(parsed) {
     };
     return { state };
 }
+/**
+ * v6.12.0 — best-effort coercion for `tddCutoverSliceId`. Returns the value
+ * only when it matches the canonical slice id shape `S-<digits>`; otherwise
+ * returns null so the field is omitted from the rehydrated state.
+ */
+function coerceTddCutoverSliceId(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return /^S-\d+$/u.test(trimmed) ? trimmed : null;
+}
 export class CorruptFlowStateError extends Error {
     statePath;
     quarantinedPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "6.11.0",
+  "version": "6.12.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {