cclaw-cli 7.0.5 → 7.1.0

package/dist/delegation.js

@@ -630,6 +630,151 @@ export class DispatchCapError extends Error {
         this.pair = params.pair;
     }
 }
+/**
+ * Patterns describing repo-relative paths owned by the cclaw managed
+ * runtime under `.cclaw/`. Workers MUST NOT claim these as
+ * `claimedPaths` because they are regenerated/rebound by `cclaw-cli sync`
+ * (and similar managed flows), and worker writes silently bypass the
+ * managed-resources manifest. Note: `.cclaw/artifacts/` is intentionally
+ * NOT protected — slice-builders legitimately write slice cards there.
+ *
+ * Motivated by the hox-session 7.0.5 finding: subagent S-36 hand-edited
+ * `.cclaw/hooks/delegation-record.mjs`, which had to be reverted because
+ * the next `cclaw-cli sync` would have stomped the change.
+ */
+const MANAGED_RUNTIME_PATH_PATTERNS = [
+    /^\.cclaw\/(hooks|agents|skills|commands|templates|seeds|rules|state)\//u,
+    /^\.cclaw\/config\.yaml$/u,
+    /^\.cclaw\/managed-resources\.json$/u,
+    /^\.cclaw\/\.flow-state\.guard\.json$/u
+];
+/**
+ * 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 function isManagedRuntimePath(path) {
+    if (typeof path !== "string" || path.length === 0)
+        return false;
+    return MANAGED_RUNTIME_PATH_PATTERNS.some((pattern) => pattern.test(path));
+}
+/**
+ * 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 class DispatchClaimedPathProtectedError extends Error {
+    protectedPaths;
+    spanId;
+    constructor(params) {
+        super(`dispatch_claimed_path_protected — span ${params.spanId} claims managed-runtime path(s) ${params.protectedPaths.join(", ")}; ` +
+            `paths under .cclaw/{hooks,agents,skills,commands,templates,seeds,rules,state}/, .cclaw/config.yaml, .cclaw/managed-resources.json, and .cclaw/.flow-state.guard.json are owned by cclaw-cli sync and must not appear in claimedPaths. ` +
+            `Drop them from claimedPaths or, if a managed-runtime change is genuinely required, ship it through a cclaw release rather than a worker span.`);
+        this.name = "DispatchClaimedPathProtectedError";
+        this.protectedPaths = params.protectedPaths;
+        this.spanId = params.spanId;
+    }
+}
+/**
+ * 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 function validateClaimedPathsNotProtected(stamped) {
+    const claimed = Array.isArray(stamped.claimedPaths) ? stamped.claimedPaths : [];
+    if (claimed.length === 0)
+        return;
+    const offending = claimed.filter((p) => isManagedRuntimePath(p));
+    if (offending.length === 0)
+        return;
+    throw new DispatchClaimedPathProtectedError({
+        protectedPaths: offending,
+        spanId: stamped.spanId ?? "unknown"
+    });
+}
+/**
+ * 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 class SliceAlreadyClosedError extends Error {
+    sliceId;
+    runId;
+    closedSpanId;
+    newSpanId;
+    constructor(params) {
+        super(`slice ${params.sliceId} already has a closed span (${params.closedSpanId}); refusing to schedule new span ${params.newSpanId} in run ${params.runId}`);
+        this.name = "SliceAlreadyClosedError";
+        this.sliceId = params.sliceId;
+        this.runId = params.runId;
+        this.closedSpanId = params.closedSpanId;
+        this.newSpanId = params.newSpanId;
+    }
+}
+/**
+ * Detect closed spans for `(sliceId, runId)`. A span is considered
+ * closed when it has completed phase rows for `red`, `green`, REFACTOR
+ * coverage (either `phase=refactor`, `phase=refactor-deferred`, or
+ * `phase=green` carrying `refactorOutcome`), AND `doc`. Returns the set of
+ * closed spanIds; callers use this to reject new scheduled spans on
+ * already-closed slices.
+ */
+function closedSliceSpans(prior, sliceId, runId) {
+    const closed = new Set();
+    if (typeof sliceId !== "string" || sliceId.length === 0)
+        return closed;
+    const matches = prior.filter((entry) => entry.sliceId === sliceId &&
+        entry.runId === runId &&
+        typeof entry.spanId === "string" &&
+        entry.spanId.length > 0);
+    const bySpan = new Map();
+    for (const entry of matches) {
+        const spanId = entry.spanId;
+        const existing = bySpan.get(spanId) ?? [];
+        existing.push(entry);
+        bySpan.set(spanId, existing);
+    }
+    for (const [spanId, entries] of bySpan.entries()) {
+        const phases = new Set(entries
+            .filter((e) => e.status === "completed" && typeof e.phase === "string")
+            .map((e) => e.phase));
+        const hasRed = phases.has("red");
+        const hasGreen = phases.has("green");
+        const hasRefactorPhase = phases.has("refactor") || phases.has("refactor-deferred");
+        const greens = entries.filter((e) => e.status === "completed" && e.phase === "green");
+        const greenWithOutcome = greens.find((e) => e.refactorOutcome &&
+            (e.refactorOutcome.mode === "inline" || e.refactorOutcome.mode === "deferred"));
+        let hasRefactorFromGreen = false;
+        if (greenWithOutcome?.refactorOutcome?.mode === "deferred") {
+            hasRefactorFromGreen = !!((greenWithOutcome.refactorOutcome.rationale &&
+                greenWithOutcome.refactorOutcome.rationale.trim().length > 0) ||
+                (Array.isArray(greenWithOutcome.evidenceRefs) &&
+                    greenWithOutcome.evidenceRefs.some((ref) => typeof ref === "string" && ref.trim().length > 0)));
+        }
+        else if (greenWithOutcome?.refactorOutcome?.mode === "inline") {
+            hasRefactorFromGreen = true;
+        }
+        const hasRefactor = hasRefactorPhase || hasRefactorFromGreen;
+        const hasDoc = phases.has("doc");
+        if (hasRed && hasGreen && hasRefactor && hasDoc) {
+            closed.add(spanId);
+        }
+    }
+    return closed;
+}
 /**
  * Default cap on active `slice-builder` spans in a single TDD run. Override
  * via `CCLAW_MAX_PARALLEL_SLICE_BUILDERS=<int>` (validated `>=1`).
@@ -1037,7 +1182,23 @@ export async function appendDelegation(projectRoot, entry) {
             return;
         }
         validateMonotonicTimestamps(stamped, prior.entries);
+        if (stamped.status === "scheduled" &&
+            typeof stamped.sliceId === "string" &&
+            stamped.sliceId.length > 0 &&
+            stamped.phase === undefined) {
+            const closed = closedSliceSpans(prior.entries, stamped.sliceId, activeRunId);
+            if (closed.size > 0 && !(stamped.spanId && closed.has(stamped.spanId))) {
+                const closedSpanId = closed.values().next().value;
+                throw new SliceAlreadyClosedError({
+                    sliceId: stamped.sliceId,
+                    runId: activeRunId,
+                    closedSpanId,
+                    newSpanId: stamped.spanId ?? "unknown"
+                });
+            }
+        }
         if (stamped.status === "scheduled") {
+            validateClaimedPathsNotProtected(stamped);
             const sameRunPrior = prior.entries.filter((entry) => entry.runId === activeRunId);
             const activeForRun = computeActiveSubagents(sameRunPrior);
             const overlap = validateFileOverlap(stamped, activeForRun);

package/dist/install.js

@@ -13,7 +13,7 @@ import { cancelCommandContract, cancelCommandSkillMarkdown } from "./content/can
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { ironLawsSkillMarkdown } from "./content/iron-laws.js";
-import { stageCompleteScript, startFlowScript, cancelRunScript, runHookCmdScript, delegationRecordScript, opencodePluginJs, claudeHooksJson, codexHooksJson, cursorHooksJson } from "./content/hooks.js";
+import { stageCompleteScript, startFlowScript, cancelRunScript, runHookCmdScript, delegationRecordScript, sliceCommitScript, opencodePluginJs, claudeHooksJson, codexHooksJson, cursorHooksJson } from "./content/hooks.js";
 import { nodeHookRuntimeScript } from "./content/node-hooks.js";
 import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.js";
 import { ARTIFACT_TEMPLATES, CURSOR_GUIDELINES_RULE_MDC, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
@@ -692,6 +692,7 @@ async function writeHooks(projectRoot, config) {
     await writeFileSafe(path.join(hooksDir, "run-hook.mjs"), bundledHookRuntime ?? nodeHookRuntimeScript(hookRuntimeOptions));
     await writeFileSafe(path.join(hooksDir, "run-hook.cmd"), runHookCmdScript());
     await writeFileSafe(path.join(hooksDir, "delegation-record.mjs"), delegationRecordScript());
+    await writeFileSafe(path.join(hooksDir, "slice-commit.mjs"), sliceCommitScript());
     const opencodePluginSource = opencodePluginJs();
     await writeFileSafe(path.join(hooksDir, "opencode-plugin.mjs"), opencodePluginSource);
     try {
@@ -701,6 +702,7 @@ async function writeHooks(projectRoot, config) {
             "run-hook.mjs",
             "run-hook.cmd",
             "delegation-record.mjs",
+            "slice-commit.mjs",
             "opencode-plugin.mjs",
             "cancel-run.mjs"
         ]) {

package/dist/internal/advance-stage.js

@@ -14,10 +14,11 @@ import { parseAdvanceStageArgs, parseCancelRunArgs, parseHookArgs, parseRewindAr
 import { parseFlowStateRepairArgs, runFlowStateRepair } from "./flow-state-repair.js";
 import { parseWaiverGrantArgs, runWaiverGrant } from "./waiver-grant.js";
 import { FlowStateGuardMismatchError, verifyFlowStateGuard } from "../run-persistence.js";
-import { DelegationTimestampError, DispatchCapError, DispatchDuplicateError, DispatchOverlapError } from "../delegation.js";
+import { DelegationTimestampError, DispatchCapError, DispatchClaimedPathProtectedError, DispatchDuplicateError, DispatchOverlapError, SliceAlreadyClosedError } from "../delegation.js";
 import { parsePlanSplitWavesArgs, runPlanSplitWaves } from "./plan-split-waves.js";
 import { runWaveStatusCommand } from "./wave-status.js";
 import { runCohesionContractCommand } from "./cohesion-contract-stub.js";
+import { runSliceCommitCommand } from "./slice-commit.js";
 /**
  * Subcommands that mutate or consult flow-state.json via the CLI runtime.
  * They all require the sha256 sidecar to match before continuing so a
@@ -35,7 +36,7 @@ const GUARD_ENFORCED_SUBCOMMANDS = new Set([
 export async function runInternalCommand(projectRoot, argv, io) {
     const [subcommand, ...tokens] = argv;
     if (!subcommand) {
-        io.stderr.write("cclaw internal requires a subcommand: advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves | wave-status | cohesion-contract\n");
+        io.stderr.write("cclaw internal requires a subcommand: advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | slice-commit | flow-state-repair | waiver-grant | plan-split-waves | wave-status | cohesion-contract\n");
         return 1;
     }
     try {
@@ -81,6 +82,9 @@ export async function runInternalCommand(projectRoot, argv, io) {
         if (subcommand === "hook") {
             return await runHookCommand(projectRoot, parseHookArgs(tokens), io);
         }
+        if (subcommand === "slice-commit") {
+            return await runSliceCommitCommand(projectRoot, tokens, io);
+        }
         if (subcommand === "flow-state-repair") {
             return await runFlowStateRepair(projectRoot, parseFlowStateRepairArgs(tokens), io);
         }
@@ -96,7 +100,7 @@ export async function runInternalCommand(projectRoot, argv, io) {
         if (subcommand === "cohesion-contract") {
             return await runCohesionContractCommand(projectRoot, tokens, io);
         }
-        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves | wave-status | cohesion-contract\n`);
+        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | slice-commit | flow-state-repair | waiver-grant | plan-split-waves | wave-status | cohesion-contract\n`);
         return 1;
     }
     catch (err) {
@@ -116,6 +120,14 @@ export async function runInternalCommand(projectRoot, argv, io) {
             io.stderr.write(`error: dispatch_overlap — ${err.message}\n`);
             return 2;
         }
+        if (err instanceof DispatchClaimedPathProtectedError) {
+            io.stderr.write(`error: dispatch_claimed_path_protected — ${err.message}\n`);
+            return 2;
+        }
+        if (err instanceof SliceAlreadyClosedError) {
+            io.stderr.write(`error: slice_already_closed — ${err.message}\n`);
+            return 2;
+        }
         if (err instanceof DispatchCapError) {
             io.stderr.write(`error: dispatch_cap — ${err.message}\n`);
             return 2;

package/dist/internal/slice-commit.d.ts

@@ -0,0 +1,7 @@
+import type { Writable } from "node:stream";
+interface InternalIo {
+    stdout: Writable;
+    stderr: Writable;
+}
+export declare function runSliceCommitCommand(projectRoot: string, tokens: string[], io: InternalIo): Promise<number>;
+export {};

package/dist/internal/slice-commit.js

@@ -0,0 +1,296 @@
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+import { readConfig, resolveTddCommitMode } from "../config.js";
+import { readDelegationLedger } from "../delegation.js";
+import { exists } from "../fs-utils.js";
+const execFileAsync = promisify(execFile);
+function parseCsv(raw) {
+    return raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+}
+function normalizePathLike(value) {
+    const slashes = value.replace(/\\/gu, "/");
+    const withoutDot = slashes.replace(/^\.\//u, "");
+    return withoutDot.replace(/\/+$/u, "");
+}
+function parseSliceCommitArgs(tokens) {
+    let sliceId = "";
+    let spanId = "";
+    let taskId;
+    let title;
+    let runId;
+    const claimedPaths = [];
+    let json = false;
+    let quiet = false;
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        const next = tokens[i + 1];
+        const valueFrom = (flag) => {
+            if (token.startsWith(`${flag}=`))
+                return token.slice(flag.length + 1);
+            if (token === flag && next && !next.startsWith("--")) {
+                i += 1;
+                return next;
+            }
+            throw new Error(`${flag} requires a value.`);
+        };
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "--quiet") {
+            quiet = true;
+            continue;
+        }
+        if (token.startsWith("--slice=") || token === "--slice") {
+            sliceId = valueFrom("--slice").trim();
+            continue;
+        }
+        if (token.startsWith("--span-id=") || token === "--span-id") {
+            spanId = valueFrom("--span-id").trim();
+            continue;
+        }
+        if (token.startsWith("--task-id=") || token === "--task-id") {
+            taskId = valueFrom("--task-id").trim();
+            continue;
+        }
+        if (token.startsWith("--title=") || token === "--title") {
+            title = valueFrom("--title").trim();
+            continue;
+        }
+        if (token.startsWith("--run-id=") || token === "--run-id") {
+            runId = valueFrom("--run-id").trim();
+            continue;
+        }
+        if (token.startsWith("--claimed-paths=") || token === "--claimed-paths") {
+            claimedPaths.push(...parseCsv(valueFrom("--claimed-paths")));
+            continue;
+        }
+        if (token.startsWith("--claimed-path=") || token === "--claimed-path") {
+            const one = valueFrom("--claimed-path").trim();
+            if (one.length > 0)
+                claimedPaths.push(one);
+            continue;
+        }
+        throw new Error(`Unknown flag for internal slice-commit: ${token}`);
+    }
+    if (sliceId.length === 0) {
+        throw new Error("internal slice-commit requires --slice=<S-N>.");
+    }
+    if (spanId.length === 0) {
+        throw new Error("internal slice-commit requires --span-id=<span-id>.");
+    }
+    return {
+        sliceId,
+        spanId,
+        taskId,
+        title,
+        runId,
+        claimedPaths,
+        json,
+        quiet
+    };
+}
+function output(io, args, payload, channel = "stdout") {
+    if (args.quiet && channel === "stdout")
+        return;
+    const writer = channel === "stdout" ? io.stdout : io.stderr;
+    if (args.json) {
+        writer.write(`${JSON.stringify(payload)}\n`);
+        return;
+    }
+    const message = typeof payload.message === "string"
+        ? payload.message
+        : JSON.stringify(payload);
+    writer.write(`${message}\n`);
+}
+function parsePorcelainPaths(raw) {
+    const out = [];
+    for (const line of raw.split(/\r?\n/gu)) {
+        const trimmed = line.trimEnd();
+        if (trimmed.length < 4)
+            continue;
+        // porcelain line shape: XY<space><path>
+        const status = trimmed.slice(0, 2);
+        if (status === "??") {
+            const p = normalizePathLike(trimmed.slice(3).trim());
+            if (p.length > 0)
+                out.push(p);
+            continue;
+        }
+        let p = trimmed.slice(3).trim();
+        const renameIdx = p.indexOf(" -> ");
+        if (renameIdx >= 0) {
+            p = p.slice(renameIdx + 4);
+        }
+        p = normalizePathLike(p.replace(/^"/u, "").replace(/"$/u, ""));
+        if (p.length > 0)
+            out.push(p);
+    }
+    return [...new Set(out)];
+}
+function matchesClaimedPath(changedPath, claimedPaths) {
+    const changed = normalizePathLike(changedPath);
+    return claimedPaths.some((rawClaimed) => {
+        const claimed = normalizePathLike(rawClaimed);
+        if (claimed.length === 0)
+            return false;
+        if (changed === claimed)
+            return true;
+        return changed.startsWith(`${claimed}/`);
+    });
+}
+async function resolveClaimedPathsFromLedger(projectRoot, args) {
+    const ledger = await readDelegationLedger(projectRoot);
+    const matches = ledger.entries.filter((entry) => entry.stage === "tdd" &&
+        entry.agent === "slice-builder" &&
+        entry.sliceId === args.sliceId &&
+        entry.spanId === args.spanId &&
+        (!args.runId || entry.runId === args.runId) &&
+        Array.isArray(entry.claimedPaths) &&
+        entry.claimedPaths.length > 0);
+    matches.sort((a, b) => {
+        const aTs = a.ts ?? a.startTs ?? "";
+        const bTs = b.ts ?? b.startTs ?? "";
+        return aTs < bTs ? 1 : aTs > bTs ? -1 : 0;
+    });
+    const fromLedger = matches[0]?.claimedPaths ?? [];
+    return [...new Set(fromLedger.map((p) => normalizePathLike(p)).filter((p) => p.length > 0))];
+}
+export async function runSliceCommitCommand(projectRoot, tokens, io) {
+    let args;
+    try {
+        args = parseSliceCommitArgs(tokens);
+    }
+    catch (err) {
+        io.stderr.write(`cclaw internal slice-commit: ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    const config = await readConfig(projectRoot).catch(() => null);
+    const commitMode = resolveTddCommitMode(config);
+    if (commitMode !== "managed-per-slice") {
+        output(io, args, {
+            ok: true,
+            skipped: true,
+            reason: "commit-mode-not-managed",
+            commitMode,
+            message: `slice-commit skipped: commitMode=${commitMode}`
+        });
+        return 0;
+    }
+    const gitPresent = await exists(path.join(projectRoot, ".git"));
+    if (!gitPresent) {
+        output(io, args, {
+            ok: true,
+            skipped: true,
+            reason: "no-git",
+            message: "slice-commit skipped: .git is missing"
+        });
+        return 0;
+    }
+    const claimedPaths = args.claimedPaths.length > 0
+        ? [...new Set(args.claimedPaths.map((p) => normalizePathLike(p)).filter((p) => p.length > 0))]
+        : await resolveClaimedPathsFromLedger(projectRoot, args);
+    if (claimedPaths.length === 0) {
+        output(io, args, {
+            ok: false,
+            errorCode: "slice_commit_claimed_paths_missing",
+            details: {
+                sliceId: args.sliceId,
+                spanId: args.spanId
+            },
+            message: `slice_commit_claimed_paths_missing: no claimed paths for ${args.sliceId}/${args.spanId}`
+        }, "stderr");
+        return 2;
+    }
+    const { stdout: statusRaw } = await execFileAsync("git", ["status", "--porcelain", "-uall"], {
+        cwd: projectRoot
+    });
+    const changedPaths = parsePorcelainPaths(statusRaw);
+    if (changedPaths.length === 0) {
+        output(io, args, {
+            ok: true,
+            skipped: true,
+            reason: "no-changes",
+            message: `slice-commit skipped: no working-tree changes for ${args.sliceId}`
+        });
+        return 0;
+    }
+    const pathDrift = changedPaths.filter((p) => !matchesClaimedPath(p, claimedPaths));
+    if (pathDrift.length > 0) {
+        output(io, args, {
+            ok: false,
+            errorCode: "slice_commit_path_drift",
+            details: {
+                sliceId: args.sliceId,
+                spanId: args.spanId,
+                claimedPaths,
+                driftPaths: pathDrift
+            },
+            message: `slice_commit_path_drift: ${pathDrift.join(", ")}`
+        }, "stderr");
+        return 2;
+    }
+    const changedInClaim = changedPaths.filter((p) => matchesClaimedPath(p, claimedPaths));
+    if (changedInClaim.length === 0) {
+        output(io, args, {
+            ok: true,
+            skipped: true,
+            reason: "claimed-paths-unchanged",
+            message: `slice-commit skipped: no changes within claimed paths for ${args.sliceId}`
+        });
+        return 0;
+    }
+    try {
+        await execFileAsync("git", ["add", "--", ...claimedPaths], {
+            cwd: projectRoot
+        });
+        const taskPart = args.taskId && args.taskId.length > 0 ? args.taskId : "task";
+        const titlePart = args.title && args.title.length > 0 ? args.title : "slice update";
+        const header = `${args.sliceId}/${taskPart}: ${titlePart}`;
+        const body = [
+            `span-id: ${args.spanId}`,
+            `run-id: ${args.runId ?? "unknown"}`,
+            "phase-cycle: red->green->refactor->doc"
+        ].join("\n");
+        await execFileAsync("git", ["commit", "-m", header, "-m", body], {
+            cwd: projectRoot
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (/nothing to commit/iu.test(message)) {
+            output(io, args, {
+                ok: true,
+                skipped: true,
+                reason: "nothing-to-commit",
+                message: `slice-commit skipped: nothing to commit for ${args.sliceId}`
+            });
+            return 0;
+        }
+        output(io, args, {
+            ok: false,
+            errorCode: "slice_commit_failed",
+            details: { message },
+            message: `slice_commit_failed: ${message}`
+        }, "stderr");
+        return 1;
+    }
+    const { stdout: shaStdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
+        cwd: projectRoot
+    });
+    const commitSha = shaStdout.trim();
+    output(io, args, {
+        ok: true,
+        commitSha,
+        sliceId: args.sliceId,
+        spanId: args.spanId,
+        claimedPaths,
+        changedPaths: changedInClaim,
+        message: `slice commit created for ${args.sliceId}: ${commitSha}`
+    });
+    return 0;
+}