cclaw-cli 6.14.1 → 6.14.3

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,37 @@ export async function lintTddStage(ctx) {
             "refactor-deferred",
             "resolve-conflict"
         ]);
+        // v6.14.3 — under `legacyContinuation: true` AND a stamped
+        // boundary, exempt every slice closed at or before
+        // `tddWorktreeCutoverSliceId`. The cutover boundary itself is the
+        // contract: slices ≤ boundary were closed before the
+        // worktree-first metadata mandate took effect, so we trust the
+        // boundary as authoritative and do not require the slice to have
+        // recorded zero metadata across all rows.
+        //
+        // The earlier v6.14.2 "all-or-nothing" rule rejected the common
+        // hox-shape pattern where the GREEN row carries claim/lane/lease
+        // (added on the v6.14.x worktree-first flip) but a later
+        // `refactor-deferred` terminal row does not. That partial-
+        // metadata layout is the operator-visible signature of the
+        // failure mode this exemption was introduced to fix; flagging it
+        // again under a different code defeated the entire migration.
+        //
+        // Operators who want a strict gate can opt out by clearing
+        // `legacyContinuation` (or omitting `tddWorktreeCutoverSliceId`)
+        // — both fields are explicit, persisted, and operator-editable.
+        const isExemptLegacySlice = (sliceId) => {
+            if (!legacyContinuation)
+                return false;
+            if (worktreeCutoverBoundary === null)
+                return false;
+            const n = parseSliceNumber(sliceId);
+            if (n === null)
+                return false;
+            return n <= worktreeCutoverBoundary;
+        };
         const missingGreenMeta = new Set();
+        const exemptedGreenMeta = new Set();
         for (const ev of runEvents) {
             if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
                 continue;
@@ -269,7 +327,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 +344,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 +364,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 +381,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 +414,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 +428,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 +450,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 +538,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 +1338,110 @@ function pickEventTs(rows) {
     }
     return undefined;
 }
