cclaw-cli 6.14.0 → 6.14.2

package/dist/artifact-linter/shared.d.ts

@@ -654,4 +654,19 @@ export interface StageLintContext {
      * wave.
      */
     integrationOverseerMode: "conditional" | "always";
+    /**
+     * v6.14.2 — historical cutover marker (`flow-state.json::tddCutoverSliceId`).
+     * Empty string when not set. Used by the `tdd_cutover_misread_warning`
+     * advisory rule to detect controllers that mistake the historical
+     * marker for an active-slice pointer.
+     */
+    tddCutoverSliceId: string;
+    /**
+     * v6.14.2 — worktree-first boundary
+     * (`flow-state.json::tddWorktreeCutoverSliceId`). Empty string when
+     * not set. Linters that fire on closed worktree slices use this
+     * boundary (with a fallback to `tddCutoverSliceId`) to exempt
+     * pre-flip closed slices on `legacyContinuation: true` projects.
+     */
+    tddWorktreeCutoverSliceId: string;
 }

package/dist/artifact-linter/tdd.js

@@ -27,8 +27,17 @@ const SLICES_INDEX_END = "<!-- auto-end: slices-index -->";
  *    via `## Slices Index`.
  */
 export async function lintTddStage(ctx) {
-    const { projectRoot, discoveryMode, raw, absFile, sections, findings, parsedFrontmatter, worktreeExecutionMode, legacyContinuation, tddCheckpointMode, integrationOverseerMode } = ctx;
+    const { projectRoot, discoveryMode, raw, absFile, sections, findings, parsedFrontmatter, worktreeExecutionMode, legacyContinuation, tddCheckpointMode, integrationOverseerMode, tddCutoverSliceId, tddWorktreeCutoverSliceId } = ctx;
     void parsedFrontmatter;
+    // v6.14.2 — boundary slice for the "any-metadata" exemption applied
+    // to worktree-first findings. Falls back to the v6.12 cutover marker
+    // when the boundary is absent (sync hasn't run, or `cclaw-cli sync`
+    // detected no auto-detectable boundary). The exemption only kicks in
+    // for `legacyContinuation: true` projects — fresh worktree-first
+    // projects continue to enforce all three rules globally.
+    const worktreeCutoverBoundary = legacyContinuation
+        ? parseSliceNumber(tddWorktreeCutoverSliceId || tddCutoverSliceId || "")
+        : null;
     const artifactsDir = path.dirname(absFile);
     const planPath = path.join(artifactsDir, "05-plan.md");
     let planRaw = "";
@@ -236,6 +245,25 @@ export async function lintTddStage(ctx) {
     if (cutoverFinding) {
         findings.push(cutoverFinding);
     }
+    // v6.14.2 Fix 2 — advisory cutover-misread detection. Fires when the
+    // active run scheduled NEW work for the slice id stored in
+    // `tddCutoverSliceId` AND that slice has already closed (terminal
+    // refactor* row recorded for the same id, possibly under a prior
+    // run). This is the "controller mistook the historical marker for an
+    // active-slice pointer" pattern observed in hox W-03/S-17. Advisory
+    // only — clears as soon as the controller pivots to a different
+    // slice, and never blocks stage-complete.
+    if (tddCutoverSliceId) {
+        const misreadFinding = evaluateCutoverMisread({
+            projectRoot,
+            tddCutoverSliceId,
+            activeRunEntries,
+            ledgerEntries: delegationLedger.entries
+        });
+        if (misreadFinding) {
+            findings.push(misreadFinding);
+        }
+    }
     const { events: jsonlEvents, fanInAudits } = await readDelegationEvents(projectRoot);
     const runEvents = jsonlEvents.filter((e) => e.runId === delegationLedger.runId);
     if (eventsActive && planRaw.length > 0) {
@@ -257,7 +285,32 @@ export async function lintTddStage(ctx) {
             "refactor-deferred",
             "resolve-conflict"
         ]);
+        // v6.14.2 — under `legacyContinuation: true` AND a stamped
+        // boundary, exempt closed slices that NEVER recorded ANY of the
+        // three worktree-first metadata fields. This is the "all-or-
+        // nothing legacy" rule from v6.14.2 Fix 3: partial-metadata
+        // slices stay flagged (a real bug), but slices that pre-date
+        // the worktree-first flip get amnesty.
+        const sliceWorktreeMetaState = computeSliceWorktreeMetaState(runEvents);
+        const isExemptLegacySlice = (sliceId) => {
+            if (!legacyContinuation)
+                return false;
+            if (worktreeCutoverBoundary === null)
+                return false;
+            const n = parseSliceNumber(sliceId);
+            if (n === null)
+                return false;
+            if (n > worktreeCutoverBoundary)
+                return false;
+            const meta = sliceWorktreeMetaState.get(sliceId);
+            if (!meta)
+                return true; // no slice-implementer rows at all → fully legacy
+            // Exempt only when the slice carries ZERO worktree fields across
+            // all rows. Partial metadata stays flagged.
+            return !meta.anyMeta;
+        };
         const missingGreenMeta = new Set();
+        const exemptedGreenMeta = new Set();
         for (const ev of runEvents) {
             if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
                 continue;
@@ -269,7 +322,12 @@ export async function lintTddStage(ctx) {
             const lane = ev.ownerLaneId?.trim() ?? "";
             const lease = ev.leasedUntil?.trim() ?? "";
             if (tok.length === 0 || lane.length === 0 || lease.length === 0) {
-                missingGreenMeta.add(ev.sliceId);
+                if (isExemptLegacySlice(ev.sliceId)) {
+                    exemptedGreenMeta.add(ev.sliceId);
+                }
+                else {
+                    missingGreenMeta.add(ev.sliceId);
+                }
             }
         }
         if (missingGreenMeta.size > 0) {
@@ -281,7 +339,17 @@ export async function lintTddStage(ctx) {
                 details: `Slices missing one or more lane fields on GREEN: ${[...missingGreenMeta].sort().join(", ")}. Remediation: include --claim-token, --lane-id, and --lease-until on every slice-implementer --phase green delegation-record write (schedule through completion); the hook fails fast with dispatch_lane_metadata_missing when they are omitted.`
             });
         }
+        else if (exemptedGreenMeta.size > 0) {
+            findings.push({
+                section: "tdd_slice_lane_metadata_legacy_exempt",
+                required: false,
+                rule: "v6.14.2 legacyContinuation amnesty: closed slices ≤ tddWorktreeCutoverSliceId whose slice-implementer rows lack ALL worktree-first metadata are exempt from `tdd_slice_lane_metadata_missing`.",
+                found: true,
+                details: `Legacy-exempt slices (no claimToken/ownerLaneId/leasedUntil recorded; all closed before worktree-first flip): ${[...exemptedGreenMeta].sort().join(", ")}.`
+            });
+        }
         const missingClaim = new Set();
+        const exemptedClaim = new Set();
         for (const ev of runEvents) {
             if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
                 continue;
@@ -291,7 +359,12 @@ export async function lintTddStage(ctx) {
                 continue;
             const tok = ev.claimToken?.trim() ?? "";
             if (tok.length === 0 && typeof ev.sliceId === "string") {
-                missingClaim.add(ev.sliceId);
+                if (isExemptLegacySlice(ev.sliceId)) {
+                    exemptedClaim.add(ev.sliceId);
+                }
+                else {
+                    missingClaim.add(ev.sliceId);
+                }
             }
         }
         if (missingClaim.size > 0) {
@@ -303,6 +376,15 @@ export async function lintTddStage(ctx) {
                 details: `Slices missing claim token on non-GREEN terminal rows: ${[...missingClaim].join(", ")}.`
             });
         }
+        else if (exemptedClaim.size > 0) {
+            findings.push({
+                section: "tdd_slice_claim_token_legacy_exempt",
+                required: false,
+                rule: "v6.14.2 legacyContinuation amnesty: closed pre-cutover slices without claim tokens on terminal rows are exempt from `tdd_slice_claim_token_missing`.",
+                found: true,
+                details: `Legacy-exempt slices: ${[...exemptedClaim].sort().join(", ")}.`
+            });
+        }
         const conflictSlices = [
             ...new Set([
                 ...runEvents
@@ -327,6 +409,12 @@ export async function lintTddStage(ctx) {
         }
         const now = Date.now();
         const leaseStale = new Set();
+        const leaseStaleExempted = new Set();
+        // v6.14.2 — also exempt slices whose lease has expired but the
+        // slice was already closed (terminal row recorded) before the
+        // expiry. The reclaim audit row was just never written —
+        // bookkeeping advisory, not a blocker.
+        const closedBeforeLeaseExpiry = computeClosedBeforeLeaseExpiry(runEvents);
         for (const ev of runEvents) {
             if (typeof ev.leasedUntil !== "string")
                 continue;
@@ -335,8 +423,18 @@ export async function lintTddStage(ctx) {
                 continue;
             if (ev.leaseState === "reclaimed" || ev.leaseState === "released")
                 continue;
-            if (typeof ev.sliceId === "string")
-                leaseStale.add(ev.sliceId);
+            if (typeof ev.sliceId !== "string")
+                continue;
+            const sliceId = ev.sliceId;
+            if (isExemptLegacySlice(sliceId)) {
+                leaseStaleExempted.add(sliceId);
+                continue;
+            }
+            if (closedBeforeLeaseExpiry.has(sliceId)) {
+                leaseStaleExempted.add(sliceId);
+                continue;
+            }
+            leaseStale.add(sliceId);
         }
         if (leaseStale.size > 0) {
             findings.push({
@@ -347,6 +445,15 @@ export async function lintTddStage(ctx) {
                 details: `Expired leases not reclaimed for slice(s): ${[...leaseStale].join(", ")}.`
             });
         }
+        else if (leaseStaleExempted.size > 0) {
+            findings.push({
+                section: "tdd_lease_expired_legacy_exempt",
+                required: false,
+                rule: "v6.14.2 amnesty: expired leases are exempt when the slice closed before the expiry timestamp (reclaim audit just never recorded) OR when the slice predates the worktree-first cutover under legacyContinuation.",
+                found: true,
+                details: `Lease-expiry-exempt slices: ${[...leaseStaleExempted].sort().join(", ")}.`
+            });
+        }
     }
     const assertionBody = sectionBodyByName(sections, "Assertion Correctness Notes");
     if (assertionBody !== null) {
@@ -426,14 +533,27 @@ export async function lintTddStage(ctx) {
             cohesionContractFound = false;
             cohesionErrors.push("cohesion-contract.json is missing or invalid JSON.");
         }
+        // v6.14.2 — soften cohesion-contract under `legacyContinuation: true`.
+        // Pre-flip projects (hox) carry many closed implementer rows but
+        // never recorded cross-slice cohesion data because that schema
+        // didn't exist when the slices closed. Flag advisory + suggest the
+        // auto-stub helper instead of blocking the gate.
+        const cohesionRequired = legacyContinuation === true ? false : true;
+        const advisoryNote = cohesionRequired
+            ? cohesionErrors.join(" ")
+            : `${cohesionErrors.join(" ")} ` +
+                "Cohesion contract is advisory under legacyContinuation: true — emit a stub via " +
+                "`cclaw-cli internal cohesion-contract --stub` to silence this finding.";
         findings.push({
             section: "tdd.cohesion_contract_missing",
-            required: true,
-            rule: "When delegation ledger has >1 completed slice-implementer rows for active TDD run, require `.cclaw/artifacts/cohesion-contract.md` and parseable `.cclaw/artifacts/cohesion-contract.json` sidecar.",
+            required: cohesionRequired,
+            rule: cohesionRequired
+                ? "When delegation ledger has >1 completed slice-implementer rows for active TDD run, require `.cclaw/artifacts/cohesion-contract.md` and parseable `.cclaw/artifacts/cohesion-contract.json` sidecar."
+                : "v6.14.2 advisory under legacyContinuation: cohesion contract is recommended, not required. Use `cclaw-cli internal cohesion-contract --stub` to write a baseline.",
             found: cohesionContractFound,
             details: cohesionContractFound
                 ? `Fan-out detected (${completedSliceImplementers.length} completed slice-implementer rows); cohesion contract markdown+JSON sidecar are present and parseable.`
-                : cohesionErrors.join(" ")
+                : advisoryNote
         });
         const completedOverseerRows = activeRunEntries.filter((entry) => entry.agent === "integration-overseer" && entry.status === "completed");
         const overseerStatusInEvidence = completedOverseerRows.some((entry) => {
@@ -448,36 +568,69 @@ export async function lintTddStage(ctx) {
         // `integrationCheckRequired()` returns required=false, the gate is
         // soft (advisory) and an audit-only finding is emitted so the
         // controller can record the deliberate skip in artifacts.
+        //
+        // v6.14.1 — also surface the audit row presence. When the controller
+        // skips `integration-overseer` dispatch (or the heuristic returns
+        // false), the run log MUST contain a
+        // `cclaw_integration_overseer_skipped` audit row for traceability.
+        // The advisory `tdd_integration_overseer_skipped_audit_missing`
+        // surfaces a missing audit row when 2+ closed slices closed without
+        // any overseer dispatch AND no audit was recorded.
         let overseerVerdict = null;
         let overseerRequired = true;
+        const skippedAuditRowCount = await countIntegrationOverseerSkippedAudits(projectRoot, delegationLedger.runId);
+        const skippedAuditRowFound = skippedAuditRowCount > 0;
         if (integrationOverseerMode === "conditional") {
             const eventsForVerdict = runEvents.length > 0 ? runEvents : [];
             const auditsForVerdict = fanInAudits.filter((a) => a.runId === delegationLedger.runId);
             overseerVerdict = integrationCheckRequired(eventsForVerdict, auditsForVerdict);
             overseerRequired = overseerVerdict.required;
             if (!overseerVerdict.required) {
+                const auditRowSuffix = skippedAuditRowFound
+                    ? "audit row recorded — skip is fully traceable."
+                    : "audit row MISSING — controller should append `cclaw_integration_overseer_skipped` for traceability (see `tdd_integration_overseer_skipped_audit_missing`).";
                 findings.push({
                     section: "tdd_integration_overseer_skipped_by_disjoint_paths",
                     required: false,
-                    rule: "v6.14.0 conditional integration-overseer mode: the heuristic returned `required: false` (disjoint claimedPaths, no high-risk slices, no fan-in conflicts). The controller may skip dispatching `integration-overseer` and emit a `cclaw_integration_overseer_skipped` audit row instead.",
+                    rule: "v6.14.0+ conditional integration-overseer mode: the heuristic returned `required: false` (disjoint claimedPaths, no high-risk slices, no fan-in conflicts). The controller may skip dispatching `integration-overseer` and emit a `cclaw_integration_overseer_skipped` audit row instead.",
                     found: true,
-                    details: `integrationCheckRequired() reasons: ${overseerVerdict.reasons.join(", ")}. Skip is safe — record an audit row via delegation events for traceability.`
+                    details: `integrationCheckRequired() reasons: ${overseerVerdict.reasons.join(", ")}. Skip is safe — ${auditRowSuffix}`
                 });
             }
         }
+        // v6.14.1 — `tdd_integration_overseer_skipped_audit_missing` (advisory).
+        // Fires when fan-out is detected (2+ completed slice-implementers),
+        // no `integration-overseer` was dispatched at all (no scheduled or
+        // completed row for the active run), AND no
+        // `cclaw_integration_overseer_skipped` audit row exists. This pairs
+        // with the controller skill text rule that the wave-closure decision
+        // ("dispatch overseer or skip") MUST leave a trail.
+        const overseerDispatched = activeRunEntries.some((entry) => entry.agent === "integration-overseer");
+        if (!overseerDispatched && !skippedAuditRowFound) {
+            findings.push({
+                section: "tdd_integration_overseer_skipped_audit_missing",
+                required: false,
+                rule: "v6.14.1: when a wave with 2+ closed slices closes without any integration-overseer dispatch, the controller should call `integrationCheckRequired()` and emit a `cclaw_integration_overseer_skipped` audit row so the decision is traceable. Advisory — never blocks stage-complete.",
+                found: false,
+                details: `Fan-out detected (${completedSliceImplementers.length} completed slice-implementer rows) but no integration-overseer dispatch row OR cclaw_integration_overseer_skipped audit row exists for active run. ` +
+                    "Remediation: emit `node .cclaw/hooks/delegation-record.mjs --audit-kind=cclaw_integration_overseer_skipped --audit-reason=\"<reasons>\" --slice-ids=\"<S-1,S-2,...>\"` after wave closure."
+            });
+        }
         findings.push({
             section: "tdd.integration_overseer_missing",
             required: overseerRequired,
             rule: overseerRequired
                 ? "When fan-out is detected, require completed `integration-overseer` evidence with PASS or PASS_WITH_GAPS."
-                : "v6.14.0 conditional integration-overseer mode: integration-overseer dispatch is advisory because `integrationCheckRequired()` returned required=false. Run it anyway if the run touches new boundaries.",
+                : "v6.14.0+ conditional integration-overseer mode: integration-overseer dispatch is advisory because `integrationCheckRequired()` returned required=false. Run it anyway if the run touches new boundaries.",
             found: integrationOverseerFound,
             details: integrationOverseerFound
                 ? "integration-overseer completion recorded with PASS/PASS_WITH_GAPS evidence."
                 : completedOverseerRows.length === 0
                     ? overseerRequired
                         ? "Fan-out detected but no completed integration-overseer delegation row exists for active run."
-                        : "Fan-out detected; integration-overseer not dispatched (conditional mode skipped on disjoint paths). Audit-only."
+                        : skippedAuditRowFound
+                            ? "Fan-out detected; integration-overseer not dispatched (conditional mode skipped on disjoint paths) and `cclaw_integration_overseer_skipped` audit row recorded. Audit-only."
+                            : "Fan-out detected; integration-overseer not dispatched (conditional mode skipped on disjoint paths). Audit-only."
                     : "integration-overseer completion exists, but PASS/PASS_WITH_GAPS evidence is missing in delegation evidenceRefs and artifact text."
         });
     }
@@ -551,6 +704,46 @@ export async function lintTddStage(ctx) {
         }
     }
 }
+/**
+ * v6.14.1 — count `cclaw_integration_overseer_skipped` audit rows in
+ * `delegation-events.jsonl` for a given runId. The audit row is not a
+ * `DelegationEvent` (no agent/status), so `readDelegationEvents`
+ * filters it out; we re-scan the raw file with a narrow JSON match.
+ *
+ * Best-effort: missing file or parse errors return 0.
+ */
+async function countIntegrationOverseerSkippedAudits(projectRoot, runId) {
+    const filePath = path.join(projectRoot, ".cclaw/state/delegation-events.jsonl");
+    let raw = "";
+    try {
+        raw = await fs.readFile(filePath, "utf8");
+    }
+    catch {
+        return 0;
+    }
+    let count = 0;
+    for (const line of raw.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            continue;
+        const obj = parsed;
+        if (obj.event !== "cclaw_integration_overseer_skipped")
+            continue;
+        if (typeof obj.runId === "string" && obj.runId !== runId)
+            continue;
+        count += 1;
+    }
+    return count;
+}
 async function listSliceFiles(slicesDir) {
     let entries = [];
     try {
@@ -1140,6 +1333,134 @@ function pickEventTs(rows) {
     }
     return undefined;
 }
+/**
+ * v6.14.2 — for each slice id appearing in `slice-implementer` rows of
+ * the active run, record whether ANY row carried at least one of the
+ * three worktree-first metadata fields (`claimToken`, `ownerLaneId`,
+ * `leasedUntil`). Used by `isExemptLegacySlice` to enforce the "all-or-
+ * nothing legacy" rule: only slices with NO worktree fields anywhere
+ * in their rows qualify for the legacyContinuation amnesty.
+ */
+function computeSliceWorktreeMetaState(events) {
+    const out = new Map();
+    for (const ev of events) {
+        if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
+            continue;
+        if (typeof ev.sliceId !== "string")
+            continue;
+        const tok = ev.claimToken?.trim() ?? "";
+        const lane = ev.ownerLaneId?.trim() ?? "";
+        const lease = ev.leasedUntil?.trim() ?? "";
+        const anyHere = tok.length > 0 || lane.length > 0 || lease.length > 0;
+        const prev = out.get(ev.sliceId) ?? { anyMeta: false };
+        out.set(ev.sliceId, { anyMeta: prev.anyMeta || anyHere });
+    }
+    return out;
+}
+/**
+ * v6.14.2 — slices whose terminal `refactor` / `refactor-deferred` /
+ * `resolve-conflict` row recorded a `completedTs` that PRECEDES the
+ * latest `leasedUntil` for the same slice. The lease was never
+ * reclaimed but the wave closed in time; the missing audit row is
+ * advisory bookkeeping, not a correctness failure.
+ */
+function computeClosedBeforeLeaseExpiry(events) {
+    const terminalPhases = new Set([
+        "refactor",
+        "refactor-deferred",
+        "resolve-conflict"
+    ]);
+    const lastLease = new Map();
+    const earliestTerminal = new Map();
+    for (const ev of events) {
+        if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
+            continue;
+        if (typeof ev.sliceId !== "string")
+            continue;
+        if (typeof ev.leasedUntil === "string") {
+            const until = Date.parse(ev.leasedUntil);
+            if (Number.isFinite(until)) {
+                const prev = lastLease.get(ev.sliceId);
+                if (prev === undefined || until > prev) {
+                    lastLease.set(ev.sliceId, until);
+                }
+            }
+        }
+        if (ev.status === "completed" &&
+            typeof ev.phase === "string" &&
+            terminalPhases.has(ev.phase) &&
+            typeof ev.completedTs === "string") {
+            const ts = Date.parse(ev.completedTs);
+            if (Number.isFinite(ts)) {
+                const prev = earliestTerminal.get(ev.sliceId);
+                if (prev === undefined || ts < prev) {
+                    earliestTerminal.set(ev.sliceId, ts);
+                }
+            }
+        }
+    }
+    const out = new Set();
+    for (const [sliceId, terminalTs] of earliestTerminal.entries()) {
+        const leaseTs = lastLease.get(sliceId);
+        if (leaseTs === undefined)
+            continue;
+        if (terminalTs < leaseTs) {
+            out.add(sliceId);
+        }
+    }
+    return out;
+}
+/**
+ * v6.14.2 Fix 2 — advisory linter rule.
+ *
+ * Fires when:
+ *   (a) `tddCutoverSliceId` is set on the active flow state, AND
+ *   (b) the active run has a `scheduled` row whose `sliceId === tddCutoverSliceId`
+ *       AND `phase ∈ {red, green, doc}`, AND
+ *   (c) that slice already has a terminal `refactor` / `refactor-deferred` /
+ *       `resolve-conflict` event recorded for it (under any run) — i.e.
+ *       it's already closed.
+ *
+ * This is the diagnostic hox surfaced on S-17/W-03: the controller
+ * read `tddCutoverSliceId: "S-11"` and treated it as the active slice
+ * pointer, then dispatched new work for S-11 (already closed under
+ * v6.12 markdown). Advisory — never blocks stage-complete.
+ */
+function evaluateCutoverMisread(input) {
+    const { tddCutoverSliceId, activeRunEntries, ledgerEntries } = input;
+    const cutoverPhases = new Set(["red", "green", "doc"]);
+    const newWork = activeRunEntries.find((entry) => entry.sliceId === tddCutoverSliceId &&
+        typeof entry.phase === "string" &&
+        cutoverPhases.has(entry.phase) &&
+        // any schedule/launch/ack/completed for the cutover slice in this run
+        (entry.status === "scheduled" ||
+            entry.status === "launched" ||
+            entry.status === "acknowledged" ||
+            entry.status === "completed"));
+    if (!newWork)
+        return null;
+    const terminalPhases = new Set([
+        "refactor",
+        "refactor-deferred",
+        "resolve-conflict"
+    ]);
+    const closure = ledgerEntries.find((entry) => entry.sliceId === tddCutoverSliceId &&
+        entry.status === "completed" &&
+        typeof entry.phase === "string" &&
+        terminalPhases.has(entry.phase));
+    if (!closure)
+        return null;
+    const closedTs = closure.completedTs ?? closure.endTs ?? closure.ts ?? "(unknown)";
+    const closedRunId = closure.runId ?? "(unknown-run)";
+    return {
+        section: "tdd_cutover_misread_warning",
+        required: false,
+        rule: "v6.14.2 Fix 2 advisory: `tddCutoverSliceId` is a HISTORICAL boundary set by sync, NOT a pointer to the active slice. The controller appears to have scheduled new work on the cutover slice id while that slice already closed.",
+        found: false,
+        details: `Active run scheduled new ${newWork.phase} work for slice ${tddCutoverSliceId} but that slice closed at ${closedTs} (run ${closedRunId}) — confirm this is intentional re-work, not a misread of tddCutoverSliceId. ` +
+            "Use `cclaw-cli internal wave-status --json` to find the next ready slice."
+    };
+}
 export function parseVerticalSliceCycle(body) {
     const tableLines = body.split("\n").filter((line) => /^\|/u.test(line));
     if (tableLines.length < 3) {

package/dist/artifact-linter.js

@@ -126,6 +126,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
     let worktreeExecutionMode = "single-tree";
     let tddCheckpointMode = "per-slice";
     let integrationOverseerMode = "always";
+    let tddCutoverSliceId = "";
+    let tddWorktreeCutoverSliceId = "";
     try {
         const flowState = await readFlowState(projectRoot);
         const hint = flowState.interactionHints?.[stage];
@@ -140,6 +142,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         worktreeExecutionMode = effectiveWorktreeExecutionMode(flowState);
         tddCheckpointMode = effectiveTddCheckpointMode(flowState);
         integrationOverseerMode = effectiveIntegrationOverseerMode(flowState);
+        tddCutoverSliceId = flowState.tddCutoverSliceId ?? "";
+        tddWorktreeCutoverSliceId = flowState.tddWorktreeCutoverSliceId ?? "";
     }
     catch {
         activeStageFlags = [];
@@ -152,6 +156,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         worktreeExecutionMode = "single-tree";
         tddCheckpointMode = "per-slice";
         integrationOverseerMode = "always";
+        tddCutoverSliceId = "";
+        tddWorktreeCutoverSliceId = "";
     }
     for (const extra of options.extraStageFlags ?? []) {
         if (typeof extra === "string" && extra.length > 0 && !activeStageFlags.includes(extra)) {
@@ -291,7 +297,9 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         legacyContinuation,
         worktreeExecutionMode,
         tddCheckpointMode,
-        integrationOverseerMode
+        integrationOverseerMode,
+        tddCutoverSliceId,
+        tddWorktreeCutoverSliceId
     };
     switch (stage) {
         case "brainstorm":

package/dist/content/core-agents.js

@@ -52,6 +52,56 @@ Before doing substantive work, return an ACK object that the parent can record:
 
 Finish with the required return schema plus the same \`spanId\` and \`dispatchId\`. The parent must not claim isolated completion unless ACK/result proof matches the ledger/event span.`;
 }
+/**
+ * v6.14.1 — TDD worker self-record contract. The parent records
+ * `scheduled` and `launched` rows BEFORE dispatching the Task; the
+ * worker is responsible for `acknowledged` (on entry) and `completed`
+ * (on exit). This contract restores the v6.13.1 discipline that
+ * v6.14.0 dropped — the controller-side fix in v6.14.1's TDD skill
+ * text is paired with this worker-side self-record helper template.
+ */
+function tddWorkerSelfRecordContract(agentName) {
+    const isImplementer = agentName === "slice-implementer";
+    const refactorOutcomeFlag = isImplementer
+        ? " --refactor-outcome=inline|deferred [--refactor-rationale=\"<why>\"]"
+        : "";
+    const laneFlags = isImplementer
+        ? " [--claim-token=<t>] [--lane-id=<lane>] [--lease-until=<iso>]"
+        : "";
+    return `## TDD Worker Self-Record Contract (v6.14.2)
+
+You are a TDD worker dispatched via \`Task\`. The parent already wrote your \`scheduled\` and \`launched\` ledger rows BEFORE invoking you. **Your responsibility is to self-record \`acknowledged\` on entry and \`completed\` on exit** by invoking \`.cclaw/hooks/delegation-record.mjs\` directly. Do NOT skip these — the controller depends on them, the linter validates them, and back-fill via \`--repair\` is reserved for recovery only.
+
+**On entry — record acknowledgement (BEFORE doing work):**
+
+\`\`\`bash
+ACK_TS="$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ 2>/dev/null || date -u +%Y-%m-%dT%H:%M:%SZ)"
+node .cclaw/hooks/delegation-record.mjs \\
+  --stage=tdd --agent=${agentName} --mode=mandatory \\
+  --status=acknowledged \\
+  --span-id=<spanId from controller dispatch> \\
+  --dispatch-id=<dispatchId from controller dispatch> \\
+  --dispatch-surface=<surface from controller dispatch> \\
+  --agent-definition-path=.cclaw/agents/${agentName}.md \\
+  --ack-ts="$ACK_TS" \\
+  --json
+\`\`\`
+
+**On exit — record completion (AFTER work + verification):**
+
+\`\`\`bash
+COMPLETED_TS="$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ 2>/dev/null || date -u +%Y-%m-%dT%H:%M:%SZ)"
+node .cclaw/hooks/delegation-record.mjs \\
+  --stage=tdd --agent=${agentName} --mode=mandatory \\
+  --status=completed \\
+  --span-id=<same spanId> \\
+  --completed-ts="$COMPLETED_TS" \\
+  --evidence-ref="<test-path-or-artifact-ref>"${refactorOutcomeFlag}${laneFlags} \\
+  --json
+\`\`\`
+
+Reuse the same \`<spanId>\` and \`<dispatchId>\` across both rows. **v6.14.2 evidence-freshness contract** (slice-implementer GREEN only): the FIRST \`--evidence-ref\` MUST (1) reference the same test the matching \`phase=red\` row cited (basename/stem substring; reject \`green_evidence_red_test_mismatch\`), (2) include a recognized passing-runner line such as \`=> N passed; 0 failed\`, \`N passed in 0.42s\`, or \`ok pkg 0.12s\` (reject \`green_evidence_passing_assertion_missing\`), AND (3) be captured AFTER \`ackTs\` of this span — \`completedTs - ackTs\` must be ≥ \`flow-state.json::tddGreenMinElapsedMs\` (default 4000ms; reject \`green_evidence_too_fresh\`). Escape clause for legitimate observational GREEN: pass BOTH \`--allow-fast-green --green-mode=observational\`. \`--ack-ts\` and \`--completed-ts\` must be monotonic on the span (\`startTs ≤ launchedTs ≤ ackTs ≤ completedTs\`); the helper rejects out-of-order writes with \`delegation_timestamp_non_monotonic\`. If the helper rejects with \`dispatch_active_span_collision\` against a stale span, surface the conflicting \`spanId\` to the parent — do NOT silently retry with \`--allow-parallel\`.`;
+}
 function formatReturnSchema(schema) {
     const lines = [
         `- Status field: \`${schema.statusField}\``,
@@ -600,6 +650,18 @@ export const CCLAW_AGENTS = [
         ].join("\n")
     }
 ];
+/**
+ * v6.14.1 — agents whose rendered `.cclaw/agents/<name>.md` file gets the
+ * TDD worker self-record helper template. These agents are the ones the
+ * controller dispatches via `Task` during a TDD wave; they are
+ * responsible for `acknowledged` and `completed` ledger writes.
+ */
+const TDD_WORKER_SELF_RECORD_AGENTS = new Set([
+    "test-author",
+    "slice-implementer",
+    "slice-documenter",
+    "integration-overseer"
+]);
 import { stageDelegationSummary } from "./stage-schema.js";
 /**
  * Render a complete cclaw agent markdown file (YAML frontmatter + body).
@@ -627,6 +689,9 @@ export function agentMarkdown(agent) {
     ].join("\n");
     const relatedStages = agent.relatedStages.length > 0 ? agent.relatedStages.join(", ") : "(none)";
     const taskDelegation = defaultTaskDelegationSection(agent.name);
+    const tddWorkerSelfRecordSection = TDD_WORKER_SELF_RECORD_AGENTS.has(agent.name)
+        ? `\n${tddWorkerSelfRecordContract(agent.name)}\n`
+        : "";
     return `${frontmatter}
 
 # ${agent.name}
@@ -639,7 +704,7 @@ ${agent.body}
 - Related stages: ${relatedStages}
 
 ${workerAckContract()}
-
+${tddWorkerSelfRecordSection}
 ## Required Return Schema
 
 STRICT_RETURN_SCHEMA: return a structured object matching this contract before any narrative when delegated. Include \`spanId\`, \`dispatchId\` or \`workerRunId\`, \`dispatchSurface\`, \`agentDefinitionPath\`, and lifecycle timestamps when provided by the parent.