cclaw-cli 7.0.5 → 7.0.6

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/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`).

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/internal/advance-stage.js

@@ -14,7 +14,7 @@ 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";
@@ -116,6 +116,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/package.json

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