+/**
+ * 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" &&

package/dist/content/stages/tdd.js

@@ -37,7 +37,8 @@ export const TDD = {
     },
     executionModel: {
         checklist: [
-            "**Stream-style wave dispatch (v6.14.0):** Before routing, read the Parallel Execution Plan (managed block in the track planning artifact) and `<artifacts-dir>/wave-plans/`. Per-lane stream: each lane runs RED→GREEN→REFACTOR independently as soon as its `dependsOn` closes — no global RED checkpoint between Phase A and Phase B. The linter enforces RED-before-GREEN per slice via `tdd_slice_red_completed_before_green`; cross-lane interleaving is allowed. **Legacy `global-red` mode** is preserved for projects with `legacyContinuation: true` and any project that explicitly sets `flow-state.json::tddCheckpointMode: \"global-red\"` (rule `tdd_red_checkpoint_violation` still fires there). Multi-ready waves still get one AskQuestion (launch wave vs single-slice); then per-lane GREEN+DOC dispatch with worktree-first flags. Integration-overseer fires only on cross-slice trigger (see `integrationCheckRequired()` heuristic). Resume partial waves by parallelizing remaining members only (see top-of-skill `## Wave Batch Mode`).",
+            "**Wave dispatch — discovery hardened (v6.14.2):** Before routing, your FIRST tool call after entering TDD MUST be `node .cclaw/cli.mjs internal wave-status --json` (or the harness equivalent `npx cclaw-cli internal wave-status --json`). Do NOT page through `05-plan.md` to find the managed block — the helper reads the managed `<!-- parallel-exec-managed-start -->` block deterministically and prints `{ waves, nextDispatch.readyToDispatch, warnings }`. Open `05-plan.md` only AFTER `wave-status` names a slice that needs context. Multi-ready waves: one AskQuestion (launch wave vs single-slice); then RED checkpoint (when `tddCheckpointMode: \"global-red\"`) or per-lane stream (when `tddCheckpointMode: \"per-slice\"`, the v6.14+ default), parallel GREEN+DOC with worktree-first flags, per-lane REFACTOR. Resume partial waves by parallelizing remaining members only (see top-of-skill `## Wave Batch Mode`).",
+            "**Stream-style wave dispatch (v6.14.0):** After `wave-status` resolves the next dispatch, route accordingly. Per-lane stream: each lane runs RED→GREEN→REFACTOR independently as soon as its `dependsOn` closes — no global RED checkpoint between Phase A and Phase B. The linter enforces RED-before-GREEN per slice via `tdd_slice_red_completed_before_green`; cross-lane interleaving is allowed. **Legacy `global-red` mode** is preserved for projects with `legacyContinuation: true` and any project that explicitly sets `flow-state.json::tddCheckpointMode: \"global-red\"` (rule `tdd_red_checkpoint_violation` still fires there). Multi-ready waves still get one AskQuestion (launch wave vs single-slice); then per-lane GREEN+DOC dispatch with worktree-first flags. Integration-overseer fires only on cross-slice trigger (see `integrationCheckRequired()` heuristic).",
             "**Controller dispatch ordering (v6.14.1 — record BEFORE dispatch).** For every `Task` subagent the controller spawns, record `scheduled` then `launched` ledger events via `node .cclaw/hooks/delegation-record.mjs --status=scheduled ...` and `--status=launched ...` **BEFORE** the `Task(...)` call (one message: ledger writes first, then the matching `Task` calls). Workers self-record `acknowledged` and `completed`; controller back-fill is reserved for `--repair` recovery only. Pass `--span-id`, `--lane-id`, `--claim-token`, `--lease-until` through to the worker so its own helper invocations reuse them.",
             "**Wave closure — integration-overseer decision (v6.14.1).** When every dispatched lane has a `phase=green status=completed` event AND per-lane REFACTOR coverage is satisfied (separate phase event OR `refactorOutcome` folded into GREEN), call `integrationCheckRequired(events, fanInAudits)` from `src/delegation.ts`. (1) `required: true` → dispatch `integration-overseer` as before. (2) `required: false` → emit the audit row via `node .cclaw/hooks/delegation-record.mjs --audit-kind=cclaw_integration_overseer_skipped --audit-reason=\"<reasons>\" --slice-ids=\"S-1,S-2\" --json` and SKIP the dispatch. Linter advisory `tdd_integration_overseer_skipped_audit_missing` flags a wave that closes without either an overseer dispatch or this audit row.",
             "**Inline DOC opt-in (v6.14.1 — single-slice non-deep waves).** Default remains parallel `slice-documenter --phase doc` dispatched alongside `slice-implementer --phase green`. For single-slice waves where `flow-state.json::discoveryMode != \"deep\"`, the controller MAY skip the parallel documenter and instead invoke `slice-implementer --finalize-doc --slice S-<id> --paths <artifacts-dir>/tdd-slices/S-<id>.md` synchronously after GREEN. Multi-slice waves and any `discoveryMode=deep` run keep parallel slice-documenter mandatory.",
@@ -114,7 +115,7 @@ export const TDD = {
             "Relevant existing test files, helpers, fixtures, and exact commands identified before RED.",
             "Callbacks, state transitions, interfaces, schemas, and contracts checked for impact before implementation.",
             "Execution posture and vertical-slice RED/GREEN/REFACTOR checkpoint plan recorded, including commit boundaries when the repo workflow supports them.",
-            "RED observability: a `phase=red` event in `delegation-events.jsonl` for each slice with non-empty evidenceRefs (test path, span ref, or pasted-output pointer). Slices created **before the v6.12.0 cutover marker** in `flow-state.json::tddCutoverSliceId` may retain legacy `## Watched-RED Proof` / `## RED Evidence` markdown tables; slices created **after the cutover marker** MUST use phase events + slice-documenter doc, and legacy table writes are surfaced by the advisory `tdd_legacy_section_writes_after_cutover` rule.",
+            "RED observability: a `phase=red` event in `delegation-events.jsonl` for each slice with non-empty evidenceRefs (test path, span ref, or pasted-output pointer). **`flow-state.json::tddCutoverSliceId` is a HISTORICAL boundary set by `cclaw-cli sync` at upgrade time; it is NOT a pointer to the active slice and the controller MUST NOT dispatch new work for that slice id on its basis.** Slices created at or before the cutover marker may retain legacy `## Watched-RED Proof` / `## RED Evidence` markdown tables; slices created after the cutover marker MUST use phase events + slice-documenter doc, and legacy table writes are surfaced by the advisory `tdd_legacy_section_writes_after_cutover` rule. To find the ACTIVE slice, run `cclaw-cli internal wave-status --json` (Fix 1, v6.14.2) — never derive it from `tddCutoverSliceId`.",
             "GREEN observability: a `phase=green` event in `delegation-events.jsonl` per slice whose `completedTs` >= the matching `phase=red` `completedTs`, authored by `slice-implementer` (linter rule `tdd_slice_implementer_missing` blocks the gate otherwise), and whose evidenceRefs name the failing-now-passing test. Pre-cutover slices may keep legacy `## GREEN Evidence` markdown.",
             "REFACTOR observability: per slice, a `phase=refactor` event OR a `phase=refactor-deferred` event whose evidenceRefs / refactor rationale captures why refactor was deferred.",
             "Per slice, a `phase=doc` event from `slice-documenter` whose evidenceRefs name `<artifacts-dir>/tdd-slices/S-<id>.md`. Mandatory regardless of `discoveryMode` (v6.12.0 Phase R). Linter rule `tdd_slice_documenter_missing` blocks the gate when missing.",