cclaw-cli 6.14.0 → 6.14.2

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");
@@ -344,6 +403,7 @@ function usage() {
     "  node .cclaw/hooks/delegation-record.mjs --stage=<stage> --agent=<agent> --mode=<mandatory|proactive> --status=<scheduled|launched|acknowledged|completed|failed|waived|stale> --span-id=<id> [--dispatch-id=<id>] [--worker-run-id=<id>] [--dispatch-surface=<surface>] [--agent-definition-path=<path>] [--ack-ts=<iso>] [--launched-ts=<iso>] [--completed-ts=<iso>] [--evidence-ref=<ref>] [--waiver-reason=<text>] [--supersede=<prevSpanId>] [--allow-parallel] [--paths=<comma-separated>] [--override-cap=<int>] [--json]",
     "  node .cclaw/hooks/delegation-record.mjs --rerecord --span-id=<id> --dispatch-id=<id> --dispatch-surface=<surface> --agent-definition-path=<path> [--ack-ts=<iso>] [--completed-ts=<iso>] [--evidence-ref=<ref>] [--json]",
     "  node .cclaw/hooks/delegation-record.mjs --repair --span-id=<id> --repair-reason=\\\"<why>\\\" [--json]",
+    "  node .cclaw/hooks/delegation-record.mjs --audit-kind=cclaw_integration_overseer_skipped [--audit-reason=\\\"<comma-separated reasons>\\\"] [--slice-ids=\\\"S-1,S-2\\\"] [--json]    # v6.14.1: emit non-delegation audit row only",
     "",
     "Allowed --dispatch-surface values:",
     "  " + VALID_DISPATCH_SURFACES.join(", "),
@@ -898,6 +958,74 @@ async function findLegacyEntry(root, spanId) {
   return ledger.entries.find((entry) => entry && entry.spanId === spanId) || null;
 }
 
+// v6.14.1 — allow-list of non-delegation audit events the controller
+// can emit via the helper. Keep in sync with NON_DELEGATION_AUDIT_EVENTS
+// in src/delegation.ts.
+const VALID_AUDIT_KINDS = new Set([
+  "cclaw_integration_overseer_skipped"
+]);
+
+async function runAuditEmit(args, json) {
+  const kind = String(args["audit-kind"]).trim();
+  if (!VALID_AUDIT_KINDS.has(kind)) {
+    emitProblems([
+      "invalid --audit-kind: " + kind +
+        " (allowed: " + [...VALID_AUDIT_KINDS].join(", ") + ")"
+    ], json, 2);
+    return;
+  }
+  const root = await detectRoot();
+  const runId = await readRunId(root);
+  const reason = typeof args["audit-reason"] === "string"
+    ? args["audit-reason"].trim()
+    : "";
+  const sliceIdsRaw = typeof args["slice-ids"] === "string"
+    ? args["slice-ids"].trim()
+    : "";
+  const sliceIds = sliceIdsRaw.length > 0
+    ? sliceIdsRaw
+      .split(",")
+      .map((value) => value.trim())
+      .filter((value) => value.length > 0)
+    : [];
+  const ts = new Date().toISOString();
+  const payload = {
+    event: kind,
+    runId,
+    ts,
+    eventTs: ts,
+    ...(reason.length > 0 ? { reasons: reason.split(",").map((r) => r.trim()).filter((r) => r.length > 0) } : {}),
+    ...(sliceIds.length > 0 ? { sliceIds } : {})
+  };
+  const stateDir = path.join(root, RUNTIME_ROOT, "state");
+  try {
+    await fs.mkdir(stateDir, { recursive: true });
+    await fs.appendFile(
+      path.join(stateDir, "delegation-events.jsonl"),
+      JSON.stringify(payload) + "\\n",
+      { encoding: "utf8", mode: 0o600 }
+    );
+  } catch (error) {
+    const message = error && typeof error === "object" && "message" in error
+      ? String(error.message)
+      : String(error);
+    emitErrorJson("audit_emit_failed", { kind, message }, json);
+    return;
+  }
+  if (json) {
+    process.stdout.write(JSON.stringify({
+      ok: true,
+      command: "audit-emit",
+      auditKind: kind,
+      runId,
+      sliceIds,
+      ts
+    }, null, 2) + "\\n");
+  } else {
+    process.stdout.write("[cclaw] audit emitted: " + kind + " (run=" + runId + ", ts=" + ts + ")\\n");
+  }
+}
+
 async function runRerecord(args, json) {
   const problems = [];
   for (const key of ["span-id", "dispatch-id", "dispatch-surface", "agent-definition-path"]) {
@@ -1130,6 +1258,18 @@ async function main() {
     return;
   }
 
+  // v6.14.1 — audit-only emit path. When the controller wants to record
+  // a non-delegation audit row (e.g. \`cclaw_integration_overseer_skipped\`
+  // when the wave heuristic chose to skip the overseer dispatch), pass
+  // --audit-kind=<event-name> [--audit-reason=<text>] [--slice-ids=<csv>]
+  // and the helper appends a single line to delegation-events.jsonl
+  // without touching the lifecycle ledger. The kind must be in the
+  // canonical allow-list so a typo cannot inject an unrecognized event.
+  if (typeof args["audit-kind"] === "string" && args["audit-kind"].trim().length > 0) {
+    await runAuditEmit(args, json);
+    return;
+  }
+
   const problems = [];
   if (!args.stage) problems.push("missing --stage");
   if (!args.agent) problems.push("missing --agent");
@@ -1354,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,12 @@ 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.",
+            "**Stale active-span recovery (v6.14.1).** If `delegation-record` rejects a new `--status=scheduled` with `dispatch_active_span_collision` or `dispatch_duplicate` and the conflicting span has a `completed` event in `delegation-events.jsonl`, the fold is correct (`computeActiveSubagents` excludes terminal spans) and the rejection is from a different live span on the same `(stage, agent)` pair — pass `--allow-parallel` deliberately, quote the conflicting `spanId` in the turn output, and proceed. If you cannot identify the conflicting active span, STOP and report — do not blanket-add `--allow-parallel` to silence the helper.",
             "Select vertical slice — the active wave plan (or single ready slice) defines work. Do not ask \"which slice next?\" when the plan already resolves it. Before starting, read `.cclaw/state/ralph-loop.json` (`loopIteration`, `acClosed[]`, `redOpenSlices[]`) so you skip cycles already closed. If `redOpenSlices[]` is non-empty, repair or explicitly park those slices before opening a new RED.",
             "Map to acceptance criterion — identify the specific spec criterion this test proves.",
             "Discover the test surface — inspect existing tests, fixtures, helpers, test commands, and nearby assertions before authoring RED. Reuse the local test style unless the slice genuinely needs a new pattern.",
@@ -49,8 +54,8 @@ export const TDD = {
             "GREEN: Run full suite — execute ALL tests, not just the ones you wrote. The full suite must be GREEN.",
             "GREEN: Verify no regressions — if any existing test breaks, fix the regression before proceeding.",
             "Run verification-before-completion discipline for the slice — capture a fresh test command, explicit PASS/FAIL status, and a config-aware ref (commit SHA when VCS is present/required, or no-vcs attestation when allowed).",
-            "REFACTOR (v6.14.0 — three forms): (1) re-dispatch `slice-implementer` with `--phase refactor` after GREEN; (2) re-dispatch with `--phase refactor-deferred --refactor-rationale \"<why>\"` to close without a separate pass; (3) **fold REFACTOR into GREEN** by adding `--refactor-outcome=inline|deferred [--refactor-rationale=\"<why>\"]` on the same `slice-implementer --phase green` dispatch. Form (3) is the v6.14.0 default; the linter accepts all three as REFACTOR coverage. Set `CCLAW_ACTIVE_AGENT=tdd-refactor` when the harness supports phase labels.",
-            "DOC (v6.14.0 — softened): in `discoveryMode=deep` runs DOC remains mandatory — dispatch `slice-documenter --slice S-<id> --phase doc --paths <artifacts-dir>/tdd-slices/S-<id>.md` IN PARALLEL with `slice-implementer --phase green` for the same slice (ONE message with TWO concurrent Task calls). The documenter only writes `tdd-slices/S-<id>.md`, so its `--paths` are disjoint from the implementer's production paths and the file-overlap scheduler auto-allows parallel dispatch. **In `lean` and `guided` modes DOC is advisory** (linter `tdd_slice_documenter_missing` becomes `required: false`); controllers may either keep parallel `slice-documenter` dispatch or call `slice-implementer --finalize-doc` inline at GREEN-completion. **Provisional-then-finalize still applies for parallel dispatch:** append a provisional row/section in `tdd-slices/S-<id>.md` at dispatch time, then finalize after the matching `phase=green` event records evidence.",
+            "REFACTOR (v6.14.0+ — three forms): (1) re-dispatch `slice-implementer` with `--phase refactor` after GREEN; (2) re-dispatch with `--phase refactor-deferred --refactor-rationale \"<why>\"` to close without a separate pass; (3) **fold REFACTOR into GREEN** by adding `--refactor-outcome=inline|deferred [--refactor-rationale=\"<why>\"]` on the same `slice-implementer --phase green` `--status=completed` write. Form (3) is the v6.14.0 default for new projects; the linter accepts all three as REFACTOR coverage. Form (1) is the only legal form when BOTH `legacyContinuation: true` AND `flow-state.json::tddCheckpointMode: \"global-red\"` are set (legacy hox-shape projects); other projects may use any form. Set `CCLAW_ACTIVE_AGENT=tdd-refactor` when the harness supports phase labels.",
+            "DOC (v6.14.0+ softened, v6.14.1 inline-opt-in): in `discoveryMode=deep` runs DOC remains mandatory — dispatch `slice-documenter --slice S-<id> --phase doc --paths <artifacts-dir>/tdd-slices/S-<id>.md` IN PARALLEL with `slice-implementer --phase green` for the same slice (ONE message with TWO concurrent Task calls). The documenter only writes `tdd-slices/S-<id>.md`, so its `--paths` are disjoint from the implementer's production paths and the file-overlap scheduler auto-allows parallel dispatch. **In `lean` and `guided` modes DOC is advisory** (linter `tdd_slice_documenter_missing` becomes `required: false`); the controller MAY either keep parallel `slice-documenter` dispatch (default — preserves the documenter's isolated context) OR, **for single-slice non-deep waves**, call `slice-implementer --finalize-doc --slice S-<id> --paths <artifacts-dir>/tdd-slices/S-<id>.md` inline after GREEN completes. Multi-slice waves keep parallel `slice-documenter` regardless of mode. **Provisional-then-finalize still applies for parallel dispatch:** append a provisional row/section in `tdd-slices/S-<id>.md` at dispatch time, then finalize after the matching `phase=green` event records evidence.",
             "**slice-documenter writes per-slice prose** (test discovery, system-wide impact check, RED/GREEN/REFACTOR notes, acceptance mapping, failure analysis) into `tdd-slices/S-<id>.md`. Controller does NOT touch this content. When logging a `green` row, attach the closed acceptance-criterion IDs in `acIds` so Ralph Loop status counts them.",
             "Annotate traceability — link to the active track's source: plan task ID + spec criterion on standard/medium, or spec acceptance item / bug reproduction slice on quick.",
             "**Boundary with review (do NOT escalate single-slice findings to whole-diff review).** `tdd.Per-Slice Review` OWNS severity-classified findings WITHIN one slice (correctness, edge cases, regression). `review` OWNS whole-diff Layer 1 (spec compliance) plus Layer 2 (cross-slice integration, security sweep, dependency/version audit, observability). When a single-slice finding genuinely needs whole-diff escalation, surface it in `06-tdd.md > Per-Slice Review` first; review will cite it (not re-classify) and the cross-artifact-duplication linter requires matching severity/disposition.",
@@ -58,9 +63,9 @@ export const TDD = {
             "Repeat for each slice — when not in multi-slice wave mode, return to wave-plan discovery; otherwise continue the active wave until members close.",
         ],
         interactionProtocol: [
-            "Pick one vertical slice at a time **only when** the merged wave plan leaves a single scheduler-ready slice or the operator chose single-slice mode. Parallel implementers are allowed when lanes touch non-overlapping files (the file-overlap scheduler auto-allows parallel when `--paths` are disjoint). **Integration-overseer is conditional in v6.14.0** (see `flow-state.json::integrationOverseerMode`): with the default `\"conditional\"` it dispatches only when `integrationCheckRequired()` returns `required: true` (shared import boundaries between closed slices, any slice with `riskTier=high`, or a recorded `cclaw_fanin_conflict`). When the heuristic returns `required: false`, record an audit `cclaw_integration_overseer_skipped` and let the linter emit advisory `tdd_integration_overseer_skipped_by_disjoint_paths`. Projects with `legacyContinuation: true` or explicit `\"always\"` keep the v6.13.x mandatory dispatch.",
+            "Pick one vertical slice at a time **only when** the merged wave plan leaves a single scheduler-ready slice or the operator chose single-slice mode. Parallel implementers are allowed when lanes touch non-overlapping files (the file-overlap scheduler auto-allows parallel when `--paths` are disjoint). **Integration-overseer is conditional in v6.14.0** (see `flow-state.json::integrationOverseerMode`): with the default `\"conditional\"` it dispatches only when `integrationCheckRequired()` returns `required: true` (shared import boundaries between closed slices, any slice with `riskTier=high`, or a recorded `cclaw_fanin_conflict`). When the heuristic returns `required: false`, record an audit `cclaw_integration_overseer_skipped` (via `delegation-record --audit-kind=cclaw_integration_overseer_skipped --audit-reason=\"<reasons>\"`) and let the linter emit advisory `tdd_integration_overseer_skipped_by_disjoint_paths`. Projects with `legacyContinuation: true` or explicit `\"always\"` keep the v6.13.x mandatory dispatch.",
             "Slice implementers are sequential only when the plan serializes work; prefer wave-parallel GREEN+DOC when the Parallel Execution Plan marks multiple ready members.",
-            "Controller owns orchestration. For each slice S-<id>, dispatch in this order: (1) `test-author --slice S-<id> --phase red` (RED-only, no production edits), (2) `slice-implementer --slice S-<id> --phase green --paths <comma-separated>` for GREEN, (3) re-dispatch `--phase refactor` or `--phase refactor-deferred --refactor-rationale \"<why>\"` to close REFACTOR. Each dispatch records a row in `delegation-events.jsonl` and the linter auto-derives the Watched-RED + Vertical Slice Cycle tables from those rows. Do NOT hand-edit those tables.",
+            "Controller owns orchestration. **v6.14.1 — record BEFORE dispatch:** every controller `Task` dispatch is preceded by two `delegation-record` writes (`--status=scheduled` then `--status=launched`); workers self-record `--status=acknowledged` on entry and `--status=completed` on exit. Never dispatch first and back-fill — that order breaks the active-span check and forces `--allow-parallel` workarounds. For each slice S-<id>, dispatch in order: (1) `test-author --slice S-<id> --phase red` (RED-only, no production edits), (2) `slice-implementer --slice S-<id> --phase green --paths <comma-separated>` for GREEN, (3) re-dispatch `--phase refactor` or `--phase refactor-deferred --refactor-rationale \"<why>\"` to close REFACTOR. Each dispatch records a row in `delegation-events.jsonl` and the linter auto-derives the Watched-RED + Vertical Slice Cycle tables — do NOT hand-edit those tables.",
             "Before writing RED tests, discover relevant existing tests and commands so the new test extends the suite instead of fighting it.",
             "Before implementation, perform a system-wide impact check across callbacks, state, interfaces, schemas, and external contracts touched by the slice.",
             "Slice-documenter (mandatory v6.12.0, regardless of `discoveryMode`): in PARALLEL with `slice-implementer --phase green`, dispatch `slice-documenter --slice S-<id> --phase doc` whose only `claimedPaths` is `<artifacts-dir>/tdd-slices/S-<id>.md`. The two dispatches run concurrently because their paths are disjoint. The documenter writes per-slice prose so the main `06-tdd.md` stays thin. Controller MUST NOT author per-slice prose; controller MUST NOT author GREEN production code (use `slice-implementer`).",
@@ -110,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.",

package/dist/flow-state.d.ts

@@ -136,6 +136,29 @@ export interface FlowState {
      * sync hasn't visited yet.
      */
     tddCutoverSliceId?: string;
+    /**
+     * v6.14.2 — boundary slice id at which worktree-first protocol began
+     * applying. `cclaw-cli sync` auto-stamps this when
+     * `legacyContinuation: true` AND `worktreeExecutionMode: "worktree-first"`
+     * AND the value is not already set.
+     *
+     * Detection rule (v6.14.2): the highest `S-N` among slices with at
+     * least one completed `slice-implementer` row in the active run that
+     * carries NONE of the worktree-first metadata fields (`claimToken`,
+     * `ownerLaneId`, `leasedUntil`). When no such slice exists, sync
+     * falls back to `tddCutoverSliceId` so legacy v6.12 cutover marks
+     * still confer the exemption.
+     *
+     * Effect: closed slices whose numeric id is `<= tddWorktreeCutoverSliceId`
+     * AND whose `slice-implementer` rows in the active run lack ALL
+     * three worktree fields are exempt from `tdd_slice_lane_metadata_missing`,
+     * `tdd_slice_claim_token_missing`, and `tdd_lease_expired_unreclaimed`.
+     *
+     * One-shot: subsequent sync runs leave the value untouched. Operators
+     * may pin it earlier/later by direct edit + `cclaw-cli internal
+     * flow-state-repair --reason=<slug>`.
+     */
+    tddWorktreeCutoverSliceId?: string;
     /**
      * v6.13.0 — when `worktree-first` (default for newly initialized runs),
      * slice-implementer work happens in isolated git worktrees with explicit
@@ -185,6 +208,20 @@ export interface FlowState {
      * Omitted on legacy state files (treated as `"always"`).
      */
     integrationOverseerMode?: "conditional" | "always";
+    /**
+     * v6.14.2 — minimum elapsed milliseconds between `acknowledged` and
+     * `completed` for a `slice-implementer --phase green` row. The hook
+     * helper rejects fast-greens (`completedTs - ackTs < this`) with
+     * `green_evidence_too_fresh` unless the dispatch carries
+     * `--allow-fast-green --green-mode=observational`.
+     *
+     * Default 4000ms when omitted (see `effectiveTddGreenMinElapsedMs`).
+     * Operators tuning the floor for very fast suites may set it lower
+     * (e.g. `1500`) or set it to `0` to disable the check entirely while
+     * keeping the other Fix 4 contracts (RED test name match, passing
+     * assertion line) active.
+     */
+    tddGreenMinElapsedMs?: number;
 }
 /**
  * Effective worktree mode: legacy state files without the field keep
@@ -202,6 +239,15 @@ export declare function effectiveTddCheckpointMode(state: FlowState): "per-slice
  * the field default to `always` (matches v6.13 behavior).
  */
 export declare function effectiveIntegrationOverseerMode(state: FlowState): "conditional" | "always";
+export declare const DEFAULT_TDD_GREEN_MIN_ELAPSED_MS = 4000;
+/**
+ * v6.14.2 — effective minimum GREEN elapsed window in milliseconds.
+ * Returns the per-project override when present and finite; otherwise
+ * the documented 4000ms default. Negative values or NaN fall through
+ * to the default so a hand-edited `flow-state.json` cannot accidentally
+ * disable the check via `-1` or `"oops"`.
+ */
+export declare function effectiveTddGreenMinElapsedMs(state: FlowState): number;
 export interface StageInteractionHint {
     skipQuestions?: boolean;
     sourceStage?: FlowStage;

package/dist/flow-state.js

@@ -69,6 +69,24 @@ export function effectiveTddCheckpointMode(state) {
 export function effectiveIntegrationOverseerMode(state) {
     return state.integrationOverseerMode === "conditional" ? "conditional" : "always";
 }
+export const DEFAULT_TDD_GREEN_MIN_ELAPSED_MS = 4000;
+/**
+ * v6.14.2 — effective minimum GREEN elapsed window in milliseconds.
+ * Returns the per-project override when present and finite; otherwise
+ * the documented 4000ms default. Negative values or NaN fall through
+ * to the default so a hand-edited `flow-state.json` cannot accidentally
+ * disable the check via `-1` or `"oops"`.
+ */
+export function effectiveTddGreenMinElapsedMs(state) {
+    const raw = state.tddGreenMinElapsedMs;
+    if (typeof raw !== "number")
+        return DEFAULT_TDD_GREEN_MIN_ELAPSED_MS;
+    if (!Number.isFinite(raw))
+        return DEFAULT_TDD_GREEN_MIN_ELAPSED_MS;
+    if (raw < 0)
+        return DEFAULT_TDD_GREEN_MIN_ELAPSED_MS;
+    return Math.floor(raw);
+}
 export function isFlowTrack(value) {
     return typeof value === "string" && FLOW_TRACKS.includes(value);
 }

package/dist/install.js

@@ -1005,12 +1005,25 @@ async function applyPlanLegacyContinuationIfNeeded(projectRoot) {
 }
 /**
  * v6.14.0 — set stream-style defaults on `cclaw-cli sync` and print a
- * one-line hint when defaults change. Strategy:
+ * one-line hint when defaults change.
  *
- * - When `legacyContinuation: true` and `tddCheckpointMode` is unset, force
- *   `tddCheckpointMode: "global-red"` (preserves hox wave protocol).
- * - When `legacyContinuation: true` and `integrationOverseerMode` is unset,
- *   force `integrationOverseerMode: "always"` (preserves v6.13 behavior).
+ * v6.14.2 update — flip the legacyContinuation defaults from
+ * `global-red`/`always` to `per-slice`/`conditional`. Rationale: hox-shape
+ * projects ran into S-17 misroutes precisely because the default
+ * preserved the v6.12 wave barrier even after the project itself had
+ * moved to stream-mode. Existing flow-state values are NEVER overwritten
+ * — operators who want to pin `global-red`/`always` may set them
+ * explicitly via `cclaw-cli internal set-checkpoint-mode global-red` and
+ * `set-integration-overseer-mode always`.
+ *
+ * Strategy:
+ *
+ * - When `legacyContinuation: true` and `tddCheckpointMode` is unset,
+ *   default to `tddCheckpointMode: "per-slice"` (v6.14.2 — was
+ *   `global-red` in v6.14.0/v6.14.1).
+ * - When `legacyContinuation: true` and `integrationOverseerMode` is
+ *   unset, default to `integrationOverseerMode: "conditional"` (v6.14.2
+ *   — was `always` in v6.14.0/v6.14.1).
  * - When `legacyContinuation` is NOT true (new / standard projects) and
  *   neither field is set, default to `tddCheckpointMode: "per-slice"`,
  *   `integrationOverseerMode: "conditional"`. Also default
@@ -1053,12 +1066,12 @@ async function applyV614DefaultsIfNeeded(projectRoot) {
     const legacyContinuation = obj.legacyContinuation === true;
     if (legacyContinuation) {
         if (!tddCheckpointModeSet) {
-            updates.tddCheckpointMode = "global-red";
-            summary.push("tddCheckpointMode=global-red (legacyContinuation)");
+            updates.tddCheckpointMode = "per-slice";
+            summary.push("tddCheckpointMode=per-slice (legacyContinuation, v6.14.2 default flip)");
         }
         if (!integrationOverseerModeSet) {
-            updates.integrationOverseerMode = "always";
-            summary.push("integrationOverseerMode=always (legacyContinuation)");
+            updates.integrationOverseerMode = "conditional";
+            summary.push("integrationOverseerMode=conditional (legacyContinuation, v6.14.2 default flip)");
         }
     }
     else {
@@ -1085,7 +1098,124 @@ async function applyV614DefaultsIfNeeded(projectRoot) {
     catch {
         return null;
     }
-    return `v6.14.0 stream-style defaults applied: ${summary.join(", ")}. To opt out, edit .cclaw/state/flow-state.json directly or pin the legacy mode (tddCheckpointMode="global-red", integrationOverseerMode="always").`;
+    return `v6.14.2 stream-style defaults applied: ${summary.join(", ")}. To opt out, run cclaw-cli internal set-checkpoint-mode global-red --reason="..." and/or cclaw-cli internal set-integration-overseer-mode always --reason="...".`;
+}
+/**
+ * v6.14.2 — auto-stamp `tddWorktreeCutoverSliceId` for legacyContinuation
+ * projects in worktree-first mode that haven't yet recorded a boundary.
+ *
+ * Detection ("any-metadata" rule): scan the active run's
+ * `slice-implementer` rows. The boundary is the highest `S-N` whose
+ * rows for the active run lack ALL of `claimToken`, `ownerLaneId`, and
+ * `leasedUntil`. When no such slice exists (every slice carries at
+ * least one worktree field), fall back to `tddCutoverSliceId` so the
+ * v6.12 cutover marker still confers exemption.
+ *
+ * Idempotent: when the field is already set, returns null without
+ * writing. Best-effort: read failures, missing ledger, or unparseable
+ * rows all short-circuit silently — the existing flow-state.json is
+ * never corrupted.
+ *
+ * Returns a one-line hint string (or `null` if nothing changed).
+ */
+async function applyV6142WorktreeCutoverIfNeeded(projectRoot) {
+    const flowStatePath = runtimePath(projectRoot, "state", "flow-state.json");
+    let flowStateRaw;
+    try {
+        flowStateRaw = await fs.readFile(flowStatePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(flowStateRaw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const obj = parsed;
+    if (obj.legacyContinuation !== true)
+        return null;
+    if (obj.worktreeExecutionMode !== "worktree-first")
+        return null;
+    if (typeof obj.tddWorktreeCutoverSliceId === "string" &&
+        obj.tddWorktreeCutoverSliceId.trim().length > 0) {
+        return null;
+    }
+    const ledgerPath = runtimePath(projectRoot, "state", "delegation-log.json");
+    const activeRunId = typeof obj.activeRunId === "string" ? obj.activeRunId : "";
+    let ledgerRaw;
+    try {
+        ledgerRaw = await fs.readFile(ledgerPath, "utf8");
+    }
+    catch {
+        ledgerRaw = "";
+    }
+    let ledgerParsed = null;
+    if (ledgerRaw.length > 0) {
+        try {
+            ledgerParsed = JSON.parse(ledgerRaw);
+        }
+        catch {
+            ledgerParsed = null;
+        }
+    }
+    const entries = ledgerParsed &&
+        typeof ledgerParsed === "object" &&
+        !Array.isArray(ledgerParsed) &&
+        Array.isArray(ledgerParsed.entries)
+        ? ledgerParsed.entries
+        : [];
+    let boundary = -1;
+    for (const entry of entries) {
+        if (entry.agent !== "slice-implementer")
+            continue;
+        if (entry.status !== "completed")
+            continue;
+        if (typeof entry.sliceId !== "string")
+            continue;
+        if (activeRunId && entry.runId && entry.runId !== activeRunId)
+            continue;
+        const tok = typeof entry.claimToken === "string" ? entry.claimToken.trim() : "";
+        const lane = typeof entry.ownerLaneId === "string" ? entry.ownerLaneId.trim() : "";
+        const lease = typeof entry.leasedUntil === "string" ? entry.leasedUntil.trim() : "";
+        if (tok.length > 0 || lane.length > 0 || lease.length > 0)
+            continue;
+        const m = /^S-(\d+)$/u.exec(entry.sliceId);
+        if (!m)
+            continue;
+        const n = Number.parseInt(m[1], 10);
+        if (!Number.isFinite(n))
+            continue;
+        if (n > boundary)
+            boundary = n;
+    }
+    let stamped = null;
+    if (boundary >= 0) {
+        stamped = `S-${boundary}`;
+    }
+    else if (typeof obj.tddCutoverSliceId === "string" &&
+        /^S-\d+$/u.test(obj.tddCutoverSliceId)) {
+        stamped = obj.tddCutoverSliceId;
+    }
+    if (!stamped)
+        return null;
+    const merged = { ...obj, tddWorktreeCutoverSliceId: stamped };
+    try {
+        await writeFileSafe(flowStatePath, `${JSON.stringify(merged, null, 2)}\n`, {
+            mode: 0o600
+        });
+    }
+    catch {
+        return null;
+    }
+    return (`v6.14.2 stamped tddWorktreeCutoverSliceId=${stamped}; closed slices ≤ ${stamped} ` +
+        "are exempt from worktree-first findings under legacyContinuation. " +
+        "Edit .cclaw/state/flow-state.json to override (advisory).");
 }
 async function cleanLegacyArtifacts(projectRoot) {
     for (const legacyFolder of DEPRECATED_UTILITY_SKILL_FOLDERS) {
@@ -1266,6 +1396,10 @@ async function materializeRuntime(projectRoot, config, forceStateReset, operatio
             if (v614Hint) {
                 process.stdout.write(`cclaw: ${v614Hint}\n`);
             }
+            const v6142Hint = await applyV6142WorktreeCutoverIfNeeded(projectRoot);
+            if (v6142Hint) {
+                process.stdout.write(`cclaw: ${v6142Hint}\n`);
+            }
         }
         try {
             await ensureRunSystem(projectRoot, { createIfMissing: false });