cclaw-cli 7.0.5 → 7.1.0

package/dist/artifact-linter/tdd.js

@@ -481,6 +481,134 @@ function groupBySlice(entries) {
     }
     return grouped;
 }
+/** Group completed phase rows for a slice by `spanId` (falls back to a single legacy bucket). */
+function groupSliceRowsBySpanId(rows) {
+    const grouped = new Map();
+    for (const entry of rows) {
+        const spanKey = typeof entry.spanId === "string" && entry.spanId.length > 0 ? entry.spanId : "__missing-span__";
+        const list = grouped.get(spanKey) ?? [];
+        list.push(entry);
+        grouped.set(spanKey, list);
+    }
+    return grouped;
+}
+function maxPhaseTimestampForSpan(rows) {
+    let max = "";
+    for (const entry of rows) {
+        const ts = entry.completedTs ?? entry.endTs ?? entry.ts ?? "";
+        if (typeof ts === "string" && ts.length > 0 && ts > max)
+            max = ts;
+    }
+    return max;
+}
+/**
+ * Validate RED→GREEN→REFACTOR (incl. green `refactorOutcome`) monotonicity for one slice-builder span.
+ * `rows` must contain only entries for that span.
+ */
+function evaluateSingleSpanSliceCycle(sliceId, spanId, rows) {
+    const errors = [];
+    const findings = [];
+    const sec = (slug) => `${slug}:${sliceId}@${spanId}`;
+    const reds = rows.filter((entry) => entry.phase === "red");
+    const greens = rows.filter((entry) => entry.phase === "green");
+    const refactors = rows.filter((entry) => entry.phase === "refactor" || entry.phase === "refactor-deferred");
+    const redTs = pickEventTs(reds);
+    const greenTs = pickEventTs(greens);
+    if (reds.length === 0) {
+        errors.push(`${sliceId}: phase=red event missing.`);
+        findings.push({
+            section: sec("tdd_slice_red_missing"),
+            required: true,
+            rule: "Each TDD slice with phase events must include a `phase=red` row.",
+            found: false,
+            details: `${sliceId} (span ${spanId}): no phase=red event recorded for the active run.`
+        });
+        return { ok: false, errors, findings };
+    }
+    if (greens.length === 0) {
+        errors.push(`${sliceId}: phase=green event missing.`);
+        findings.push({
+            section: sec("tdd_slice_green_missing"),
+            required: true,
+            rule: "Each TDD slice with a phase=red event must reach a `phase=green` row before stage-complete.",
+            found: false,
+            details: `${sliceId} (span ${spanId}): no phase=green event recorded; RED has no matching GREEN.`
+        });
+        return { ok: false, errors, findings };
+    }
+    if (greenTs && redTs && greenTs < redTs) {
+        errors.push(`${sliceId}: phase=green completedTs (${greenTs}) precedes phase=red (${redTs}).`);
+        findings.push({
+            section: sec("tdd_slice_phase_order_invalid"),
+            required: true,
+            rule: "Phase events must be monotonic: phase=green completedTs >= phase=red completedTs.",
+            found: false,
+            details: `${sliceId} (span ${spanId}): green at ${greenTs} precedes red at ${redTs}.`
+        });
+        return { ok: false, errors, findings };
+    }
+    const greenEvidenceRef = greens
+        .flatMap((entry) => (Array.isArray(entry.evidenceRefs) ? entry.evidenceRefs : []))
+        .find((ref) => typeof ref === "string" && ref.trim().length > 0);
+    if (!greenEvidenceRef) {
+        errors.push(`${sliceId}: phase=green row has empty evidenceRefs.`);
+        findings.push({
+            section: sec("tdd_slice_evidence_missing"),
+            required: true,
+            rule: "Each `phase=green` event must record at least one evidenceRef (path to test artifact, span id, or pasted-output pointer).",
+            found: false,
+            details: `${sliceId} (span ${spanId}): phase=green event missing evidenceRefs.`
+        });
+        return { ok: false, errors, findings };
+    }
+    const greenWithOutcome = greens.find((entry) => entry.refactorOutcome &&
+        (entry.refactorOutcome.mode === "inline" || entry.refactorOutcome.mode === "deferred"));
+    if (refactors.length === 0 && !greenWithOutcome) {
+        errors.push(`${sliceId}: phase=refactor or phase=refactor-deferred event missing.`);
+        findings.push({
+            section: sec("tdd_slice_refactor_missing"),
+            required: true,
+            rule: "Each TDD slice must close with a `phase=refactor` event, a `phase=refactor-deferred` event whose evidenceRefs / refactorRationale captures why refactor was deferred, OR a `phase=green` event carrying `refactorOutcome`.",
+            found: false,
+            details: `${sliceId} (span ${spanId}): no phase=refactor / phase=refactor-deferred event and no refactorOutcome on phase=green.`
+        });
+        return { ok: false, errors, findings };
+    }
+    if (greenWithOutcome &&
+        greenWithOutcome.refactorOutcome?.mode === "deferred" &&
+        !greenWithOutcome.refactorOutcome.rationale &&
+        !(Array.isArray(greenWithOutcome.evidenceRefs) &&
+            greenWithOutcome.evidenceRefs.some((ref) => typeof ref === "string" && ref.trim().length > 0))) {
+        errors.push(`${sliceId}: phase=green refactorOutcome=deferred missing rationale.`);
+        findings.push({
+            section: sec("tdd_slice_refactor_missing"),
+            required: true,
+            rule: "phase=green refactorOutcome=deferred requires a rationale (via --refactor-rationale or --evidence-ref).",
+            found: false,
+            details: `${sliceId} (span ${spanId}): phase=green refactorOutcome.mode=deferred recorded without rationale.`
+        });
+        return { ok: false, errors, findings };
+    }
+    const deferred = refactors.find((entry) => entry.phase === "refactor-deferred");
+    if (refactors.length > 0 &&
+        deferred &&
+        refactors.every((entry) => entry.phase === "refactor-deferred")) {
+        const refs = Array.isArray(deferred.evidenceRefs) ? deferred.evidenceRefs : [];
+        const hasRationale = refs.some((ref) => typeof ref === "string" && ref.trim().length > 0);
+        if (!hasRationale) {
+            errors.push(`${sliceId}: phase=refactor-deferred row needs evidenceRefs containing a rationale.`);
+            findings.push({
+                section: sec("tdd_slice_refactor_missing"),
+                required: true,
+                rule: "phase=refactor-deferred must record a rationale via --refactor-rationale or via --evidence-ref pointing at the rationale text.",
+                found: false,
+                details: `${sliceId} (span ${spanId}): phase=refactor-deferred recorded without rationale evidenceRefs.`
+            });
+            return { ok: false, errors, findings };
+        }
+    }
+    return { ok: true, errors: [], findings: [] };
+}
 export function evaluateEventsWatchedRed(slices) {
     const errors = [];
     let redCount = 0;
@@ -525,109 +653,23 @@ export function evaluateEventsSliceCycle(slices) {
     const errors = [];
     const findings = [];
     for (const [sliceId, rows] of slices.entries()) {
-        const reds = rows.filter((entry) => entry.phase === "red");
-        const greens = rows.filter((entry) => entry.phase === "green");
-        const refactors = rows.filter((entry) => entry.phase === "refactor" || entry.phase === "refactor-deferred");
-        const redTs = pickEventTs(reds);
-        const greenTs = pickEventTs(greens);
-        if (reds.length === 0) {
-            errors.push(`${sliceId}: phase=red event missing.`);
-            findings.push({
-                section: `tdd_slice_red_missing:${sliceId}`,
-                required: true,
-                rule: "Each TDD slice with phase events must include a `phase=red` row.",
-                found: false,
-                details: `${sliceId}: no phase=red event recorded for the active run.`
-            });
-            continue;
-        }
-        if (greens.length === 0) {
-            errors.push(`${sliceId}: phase=green event missing.`);
-            findings.push({
-                section: `tdd_slice_green_missing:${sliceId}`,
-                required: true,
-                rule: "Each TDD slice with a phase=red event must reach a `phase=green` row before stage-complete.",
-                found: false,
-                details: `${sliceId}: no phase=green event recorded; RED has no matching GREEN.`
-            });
-            continue;
-        }
-        if (greenTs && redTs && greenTs < redTs) {
-            errors.push(`${sliceId}: phase=green completedTs (${greenTs}) precedes phase=red (${redTs}).`);
-            findings.push({
-                section: `tdd_slice_phase_order_invalid:${sliceId}`,
-                required: true,
-                rule: "Phase events must be monotonic: phase=green completedTs >= phase=red completedTs.",
-                found: false,
-                details: `${sliceId}: green at ${greenTs} precedes red at ${redTs}.`
+        const bySpan = groupSliceRowsBySpanId(rows);
+        const spanOutcomes = [];
+        for (const [spanId, spanRows] of bySpan.entries()) {
+            const result = evaluateSingleSpanSliceCycle(sliceId, spanId, spanRows);
+            spanOutcomes.push({
+                spanId,
+                maxTs: maxPhaseTimestampForSpan(spanRows),
+                result
             });
-            continue;
         }
-        const greenEvidenceRef = greens
-            .flatMap((entry) => Array.isArray(entry.evidenceRefs) ? entry.evidenceRefs : [])
-            .find((ref) => typeof ref === "string" && ref.trim().length > 0);
-        if (!greenEvidenceRef) {
-            errors.push(`${sliceId}: phase=green row has empty evidenceRefs.`);
-            findings.push({
-                section: `tdd_slice_evidence_missing:${sliceId}`,
-                required: true,
-                rule: "Each `phase=green` event must record at least one evidenceRef (path to test artifact, span id, or pasted-output pointer).",
-                found: false,
-                details: `${sliceId}: phase=green event missing evidenceRefs.`
-            });
+        if (spanOutcomes.some((s) => s.result.ok)) {
             continue;
         }
-        // refactorOutcome on phase=green satisfies REFACTOR coverage
-        // without a separate phase=refactor / phase=refactor-deferred row.
-        // - mode: "inline" → REFACTOR ran inline as part of GREEN.
-        // - mode: "deferred" → rationale required (carried in evidenceRefs[0]
-        //   by the hook helper so legacy linters keep working).
-        const greenWithOutcome = greens.find((entry) => entry.refactorOutcome &&
-            (entry.refactorOutcome.mode === "inline" || entry.refactorOutcome.mode === "deferred"));
-        if (refactors.length === 0 && !greenWithOutcome) {
-            errors.push(`${sliceId}: phase=refactor or phase=refactor-deferred event missing.`);
-            findings.push({
-                section: `tdd_slice_refactor_missing:${sliceId}`,
-                required: true,
-                rule: "Each TDD slice must close with a `phase=refactor` event, a `phase=refactor-deferred` event whose evidenceRefs / refactorRationale captures why refactor was deferred, OR a `phase=green` event carrying `refactorOutcome`.",
-                found: false,
-                details: `${sliceId}: no phase=refactor / phase=refactor-deferred event and no refactorOutcome on phase=green.`
-            });
-            continue;
-        }
-        if (greenWithOutcome &&
-            greenWithOutcome.refactorOutcome?.mode === "deferred" &&
-            !greenWithOutcome.refactorOutcome.rationale &&
-            !(Array.isArray(greenWithOutcome.evidenceRefs) &&
-                greenWithOutcome.evidenceRefs.some((ref) => typeof ref === "string" && ref.trim().length > 0))) {
-            errors.push(`${sliceId}: phase=green refactorOutcome=deferred missing rationale.`);
-            findings.push({
-                section: `tdd_slice_refactor_missing:${sliceId}`,
-                required: true,
-                rule: "phase=green refactorOutcome=deferred requires a rationale (via --refactor-rationale or --evidence-ref).",
-                found: false,
-                details: `${sliceId}: phase=green refactorOutcome.mode=deferred recorded without rationale.`
-            });
-            continue;
-        }
-        const deferred = refactors.find((entry) => entry.phase === "refactor-deferred");
-        if (refactors.length > 0 &&
-            deferred &&
-            refactors.every((entry) => entry.phase === "refactor-deferred")) {
-            const refs = Array.isArray(deferred.evidenceRefs) ? deferred.evidenceRefs : [];
-            const hasRationale = refs.some((ref) => typeof ref === "string" && ref.trim().length > 0);
-            if (!hasRationale) {
-                errors.push(`${sliceId}: phase=refactor-deferred row needs evidenceRefs containing a rationale.`);
-                findings.push({
-                    section: `tdd_slice_refactor_missing:${sliceId}`,
-                    required: true,
-                    rule: "phase=refactor-deferred must record a rationale via --refactor-rationale or via --evidence-ref pointing at the rationale text.",
-                    found: false,
-                    details: `${sliceId}: phase=refactor-deferred recorded without rationale evidenceRefs.`
-                });
-                continue;
-            }
-        }
+        spanOutcomes.sort((a, b) => (a.maxTs < b.maxTs ? 1 : a.maxTs > b.maxTs ? -1 : 0));
+        const chosen = spanOutcomes[0];
+        errors.push(...chosen.result.errors);
+        findings.push(...chosen.result.findings);
     }
     if (errors.length > 0) {
         return {
@@ -638,7 +680,7 @@ export function evaluateEventsSliceCycle(slices) {
     }
     return {
         ok: true,
-        details: `${slices.size} slice(s) show monotonic phase=red -> phase=green -> phase=refactor (deferred-with-rationale accepted).`,
+        details: `${slices.size} slice(s) show monotonic phase=red -> phase=green -> phase=refactor (deferred-with-rationale accepted); at least one span per slice satisfies the cycle.`,
         findings: []
     };
 }

package/dist/config.d.ts

@@ -1,4 +1,6 @@
-import type { CclawConfig, FlowTrack, HarnessId, LanguageRulePack } from "./types.js";
+import type { CclawConfig, FlowTrack, HarnessId, LanguageRulePack, TddCommitMode } from "./types.js";
+export declare const TDD_COMMIT_MODES: readonly ["managed-per-slice", "agent-required", "checkpoint-only", "off"];
+export declare const DEFAULT_TDD_COMMIT_MODE: TddCommitMode;
 export declare const DEFAULT_TDD_TEST_PATH_PATTERNS: readonly string[];
 export declare const DEFAULT_TDD_TEST_GLOBS: readonly string[];
 export declare const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS: readonly string[];
@@ -16,6 +18,7 @@ export declare class InvalidConfigError extends Error {
 }
 export declare function configPath(projectRoot: string): string;
 export declare function createDefaultConfig(harnesses?: HarnessId[], _defaultTrack?: FlowTrack): CclawConfig;
+export declare function resolveTddCommitMode(config: Pick<CclawConfig, "tdd"> | null | undefined): TddCommitMode;
 export declare function detectLanguageRulePacks(_projectRoot: string): Promise<LanguageRulePack[]>;
 export declare function readConfig(projectRoot: string, _options?: ReadConfigOptions): Promise<CclawConfig>;
 export interface WriteConfigOptions {

package/dist/config.js

@@ -6,8 +6,16 @@ import { exists, writeFileSafe } from "./fs-utils.js";
 import { HARNESS_IDS } from "./types.js";
 const CONFIG_PATH = `${RUNTIME_ROOT}/config.yaml`;
 const HARNESS_ID_SET = new Set(HARNESS_IDS);
-const ALLOWED_CONFIG_KEYS = new Set(["version", "flowVersion", "harnesses"]);
+const ALLOWED_CONFIG_KEYS = new Set(["version", "flowVersion", "harnesses", "tdd"]);
 const SUPPORTED_HARNESSES_TEXT = HARNESS_IDS.join(", ");
+export const TDD_COMMIT_MODES = [
+    "managed-per-slice",
+    "agent-required",
+    "checkpoint-only",
+    "off"
+];
+const TDD_COMMIT_MODE_SET = new Set(TDD_COMMIT_MODES);
+export const DEFAULT_TDD_COMMIT_MODE = "managed-per-slice";
 // Kept for runtime modules that use these defaults directly.
 export const DEFAULT_TDD_TEST_PATH_PATTERNS = [
     "**/*.test.*",
@@ -30,7 +38,9 @@ export class InvalidConfigError extends Error {
 function configFixExample() {
     return `harnesses:
   - claude
-  - cursor`;
+  - cursor
+tdd:
+  commitMode: managed-per-slice`;
 }
 function configValidationError(configFilePath, reason) {
     return new InvalidConfigError(`Invalid cclaw config at ${configFilePath}: ${reason}\n` +
@@ -48,9 +58,19 @@ export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, _defaultTrack
     return {
         version: CCLAW_VERSION,
         flowVersion: FLOW_VERSION,
-        harnesses: [...new Set(harnesses)]
+        harnesses: [...new Set(harnesses)],
+        tdd: {
+            commitMode: DEFAULT_TDD_COMMIT_MODE
+        }
     };
 }
+export function resolveTddCommitMode(config) {
+    const raw = config?.tdd?.commitMode;
+    if (typeof raw === "string" && TDD_COMMIT_MODE_SET.has(raw)) {
+        return raw;
+    }
+    return DEFAULT_TDD_COMMIT_MODE;
+}
 function assertOnlySupportedKeys(parsed, fullPath) {
     const unknownKeys = Object.keys(parsed).filter((key) => !ALLOWED_CONFIG_KEYS.has(key));
     if (unknownKeys.length === 0)
@@ -84,6 +104,10 @@ export async function readConfig(projectRoot, _options = {}) {
         !Array.isArray(parsed.harnesses)) {
         throw configValidationError(fullPath, `"harnesses" must be an array`);
     }
+    if (Object.prototype.hasOwnProperty.call(parsed, "tdd") &&
+        !isRecord(parsed.tdd)) {
+        throw configValidationError(fullPath, `"tdd" must be an object when provided`);
+    }
     const rawHarnesses = Array.isArray(parsed.harnesses) ? parsed.harnesses : DEFAULT_HARNESSES;
     const normalizedHarnesses = [];
     for (const harness of rawHarnesses) {
@@ -103,17 +127,32 @@ export async function readConfig(projectRoot, _options = {}) {
     const flowVersion = typeof parsed.flowVersion === "string" && parsed.flowVersion.trim().length > 0
         ? parsed.flowVersion
         : FLOW_VERSION;
+    const parsedTdd = isRecord(parsed.tdd) ? parsed.tdd : {};
+    const rawCommitMode = parsedTdd.commitMode;
+    if (rawCommitMode !== undefined &&
+        (typeof rawCommitMode !== "string" || !TDD_COMMIT_MODE_SET.has(rawCommitMode))) {
+        throw configValidationError(fullPath, `"tdd.commitMode" must be one of: ${TDD_COMMIT_MODES.join(", ")}`);
+    }
+    const commitMode = typeof rawCommitMode === "string"
+        ? rawCommitMode
+        : DEFAULT_TDD_COMMIT_MODE;
     return {
         version,
         flowVersion,
-        harnesses: normalizedHarnesses
+        harnesses: normalizedHarnesses,
+        tdd: {
+            commitMode
+        }
     };
 }
 export async function writeConfig(projectRoot, config, _options = {}) {
     const serialisable = {
         version: config.version,
         flowVersion: config.flowVersion,
-        harnesses: config.harnesses
+        harnesses: config.harnesses,
+        tdd: {
+            commitMode: resolveTddCommitMode(config)
+        }
     };
     await writeFileSafe(configPath(projectRoot), stringify(serialisable));
 }

package/dist/content/core-agents.js

@@ -156,6 +156,7 @@ export function sliceBuilderProtocol() {
         "### Invariants",
         "- Produce failing RED evidence (or cite the delegated RED artifact) **before** production edits.",
         "- Stay inside the slice contract: `claimedPaths`, acceptance mapping, and forbidden-change lists from the parent.",
+        "- When `tdd.commitMode=managed-per-slice`, do **not** hand-edit git state for slice files (no manual `git add/commit` on claimed paths). Let `.cclaw/hooks/slice-commit.mjs` own per-slice commits.",
         "- After GREEN, refactor inline **or** record deferred refactor via the same `--refactor-outcome` mechanics the controller specifies.",
         "- Own the prose slice summary at `<artifacts-dir>/tdd-slices/S-<id>.md` yourself.",
         "",

package/dist/content/hooks.d.ts

@@ -2,6 +2,7 @@ export declare function startFlowScript(): string;
 export declare function cancelRunScript(): string;
 export declare function stageCompleteScript(): string;
 export declare function delegationRecordScript(): string;
+export declare function sliceCommitScript(): string;
 export declare function runHookCmdScript(): string;
 export { claudeHooksJsonWithObservation as claudeHooksJson } from "./observe.js";
 export { cursorHooksJsonWithObservation as cursorHooksJson } from "./observe.js";

package/dist/content/hooks.js

@@ -200,6 +200,7 @@ export function stageCompleteScript() {
 export function delegationRecordScript() {
     return `#!/usr/bin/env node
 import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
@@ -1189,6 +1190,101 @@ async function runRepair(args, json) {
   }
 }
 
+async function runSliceCommitIfNeeded(root, row, runId) {
+  if (
+    row.stage !== "tdd" ||
+    row.agent !== "slice-builder" ||
+    row.status !== "completed" ||
+    row.phase !== "doc"
+  ) {
+    return { ok: true, skipped: true };
+  }
+  const sliceId = typeof row.sliceId === "string" ? row.sliceId.trim() : "";
+  const spanId = typeof row.spanId === "string" ? row.spanId.trim() : "";
+  if (sliceId.length === 0 || spanId.length === 0) {
+    return { ok: true, skipped: true };
+  }
+  const helperPath = path.join(root, RUNTIME_ROOT, "hooks", "slice-commit.mjs");
+  if (!(await exists(helperPath))) {
+    return { ok: true, skipped: true };
+  }
+  const helperArgs = [
+    helperPath,
+    "--json",
+    "--quiet",
+    "--slice=" + sliceId,
+    "--span-id=" + spanId,
+    "--run-id=" + runId
+  ];
+  if (typeof row.taskId === "string" && row.taskId.trim().length > 0) {
+    helperArgs.push("--task-id=" + row.taskId.trim());
+  }
+  if (Array.isArray(row.claimedPaths) && row.claimedPaths.length > 0) {
+    helperArgs.push("--claimed-paths=" + row.claimedPaths.join(","));
+  }
+  if (Array.isArray(row.evidenceRefs) && row.evidenceRefs.length > 0) {
+    const title = String(row.evidenceRefs[0] || "").trim();
+    if (title.length > 0) {
+      helperArgs.push("--title=" + title.slice(0, 120));
+    }
+  }
+
+  return await new Promise((resolve) => {
+    const child = spawn(process.execPath, helperArgs, {
+      cwd: root,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let out = "";
+    let err = "";
+    child.stdout.on("data", (chunk) => {
+      out += String(chunk ?? "");
+    });
+    child.stderr.on("data", (chunk) => {
+      err += String(chunk ?? "");
+    });
+    child.on("error", (error) => {
+      resolve({
+        ok: false,
+        errorCode: "slice_commit_failed",
+        details: {
+          message: error instanceof Error ? error.message : String(error)
+        }
+      });
+    });
+    child.on("close", (code) => {
+      let payload = null;
+      const trimmed = out.trim();
+      if (trimmed.length > 0) {
+        try {
+          payload = JSON.parse(trimmed);
+        } catch {
+          payload = null;
+        }
+      }
+      if (code === 0) {
+        resolve({ ok: true, payload });
+        return;
+      }
+      const payloadCode =
+        payload && typeof payload === "object" && typeof payload.errorCode === "string"
+          ? payload.errorCode
+          : "slice_commit_failed";
+      resolve({
+        ok: false,
+        errorCode: payloadCode,
+        details:
+          payload && typeof payload === "object"
+            ? payload
+            : {
+              stderr: err.trim(),
+              stdout: out.trim()
+            }
+      });
+    });
+  });
+}
+
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const json = args.json !== undefined;
@@ -1573,6 +1669,23 @@ async function main() {
     }
   }
 
+  const sliceCommitResult = await runSliceCommitIfNeeded(root, clean, runId);
+  if (!sliceCommitResult.ok) {
+    emitErrorJson(
+      sliceCommitResult.errorCode || "slice_commit_failed",
+      sliceCommitResult.details || {},
+      json
+    );
+    return;
+  }
+  if (
+    sliceCommitResult.payload &&
+    typeof sliceCommitResult.payload === "object" &&
+    typeof sliceCommitResult.payload.commitSha === "string"
+  ) {
+    event.sliceCommitSha = sliceCommitResult.payload.commitSha;
+  }
+
   await persistEntry(root, runId, clean, event);
 
   process.stdout.write(JSON.stringify({ ok: true, event }, null, 2) + "\\n");
@@ -1581,6 +1694,9 @@ async function main() {
 void main();
 `;
 }
+export function sliceCommitScript() {
+    return internalHelperScript("slice-commit", "slice-commit", "Usage: node " + RUNTIME_ROOT + "/hooks/slice-commit.mjs --slice=<S-N> --span-id=<span-id> [--task-id=<T-id>] [--title=<text>] [--run-id=<run-id>] [--claimed-paths=<path1,path2,...>] [--claimed-path=<path> ...] [--json] [--quiet]");
+}
 export function runHookCmdScript() {
     return `: << 'CMDBLOCK'
 @echo off

package/dist/content/stages/tdd.js

@@ -52,7 +52,7 @@ export const TDD = {
             "Controller never writes production code or per-slice prose — the delegated worker does. Record routing decisions; cite `wave-status` before redundant slice questions.",
             "Discover existing tests and commands before RED; run a system-wide impact check (callbacks, state, interfaces, contracts) before GREEN.",
             "RED must fail for the right reason; capture logs. GREEN must run the full relevant suite, not a narrow subset.",
-            "Before calling a slice done, run verification-before-completion (command + PASS/FAIL + commit SHA or no-VCS attestation).",
+            "Before calling a slice done, run verification-before-completion (command + PASS/FAIL + durable commit evidence: managed-per-slice git commits when `.git` is present, or explicit no-VCS attestation + hash).",
             "Integration-overseer must complete with PASS/PASS_WITH_GAPS when fan-out closes a wave unless the controller emits `cclaw_integration_overseer_skipped` for a documented heuristic skip.",
             "Investigation discipline + behavior anchor in this skill govern evidence: cite commands and paths, not pasted source dumps.",
         ],
@@ -72,7 +72,7 @@ export const TDD = {
             { id: "tdd_red_test_written", description: "Failing tests exist before implementation changes." },
             { id: "tdd_green_full_suite", description: "Full relevant suite passes in GREEN state." },
             { id: "tdd_refactor_completed", description: "Refactor pass completed with behavior preservation verified." },
-            { id: "tdd_verified_before_complete", description: "Fresh verification evidence includes test command, explicit pass/fail status, and a durable ref: commit SHA when `.git` is present or explicit no-VCS attestation + hash when not." },
+            { id: "tdd_verified_before_complete", description: "Fresh verification evidence includes test command + explicit pass/fail status; when `tdd.commitMode=managed-per-slice` and `.git` exists, closed slices must be backed by real git commits, otherwise provide explicit no-VCS attestation + hash." },
             { id: "tdd_iron_law_acknowledged", description: "Iron Law acknowledgement is explicit (`Acknowledged: yes`) before implementation proceeds." },
             { id: "tdd_watched_red_observed", description: "Watched-RED Proof records at least one observed failing test with ISO timestamp evidence." },
             { id: "tdd_slice_cycle_complete", description: "Vertical Slice Cycle records RED, GREEN, and REFACTOR phases per active slice." },
@@ -89,7 +89,7 @@ export const TDD = {
             "REFACTOR coverage: separate `phase=refactor|refactor-deferred` rows or `refactorOutcome` folded into GREEN as the hook documents.",
             "`tdd-slices/S-<id>.md` kept current with the builder span; phase events remain the ground truth for lint auto-render blocks.",
             "`event: slice-completed` umbrella rows tie RED/GREEN timestamps to the builder once that writer runs on the repo.",
-            "Fresh verification (command + PASS/FAIL + commit SHA or no-VCS reason + hash); Iron Law acknowledgement; acceptance mapping + traceability IDs.",
+            "Fresh verification (command + PASS/FAIL + managed-per-slice commit proof from git log when `.git` exists, or no-VCS reason + hash); Iron Law acknowledgement; acceptance mapping + traceability IDs.",
         ],
         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"],
@@ -135,7 +135,7 @@ export const TDD = {
             { section: "REFACTOR Notes", required: true, validationRule: "What changed, why, behavior preservation confirmed." },
             { section: "Traceability", required: true, validationRule: "Plan task ID and spec criterion linked." },
             { section: "Iron Law Acknowledgement", required: true, validationRule: "Must include `Acknowledged: yes` and list exceptions (or `None`)." },
-            { section: "Verification Ladder", required: true, validationRule: "Per-slice verification tier (static, command, behavioral, human) with evidence captured for the highest tier reached this turn. Must include command + PASS/FAIL + commit SHA when VCS is present, or explicit no-vcs reason plus content/artifact hash/config override." },
+            { section: "Verification Ladder", required: true, validationRule: "Per-slice verification tier (static, command, behavioral, human) with evidence captured for the highest tier reached this turn. Must include command + PASS/FAIL and durable commit evidence: managed-per-slice git commit proof when VCS is present, or explicit no-vcs reason plus content/artifact hash/config override." },
             { section: "TDD Blocker Taxonomy", required: false, validationRule: "When blocked, classify as NO_SOURCE_CONTEXT, NO_TEST_SURFACE, NO_IMPLEMENTABLE_SLICE, RED_NOT_EXPRESSIBLE, or NO_VCS_MODE; include blockedBecause, missingInputs, recommendedRoute, nextCommand, and resumeCriteria." }
         ]
     },

package/dist/delegation.d.ts

@@ -344,6 +344,61 @@ export declare class DispatchCapError extends Error {
         };
     });
 }
+/**
+ * Return `true` when `path` is a repo-relative path owned by the cclaw
+ * managed runtime under `.cclaw/`. Used by `validateClaimedPathsNotProtected`
+ * during `appendDelegation` to reject `slice-builder` (or any worker)
+ * spans that try to claim ownership of cclaw-managed files. Does not
+ * normalise the input — callers pass the path exactly as the worker wrote
+ * it into `claimedPaths` so the error message points at the real string.
+ */
+export declare function isManagedRuntimePath(path: string): boolean;
+/**
+ * Thrown by `appendDelegation` when a scheduled span declares a
+ * `claimedPaths` entry that lives under the cclaw managed runtime
+ * (see `isManagedRuntimePath`). Workers must never edit those paths
+ * directly — they are owned by the managed sync surface. The error
+ * lists the offending paths so the operator can drop or rewrite them.
+ */
+export declare class DispatchClaimedPathProtectedError extends Error {
+    readonly protectedPaths: string[];
+    readonly spanId: string;
+    constructor(params: {
+        protectedPaths: string[];
+        spanId: string;
+    });
+}
+/**
+ * Reject any worker span that declares `claimedPaths` entries owned by
+ * the cclaw managed runtime. Called from `appendDelegation` for
+ * `status === "scheduled"` rows alongside the overlap and fan-out
+ * checks. Throws `DispatchClaimedPathProtectedError` listing every
+ * offending path so the operator can fix the dispatch in one pass.
+ */
+export declare function validateClaimedPathsNotProtected(stamped: DelegationEntry): void;
+/**
+ * Thrown by `appendDelegation` when a new `scheduled` span would open a
+ * second TDD cycle for a slice that already has at least one closed span
+ * (a span with completed phase rows for `red`, `green`, at least one of
+ * `refactor`/`refactor-deferred`, and `doc`) in the same run. Re-running
+ * a slice under a fresh span is almost always controller drift —
+ * legitimate replay reuses the original spanId and is absorbed by the
+ * existing dedup. Motivated by the hox-session 7.0.5 finding where
+ * `S-36` had two scheduled spans (`span-w07-S-36-final` and `span-w07-S-36`)
+ * that the linter then misread as out-of-order phases.
+ */
+export declare class SliceAlreadyClosedError extends Error {
+    readonly sliceId: string;
+    readonly runId: string;
+    readonly closedSpanId: string;
+    readonly newSpanId: string;
+    constructor(params: {
+        sliceId: string;
+        runId: string;
+        closedSpanId: string;
+        newSpanId: string;
+    });
+}
 /**
  * Default cap on active `slice-builder` spans in a single TDD run. Override
  * via `CCLAW_MAX_PARALLEL_SLICE_BUILDERS=<int>` (validated `>=1`).