cclaw-cli 6.14.1 → 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) => {
@@ -1213,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

@@ -68,7 +68,7 @@ function tddWorkerSelfRecordContract(agentName) {
     const laneFlags = isImplementer
         ? " [--claim-token=<t>] [--lane-id=<lane>] [--lease-until=<iso>]"
         : "";
-    return `## TDD Worker Self-Record Contract (v6.14.1)
+    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.
 
@@ -100,7 +100,7 @@ node .cclaw/hooks/delegation-record.mjs \\
   --json
 \`\`\`
 
-Reuse the same \`<spanId>\` and \`<dispatchId>\` across both rows. \`--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\`.`;
+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 = [

package/dist/content/hooks.js

@@ -307,6 +307,65 @@ async function readWorktreeExecutionModeInline(root) {
   }
 }
 
+// v6.14.2 — read \`tddGreenMinElapsedMs\` from flow-state.json. Defaults to
+// 4000ms when missing or invalid. Operators set 0 to disable the freshness
+// floor while keeping RED-test-name and passing-assertion checks active.
+async function readTddGreenMinElapsedMsInline(root) {
+  try {
+    const raw = await fs.readFile(path.join(root, RUNTIME_ROOT, "state", "flow-state.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.tddGreenMinElapsedMs === "number" && parsed.tddGreenMinElapsedMs >= 0) {
+      return Math.floor(parsed.tddGreenMinElapsedMs);
+    }
+    return 4000;
+  } catch {
+    return 4000;
+  }
+}
+
+// v6.14.2 Fix 4 — match the RED test name into the GREEN evidenceRef.
+// Returns the basename or stem (without extension) of the most-specific
+// path token in the RED row's first evidenceRef. We deliberately use a
+// substring match, not equality, so callers can include richer text
+// like "REGRESSION: cargo test --test foo => 8 passed; 0 failed".
+function extractRedTestNameInline(redEvidenceRef) {
+  if (typeof redEvidenceRef !== "string") return null;
+  const trimmed = redEvidenceRef.trim();
+  if (trimmed.length === 0) return null;
+  // Path-shaped token (foo/bar/baz_test.rs or src/foo.test.ts).
+  const pathMatch = /[A-Za-z0-9_./-]+/u.exec(trimmed);
+  if (pathMatch) {
+    const token = pathMatch[0];
+    const slashIdx = token.lastIndexOf("/");
+    const base = slashIdx >= 0 ? token.slice(slashIdx + 1) : token;
+    const dotIdx = base.indexOf(".");
+    const stem = dotIdx > 0 ? base.slice(0, dotIdx) : base;
+    if (stem.length >= 4) return stem;
+    return base;
+  }
+  return trimmed;
+}
+
+// Match canonical runner pass lines:
+//   cargo: "test result: ok. N passed; 0 failed"
+//   pytest: "===== N passed in 0.42s ====="
+//   go test: "ok   pkg   0.123s"
+//   npm/jest/vitest: "Tests:  N passed"
+// We accept a generic shape: "=> N passed; 0 failed" (the example in
+// the v6.14.2 worker contract) plus four runner-specific patterns.
+const GREEN_PASS_PATTERNS = [
+  /=>\\s*\\d+\\s+passed/iu,
+  /\\b\\d+\\s+passed[;,]\\s*0\\s+failed\\b/iu,
+  /\\btest\\s+result:\\s*ok\\b/iu,
+  /\\b\\d+\\s+passed\\s+in\\s+\\d+(?:\\.\\d+)?\\s*s\\b/iu,
+  /^ok\\s+\\S+\\s+\\d+(?:\\.\\d+)?s\\b/imu
+];
+
+function matchesPassingAssertionInline(value) {
+  if (typeof value !== "string") return false;
+  return GREEN_PASS_PATTERNS.some((re) => re.test(value));
+}
+
 async function readDelegationEvents(root) {
   try {
     const raw = await fs.readFile(path.join(root, RUNTIME_ROOT, "state", "delegation-events.jsonl"), "utf8");
@@ -1435,6 +1494,137 @@ async function main() {
     }
   }
 
+  // v6.14.2 Fix 4 — GREEN evidence freshness contract for
+  // \`slice-implementer --phase green --status=completed\`. Three checks:
+  //   1. green_evidence_red_test_mismatch — evidenceRefs[0] must contain
+  //      the basename/stem of the RED span's first evidenceRef.
+  //   2. green_evidence_passing_assertion_missing — evidenceRefs[0]
+  //      must carry a recognized passing-assertion line ("=> N passed;
+  //      0 failed" or runner-specific equivalents).
+  //   3. green_evidence_too_fresh — completedTs minus ackTs must be
+  //      >= flow-state.json::tddGreenMinElapsedMs (default 4000ms).
+  // Escape hatch for legitimate observational GREENs (cross-slice
+  // handoff, no-op verification): pair --allow-fast-green with
+  // --green-mode=observational. Both flags are required.
+  if (
+    clean.stage === "tdd" &&
+    clean.agent === "slice-implementer" &&
+    clean.phase === "green" &&
+    clean.status === "completed"
+  ) {
+    const isObservational =
+      typeof args["green-mode"] === "string" &&
+      args["green-mode"].trim().toLowerCase() === "observational";
+    const allowFastGreen = args["allow-fast-green"] === true;
+    const greenEvidenceFirst =
+      Array.isArray(clean.evidenceRefs) && clean.evidenceRefs.length > 0
+        ? String(clean.evidenceRefs[0])
+        : "";
+
+    // Locate the matching RED row's first evidenceRef in the events log.
+    const priorEvents = await readDelegationEvents(root);
+    let redEvidenceRef = null;
+    for (let i = priorEvents.length - 1; i >= 0; i -= 1) {
+      const ev = priorEvents[i];
+      if (!ev) continue;
+      if (ev.runId !== runId) continue;
+      if (ev.stage !== "tdd") continue;
+      if (ev.sliceId !== clean.sliceId) continue;
+      if (ev.phase !== "red") continue;
+      if (Array.isArray(ev.evidenceRefs) && ev.evidenceRefs.length > 0) {
+        redEvidenceRef = String(ev.evidenceRefs[0] || "");
+        break;
+      }
+    }
+
+    // The freshness contract only fires when there's a matching RED row
+    // for this slice in the active run. Without RED context we have
+    // nothing to verify GREEN against (legacy ledger imports, RED
+    // happened outside cclaw harness, or test fixtures that bypass
+    // RED). Once a RED row is present, the contract becomes
+    // mandatory unless explicitly waived via --allow-fast-green
+    // --green-mode=observational.
+    const hasRedContext = redEvidenceRef !== null;
+    const escapeFastGreen = allowFastGreen && isObservational;
+
+    if (hasRedContext && !escapeFastGreen) {
+      // Check 1: RED test name match.
+      const stem = extractRedTestNameInline(redEvidenceRef);
+      if (stem && greenEvidenceFirst.length > 0 && !greenEvidenceFirst.toLowerCase().includes(stem.toLowerCase())) {
+        emitErrorJson(
+          "green_evidence_red_test_mismatch",
+          {
+            sliceId: clean.sliceId,
+            redEvidenceFirst: redEvidenceRef,
+            greenEvidenceFirst,
+            expectedSubstring: stem,
+            remediation:
+              "evidenceRefs[0] on the GREEN row must reference the same test the RED row cited. Re-run the matching RED test, capture its passing output, and pass it as --evidence-ref."
+          },
+          json
+        );
+        return;
+      }
+
+      // Check 2: passing-assertion line.
+      if (greenEvidenceFirst.length > 0 && !matchesPassingAssertionInline(greenEvidenceFirst)) {
+        emitErrorJson(
+          "green_evidence_passing_assertion_missing",
+          {
+            sliceId: clean.sliceId,
+            greenEvidenceFirst,
+            remediation:
+              "evidenceRefs[0] on the GREEN row must contain a passing-assertion line such as \\"=> N passed; 0 failed\\" (cargo/jest/vitest), \\"N passed in 0.42s\\" (pytest), \\"ok pkg 0.12s\\" (go test), or equivalent runner output. Re-run the test and paste a fresh runner line."
+          },
+          json
+        );
+        return;
+      }
+
+      // Check 3: fast-green floor. ackTs is required upstream; we use
+      // the persisted ackTs from prior events when not provided on this
+      // row.
+      const minMs = await readTddGreenMinElapsedMsInline(root);
+      if (minMs > 0 && clean.completedTs) {
+        let ackTs = clean.ackTs;
+        if (!ackTs) {
+          for (let i = priorEvents.length - 1; i >= 0; i -= 1) {
+            const ev = priorEvents[i];
+            if (!ev) continue;
+            if (ev.spanId !== clean.spanId) continue;
+            if (typeof ev.ackTs === "string" && ev.ackTs.length > 0) {
+              ackTs = ev.ackTs;
+              break;
+            }
+          }
+        }
+        if (ackTs) {
+          const completedMs = Date.parse(clean.completedTs);
+          const ackMs = Date.parse(ackTs);
+          if (Number.isFinite(completedMs) && Number.isFinite(ackMs)) {
+            const elapsed = completedMs - ackMs;
+            if (elapsed < minMs) {
+              emitErrorJson(
+                "green_evidence_too_fresh",
+                {
+                  sliceId: clean.sliceId,
+                  ackTs,
+                  completedTs: clean.completedTs,
+                  elapsedMs: elapsed,
+                  minMs,
+                  remediation:
+                    "GREEN completedTs - ackTs is below the freshness floor. Either run the verification test for real and re-record, or pass --allow-fast-green --green-mode=observational for legitimate no-op verification spans."
+                },
+                json
+              );
+              return;
+            }
+          }
+        }
+      }
+    }
+  }
+
   if (
     clean.stage === "tdd" &&
     clean.agent === "slice-implementer" &&