ruvnet-brain 4.3.37 → 4.3.38

package/plugin/scripts/host-update.mjs

@@ -36,6 +36,51 @@ if (process.argv.includes('--check')) {
 }
 
 const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+
+// --knowledge <attemptFile> <lockFile>: the SessionStart knowledge self-heal worker (launched by
+// session-start-update-plane.mjs under detach.mjs's TTL). Unlike the default mode below it DOES
+// update knowledge: the same argv bin/nightly-refresh.mjs runs, through the same env boundary.
+// Offline (registry unreachable) is recorded as 'offline' so the next session retries in 30 min
+// without reporting a failure. Every other outcome is recorded for the next session to speak.
+const knowledgeAt = process.argv.indexOf('--knowledge');
+if (knowledgeAt >= 0) {
+  const fs = await import('node:fs');
+  const [attemptFile, lockFile] = process.argv.slice(knowledgeAt + 1);
+  const record = (fields) => {
+    try {
+      let prior = {};
+      try { prior = JSON.parse(fs.readFileSync(attemptFile, 'utf8')); } catch { /* first write */ }
+      const tmp = `${attemptFile}.tmp-${process.pid}`;
+      fs.writeFileSync(tmp, `${JSON.stringify({ ...prior, ...fields, finishedAt: new Date().toISOString() })}\n`);
+      fs.renameSync(tmp, attemptFile);
+    } catch { /* the next session reports a launch with no outcome as a failure */ }
+  };
+  try {
+    const probe = process.env.RUVNET_AUTO_UPDATE_PROBE_URL || 'https://registry.npmjs.org/ruvnet-brain/latest';
+    let online = false;
+    try { online = (await fetch(probe, { signal: AbortSignal.timeout(5_000) })).ok; } catch { /* offline */ }
+    if (!online) {
+      record({ outcome: 'offline', code: null, reason: `registry unreachable (${probe})` });
+    } else {
+      const run = spawnSync(npx, ['--yes', 'ruvnet-brain@latest', '--update', '--no-nightly-prompt'], {
+        env: childEnvironment(), encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
+        timeout: Number(process.env.RUVNET_KNOWLEDGE_UPDATE_TIMEOUT_MS || 25 * 60_000),
+      });
+      process.stdout.write(run.stdout || '');
+      process.stderr.write(run.stderr || '');
+      // eslint-disable-next-line no-control-regex
+      const tail = `${run.stderr || ''}\n${run.stdout || ''}`.replace(/\u001b\[[0-9;]*m/g, '')
+        .split('\n').map((line) => line.trim()).filter(Boolean);
+      const code = run.error ? null : run.status;
+      record({ outcome: code === 0 ? 'succeeded' : 'failed', code,
+        reason: code === 0 ? '' : String(run.error?.message || tail.find((l) => /✗|error|fail/i.test(l)) || tail.at(-1) || 'no output').slice(0, 200) });
+    }
+  } finally {
+    try { fs.rmSync(lockFile, { force: true }); } catch { /* stale-lock rule reclaims it */ }
+  }
+  process.exit(0);
+}
+
 const result = spawnSync(npx, [
   '--yes',
   'ruvnet-brain@latest',

package/plugin/scripts/nightly-scheduler.mjs

@@ -272,6 +272,40 @@ export function refreshRunHealth({ brainHome, identity = NIGHTLY_LABEL, now = Da
     evidence: `Last nightly refresh ${receipt.terminalVerdict} ${ageHours.toFixed(1)}h ago; envelope verified.`, receipt };
 }
 
+/**
+ * Every refresh receipt (nightly AND manual --update), newest first, reduced to what a user needs
+ * to know: the newest run, the newest SUCCESS (envelope-verified, the same validator the proof
+ * uses), and how many runs failed since that success. Read-only, no spawn. An unreadable receipt
+ * is counted, never skipped silently.
+ */
+export function refreshHistory({ brainHome }) {
+  let names = [];
+  try { names = fs.readdirSync(path.join(brainHome, 'refresh-runs')).filter((n) => n.endsWith('.json')); }
+  catch { return { receipts: 0, unreadable: 0, latest: null, lastSuccess: null, failuresSinceSuccess: 0 }; }
+  const rows = [];
+  let unreadable = 0;
+  for (const name of names) {
+    try {
+      const r = JSON.parse(fs.readFileSync(path.join(brainHome, 'refresh-runs', name), 'utf8'));
+      const at = Date.parse(r?.finishedAt || r?.startedAt || '');
+      if (r?.kind === 'ruvnet-brain-refresh-run' && Number.isFinite(at)) rows.push({ at, receipt: r });
+      else unreadable += 1;
+    } catch { unreadable += 1; }
+  }
+  rows.sort((a, b) => b.at - a.at);
+  const successIndex = rows.findIndex(({ receipt }) => validateRefreshReceiptEnvelope(receipt).ok);
+  const sinceSuccess = successIndex < 0 ? rows : rows.slice(0, successIndex);
+  return { receipts: rows.length, unreadable, latest: rows[0] || null,
+    lastSuccess: successIndex < 0 ? null : rows[successIndex],
+    failuresSinceSuccess: sinceSuccess.filter(({ receipt }) => receipt.status === 'FAILED').length };
+}
+
+/** agentic-kit owns this machine's Brain updates (`ak sync`), so the Brain's own scheduler is off on purpose. */
+export function updateOwnedByAgenticKit(home = os.homedir()) {
+  try { return JSON.parse(fs.readFileSync(path.join(home, '.config', 'agentic-kit', 'kit.json'), 'utf8')).ruvnetBrain === true; }
+  catch { return false; }
+}
+
 export function nightlyCommand(record) {
   return `${shellQuote(record.nodePath)} ${shellQuote(record.runnerPath)} --registration ${shellQuote(record.recordPath)}`;
 }

package/plugin/scripts/session-start-budget.mjs

@@ -42,6 +42,7 @@ export const STAGE_BUDGETS_MS = {
   'issue-pointer': 1100,
   'signal-surface': 400,  // bounded CI-signal transition poll (see session-start-signals.mjs)
   'router-nudge': 50,     // one fs.existsSync + at-most-one-time write
+  'knowledge-currency': 100, // refresh receipts + registration + SOURCE.json reads; no spawn, no network
   'stable-spine': 300,    // seed-dispatch decision + a single detach launch
   heartbeat: 300,         // update-check dispatch launch
   'ascii-drift': 300,     // optional ascii->svg drift advisory, already spawnSync-timeout bounded

package/plugin/scripts/session-start-core.mjs

@@ -32,8 +32,8 @@ import {
 } from './session-start-fsutil.mjs';
 import { maintainerIssueEntitlement, surfaceIssuePointer } from './session-start-issue-alert.mjs';
 import { surfaceSignals } from './session-start-signals.mjs';
-import { brainState, health, mcpReadiness } from './session-start-health.mjs';
-import { stableSpine, heartbeat } from './session-start-update-plane.mjs';
+import { brainState, health, knowledgeCurrency, mcpReadiness, KNOWLEDGE_LINE_PREFIX } from './session-start-health.mjs';
+import { stableSpine, heartbeat, knowledgeAutoUpdate } from './session-start-update-plane.mjs';
 import { describeLifecycleHooks, readHookContracts } from './session-start-hook-description.mjs';
 import { createStageTracer } from './session-start-trace.mjs';
 
@@ -79,6 +79,7 @@ export async function runSessionStart({
       || s.startsWith('[RuvNet Brain — HEALTH ALARM')
       || s.startsWith('[RuvNet Brain — INSTALL ALARM')
       || s.startsWith('[RuvNet Brain — NIGHTLY FAILED')
+      || s.startsWith(KNOWLEDGE_LINE_PREFIX)
       || s.startsWith('[RuvNet Brain — OPEN ISSUES')
       || /\bopen issue\(s\)/i.test(s)
       || /^\[RuvNet Brain — external signal/i.test(s)
@@ -206,6 +207,18 @@ export async function runSessionStart({
       return result;
     }) || { problem: '', absentByChoice: false };
 
+    // ONE line when the installed knowledge cannot be PROVEN current (old, failing, or UNKNOWN);
+    // silent when a refresh or --check proved it inside 48h. Skipped when the brain is off (a choice)
+    // or already down (the HEALTH ALARM above owns that).
+    // Knowledge self-heal first (a detached, throttled --update when nothing proves currency inside
+    // 24h), so the line below already says an update is running.
+    tracer.stage('knowledge-currency', () => {
+      if (brain.off || state.problem) return;
+      knowledgeAutoUpdate({ env, home, now, hookDir, emit });
+      const line = knowledgeCurrency({ env, home, now });
+      if (line) emit(line);
+    });
+
     tracer.stage('misc', () => {
       const consoleOffered = path.join(stateDir, '.console-offered');
       const firstSession = !brain.off && !exists(consoleOffered);

package/plugin/scripts/session-start-health.mjs

@@ -10,7 +10,10 @@
 // worded for the user — never gated behind the maintainer entitlement file.
 import fs from 'node:fs';
 import path from 'node:path';
-import { json, exists, mtimeMs } from './session-start-fsutil.mjs';
+import { json, exists, mtimeMs, read } from './session-start-fsutil.mjs';
+import {
+  describeFailedRefreshRun, readNightlyRegistration, refreshHistory, updateOwnedByAgenticKit,
+} from './nightly-scheduler.mjs';
 
 export const brainState = (env, home) => {
   const stateDir = env.RUVNET_BRAIN_STATE_DIR || path.join(home, '.config', 'ruvnet-brain');
@@ -49,6 +52,103 @@ export const health = (home, off) => {
   return { problem: '', absentByChoice };
 };
 
+/**
+ * KNOWLEDGE CURRENCY — "never silent for 40 days" (owner, 2026-09-30). The installed knowledge base
+ * on the owner's Mac was 35 days old with the nightly refresh failing 22/22 times, and the only
+ * trace was a "Corpus snapshot ages" footnote inside search output. This returns ONE plain line, or
+ * '' when currency is PROVEN. Reuses the existing readers only: refresh receipts
+ * (nightly-scheduler.mjs refreshHistory + describeFailedRefreshRun), the scheduler registration
+ * (readNightlyRegistration), agentic-kit ownership, SOURCE.json builtUtc, and the heartbeat's
+ * recorded --check verdict. Currency is PROVEN only by a successful refresh or a CURRENT verdict
+ * inside 48h; anything unreadable stays UNKNOWN in the words, never "current".
+ */
+export const KNOWLEDGE_LINE_PREFIX = '[RuvNet Brain — KNOWLEDGE ';
+
+// The SessionStart knowledge auto-update's own per-machine state (session-start-update-plane.mjs
+// writes it, host-update.mjs --knowledge records the outcome). Deliberately NOT inside refresh-runs/:
+// kb/lifecycle-evidence-retention.mjs scanRefresh() marks any non-receipt entry there "unsafe" and
+// then refuses to prune, so a sidecar file would silently stop receipt retention.
+export const autoUpdatePaths = (brainHome) => ({
+  attemptFile: path.join(brainHome, 'auto-update.json'),
+  lockFile: path.join(brainHome, 'auto-update.lock'),
+  logFile: path.join(brainHome, '.last-auto-update-knowledge.log'),
+});
+export const AUTO_UPDATE_LOCK_STALE_MS = 35 * 60_000; // detach TTL (30 min) + slack
+
+/** The inputs every currency decision reads — one reader, shared by the line and the auto-update. */
+export const knowledgeFacts = ({ env = process.env, home, now = Date.now() } = {}) => {
+  const brainHome = env.RUVNET_BRAIN_HOME || path.join(home, '.cache', 'ruvnet-brain');
+  const kbDir = env.RUVNET_BRAIN_KB || path.join(brainHome, 'kb');
+  const hours = (ms) => (now - ms) / 3_600_000;
+  const source = json(path.join(kbDir, 'SOURCE.json'));
+  const builtMs = Date.parse(source?.builtUtc || source?.generatedAt || '');
+  const history = refreshHistory({ brainHome });
+  const check = json(path.join(brainHome, '.last-kb-check-result.json'));
+  const checkMs = Date.parse(check?.recordedAt || '');
+  const auto = autoUpdatePaths(brainHome);
+  const provenWithin = (h) => Boolean((history.lastSuccess && hours(history.lastSuccess.at) <= h)
+    || (check?.currencyVerdict === 'CURRENT' && Number.isFinite(checkMs) && hours(checkMs) <= h));
+  return { brainHome, kbDir, source, builtMs, history, hours, provenWithin, auto,
+    attempt: json(auto.attemptFile),
+    lockMs: Date.parse(json(auto.lockFile)?.at || '') || mtimeMs(auto.lockFile) };
+};
+
+/** Why the SessionStart knowledge auto-update may NEVER run on this machine ('' = it may). */
+export const autoUpdateOptOut = ({ env = process.env, home, facts }) => {
+  const flag = String(env.RUVNET_AUTO_UPDATE || '').toLowerCase();
+  if (flag === 'off') return 'RUVNET_AUTO_UPDATE=off';
+  if (env.RUVNET_BRAIN_TEST === '1' && flag !== 'on') return 'test mode';
+  if (read(path.join(facts.brainHome, '.auto-update-pref')).trim() === 'no') return 'you answered no to background auto-update';
+  if (updateOwnedByAgenticKit(home)) return 'agentic-kit owns updates: ak sync';
+  if (!exists(path.join(facts.kbDir, 'forge-update.mjs'))) return 'this install predates the self-updater';
+  return '';
+};
+
+export const knowledgeCurrency = ({ env = process.env, home, now = Date.now(), windowHours = 48 } = {}) => {
+  const facts = knowledgeFacts({ env, home, now });
+  const { brainHome, builtMs, history, hours, attempt } = facts;
+  const day = (ms) => new Date(ms).toISOString().slice(0, 16).replace('T', ' ') + 'Z';
+  const age = (ms) => { const h = hours(ms); return h < 48 ? `${Math.round(h)}h ago` : `${Math.round(h / 24)}d ago`; };
+  const proven = facts.provenWithin(windowHours);
+  const latest = history.latest?.receipt;
+  // An automatic update that ended without a refresh receipt of its own (npx could not fetch the
+  // package, the lock was held, it was killed at its TTL) is a failure the receipts cannot show.
+  const launchedMs = Date.parse(attempt?.launchedAt || '');
+  const autoRunning = facts.lockMs > 0 && now - facts.lockMs < AUTO_UPDATE_LOCK_STALE_MS;
+  const autoAbandoned = attempt?.outcome === 'launched' && !autoRunning;
+  const autoFailed = Number.isFinite(launchedMs) && (attempt.outcome === 'failed' || autoAbandoned)
+    && !(history.latest && history.latest.at >= launchedMs);
+  const failing = latest?.status === 'FAILED' || autoFailed;
+  const ageKnown = Number.isFinite(builtMs);
+  if (!failing && proven) return '';
+  if (!failing && ageKnown && hours(builtMs) <= windowHours) return '';
+  const agentKit = updateOwnedByAgenticKit(home);
+  const scheduled = agentKit || readNightlyRegistration({ brainHome }).ok;
+  const parts = [ageKnown ? `knowledge base built ${day(builtMs)} (${age(builtMs)})`
+    : 'knowledge base age UNKNOWN (SOURCE.json missing or unreadable)'];
+  if (autoFailed) {
+    const why = autoAbandoned ? 'it never recorded an outcome (killed at its 30-minute limit, or the machine slept)'
+      : `exit ${attempt.code ?? 'unknown'}: ${attempt.reason || 'no reason recorded'}`;
+    parts.push(`automatic update launched ${age(launchedMs)} FAILED — ${why}`);
+  } else if (latest?.status === 'FAILED') {
+    const why = describeFailedRefreshRun(latest) || 'failed';
+    parts.push(`last refresh (${latest.action || 'unknown'}) FAILED ${age(history.latest.at)}: ${why}`);
+  }
+  if (autoRunning) parts.push(`an automatic update is running now (started ${age(facts.lockMs)})`);
+  parts.push(history.receipts
+    ? `${history.failuresSinceSuccess} failed run(s) since the last success (${history.lastSuccess ? day(history.lastSuccess.at) : 'none recorded'})`
+    : 'no refresh has ever run on this machine');
+  if (!scheduled) parts.push('no nightly refresh is scheduled');
+  if (history.unreadable) parts.push(`${history.unreadable} unreadable receipt(s)`);
+  const fix = agentKit ? 'ak sync' : scheduled ? 'npx ruvnet-brain@latest --update'
+    : 'npx ruvnet-brain@latest --update && npx ruvnet-brain --enable-nightly';
+  const optOut = autoUpdateOptOut({ env, home, facts });
+  if (optOut) parts.push(`automatic update is off (${optOut})`);
+  else if (!autoRunning) parts.push('SessionStart retries the update automatically at most every 6h');
+  const head = failing ? 'UPDATE FAILING' : ageKnown ? 'STALE' : 'CURRENCY UNKNOWN';
+  return `${KNOWLEDGE_LINE_PREFIX}${head}] ${parts.join('; ')}. Fix: ${fix} (verify: npx ruvnet-brain --doctor).`;
+};
+
 export const mcpReadiness = (env, home) => {
   const brainHome = env.RUVNET_BRAIN_HOME || path.join(home, '.cache', 'ruvnet-brain');
   const receipt = json(path.join(brainHome, 'mcp-readiness.json'));

package/plugin/scripts/session-start-update-plane.mjs

@@ -4,8 +4,78 @@
 // 500 lines. `announceVersion` was intentionally NOT migrated here: it was dead code (defined, never
 // called, never tested) and was deleted rather than relocated — moving unused code to a new module
 // would still be scope creep, just in a different file.
+import fs from 'node:fs';
 import path from 'node:path';
-import { read, write, exists, json, firstVersion, dispatchDetached } from './session-start-fsutil.mjs';
+import { spawn } from 'node:child_process';
+import { read, write, exists, json, firstVersion, dispatchDetached, mtimeMs } from './session-start-fsutil.mjs';
+import { KNOWLEDGE_LINE_PREFIX, AUTO_UPDATE_LOCK_STALE_MS, autoUpdateOptOut, knowledgeFacts } from './session-start-health.mjs';
+
+/**
+ * KNOWLEDGE SELF-HEAL (owner invariant 2026-09-30: no brain may ever be more than 48h old). The
+ * nightly scheduler is opt-in and can silently never register, so this does not depend on it: when
+ * a session starts and nothing proves the knowledge current inside 24h, launch ONE detached, bounded
+ * `npx ruvnet-brain@latest --update --no-nightly-prompt` (the exact argv bin/nightly-refresh.mjs
+ * runs) through the existing host-update.mjs credential boundary and detach.mjs TTL supervisor.
+ * Per machine (all state under brainHome), at most one launch per 6h (30 min after an offline
+ * probe), never while a refresh lock or another launch is live, never blocks (spawn + unref, no
+ * wait). The outcome is recorded by the worker and spoken by the NEXT session's knowledge line.
+ */
+export const AUTO_UPDATE_POLICY = Object.freeze({ staleHours: 24, retryHours: 6, offlineRetryMinutes: 30, ttlSec: 1800 });
+
+const writeJsonAtomic = (file, value) => {
+  const tmp = `${file}.tmp-${process.pid}`;
+  try { fs.writeFileSync(tmp, `${JSON.stringify(value)}\n`); fs.renameSync(tmp, file); return true; }
+  catch { try { fs.rmSync(tmp, { force: true }); } catch { /* ignore */ } return false; }
+};
+
+export const knowledgeAutoUpdate = ({ env, home, now, hookDir, emit = () => {}, spawnFn = spawn }) => {
+  const facts = knowledgeFacts({ env, home, now });
+  const { attemptFile, lockFile, logFile } = facts.auto;
+  const attempt = facts.attempt;
+  const hoursAgo = (iso) => (now - Date.parse(iso || '')) / 3_600_000;
+  if (attempt?.outcome === 'succeeded' && !attempt.reported) {
+    const built = facts.builtMs;
+    const tag = facts.source?.releaseTag ? `corpus ${facts.source.releaseTag}` : 'the latest corpus';
+    emit(`${KNOWLEDGE_LINE_PREFIX}UPDATED] automatic update finished ${Math.round(hoursAgo(attempt.finishedAt))}h ago: ${tag}, `
+      + `knowledge base built ${Number.isFinite(built) ? `${Math.round(facts.hours(built))}h ago` : 'at an UNKNOWN time'}.`);
+    writeJsonAtomic(attemptFile, { ...attempt, reported: true });
+  }
+  const optOut = autoUpdateOptOut({ env, home, facts });
+  if (optOut) return { launched: false, why: optOut };
+  const fresh = facts.provenWithin(AUTO_UPDATE_POLICY.staleHours)
+    || (Number.isFinite(facts.builtMs) && facts.hours(facts.builtMs) <= AUTO_UPDATE_POLICY.staleHours);
+  if (fresh) return { launched: false, why: 'fresh' };
+  // A nightly or manual --update holds this lock (kb/refresh-run.mjs refreshLockPath, duplicated here
+  // because the plugin payload cannot import kb/); --update would refuse anyway, this saves the launch.
+  if (exists(path.join(path.dirname(facts.kbDir), `.${path.basename(facts.kbDir)}.refresh-run.lock`))) {
+    return { launched: false, why: 'refresh running' };
+  }
+  const since = hoursAgo(attempt?.launchedAt);
+  const retryHours = attempt?.outcome === 'offline' ? AUTO_UPDATE_POLICY.offlineRetryMinutes / 60 : AUTO_UPDATE_POLICY.retryHours;
+  if (since >= 0 && since < retryHours) return { launched: false, why: 'throttled' };
+  // Cross-process: exactly one session wins the O_EXCL create; a lock older than the TTL is stale.
+  const claim = () => { try { fs.writeFileSync(lockFile, `${JSON.stringify({ pid: process.pid, at: new Date(now).toISOString() })}\n`, { flag: 'wx' }); return true; } catch { return false; } };
+  if (!claim()) {
+    const lockMs = Date.parse(json(lockFile)?.at || '') || mtimeMs(lockFile);
+    if (!(lockMs > 0 && now - lockMs > AUTO_UPDATE_LOCK_STALE_MS)) return { launched: false, why: 'locked' };
+    try { fs.rmSync(lockFile, { force: true }); } catch { /* raced */ }
+    if (!claim()) return { launched: false, why: 'locked' };
+  }
+  writeJsonAtomic(attemptFile, { schemaVersion: 1, launchedAt: new Date(now).toISOString(), outcome: 'launched' });
+  try {
+    const child = spawnFn(process.execPath, [path.join(hookDir, 'detach.mjs'), String(AUTO_UPDATE_POLICY.ttlSec), logFile,
+      process.execPath, path.join(hookDir, 'host-update.mjs'), '--knowledge', attemptFile, lockFile],
+    { detached: true, stdio: 'ignore', env, windowsHide: true });
+    child.on?.('error', () => {});
+    child.unref?.();
+  } catch (error) {
+    writeJsonAtomic(attemptFile, { schemaVersion: 1, launchedAt: new Date(now).toISOString(), outcome: 'failed',
+      code: null, reason: `could not launch: ${error.message}`, finishedAt: new Date(now).toISOString() });
+    try { fs.rmSync(lockFile, { force: true }); } catch { /* ignore */ }
+    return { launched: false, why: 'launch failed' };
+  }
+  return { launched: true, why: 'stale' };
+};
 
 export const compareVersions = (a, b) => {
   const left = String(a).split(/[.-]/).map((part) => (/^\d+$/.test(part) ? Number(part) : part));

package/scripts/completion-claim-replay.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * completion-claim-replay.mjs — measure the completion-claim gate and promise capture against REAL
+ * Claude Code transcripts, read-only (ADR-074 acceptance #5: "Measure Stop latency and false-positive
+ * rate").
+ *
+ * It replays every turn of every top-level `*.jsonl` under the transcript root through the SAME pure
+ * functions continuation-gate.mjs calls at Stop (plugin/scripts/completion-claim-evidence.mjs), and
+ * reports how often the gate would ARM (a completion claim is present), BLOCK (FAIL verdict) and
+ * capture a PROMISE. It never writes into the transcript root; `--out` writes a JSONL sample of
+ * blocks and promises for a human to label true/false by eye.
+ *
+ *   node scripts/completion-claim-replay.mjs [--root ~/.claude/projects] [--limit 40] [--out file.jsonl]
+ *
+ * Turn = records from one genuine user message to the next; the turn's final assistant text stands
+ * in for the Stop payload's `last_assistant_message`. That approximation is disclosed in the report.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { auditCompletionClaims, claudeTurnEvents, extractCommitments } from '../plugin/scripts/completion-claim-evidence.mjs';
+
+const argv = process.argv.slice(2);
+const opt = (flag, fallback) => { const i = argv.indexOf(flag); return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback; };
+
+// The transcript walkers below are exported for scripts/grounding-turn-replay.mjs (one turn model,
+// two gates); main() runs only when this file is the entrypoint.
+const textOf = (c) => (typeof c === 'string' ? c : Array.isArray(c)
+  ? c.filter((x) => x?.type === 'text' && typeof x.text === 'string').map((x) => x.text).join('\n') : '');
+
+export function transcripts(root, limit) {
+  const files = [];
+  for (const dir of fs.readdirSync(root)) {
+    const full = path.join(root, dir);
+    try {
+      for (const name of fs.readdirSync(full)) {
+        if (!name.endsWith('.jsonl')) continue;
+        const file = path.join(full, name);
+        const st = fs.statSync(file);
+        if (st.isFile() && st.size > 20_000) files.push({ file, mtime: st.mtimeMs });
+      }
+    } catch { /* not a directory */ }
+  }
+  return files.sort((a, b) => b.mtime - a.mtime).slice(0, limit).map((f) => f.file);
+}
+
+export function turnsOf(lines) {
+  const starts = [];
+  lines.forEach((l, i) => {
+    try {
+      const o = JSON.parse(l);
+      const c = o?.message?.content;
+      const toolResult = Array.isArray(c) && c.some((x) => x?.type === 'tool_result');
+      if (o?.type === 'user' && !o.isSidechain && !o.isMeta && !toolResult && textOf(c).trim()) starts.push(i);
+    } catch { /* torn */ }
+  });
+  return starts.map((s, k) => lines.slice(s, starts[k + 1] ?? lines.length));
+}
+
+export function finalText(turnLines) {
+  for (let i = turnLines.length - 1; i >= 0; i -= 1) {
+    try {
+      const o = JSON.parse(turnLines[i]);
+      if (o?.type === 'assistant' && !o.isSidechain) { const t = textOf(o.message?.content).trim(); if (t) return t; }
+    } catch { /* torn */ }
+  }
+  return '';
+}
+
+function main() {
+  const root = path.resolve(opt('--root', path.join(os.homedir(), '.claude', 'projects')));
+  const limit = Number(opt('--limit', '40'));
+  const out = opt('--out', null);
+  const report = { root, transcripts: 0, turns: 0, armed: 0, blocked: 0, passed: 0, promises: 0, turnsWithPromise: 0,
+    reasons: {}, auditMs: [] };
+  const samples = [];
+  for (const file of transcripts(root, limit)) {
+    report.transcripts += 1;
+    const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
+    for (const turnLines of turnsOf(lines)) {
+      const message = finalText(turnLines);
+      if (!message) continue;
+      report.turns += 1;
+      const t0 = performance.now();
+      const audit = auditCompletionClaims(message, { turn: claudeTurnEvents(turnLines) });
+      report.auditMs.push(performance.now() - t0);
+      const promises = extractCommitments(message);
+      if (promises.length) { report.turnsWithPromise += 1; report.promises += promises.length; }
+      if (audit.verdict !== 'NONE') report.armed += 1;
+      if (audit.verdict === 'PASS') report.passed += 1;
+      if (audit.verdict === 'FAIL') {
+        report.blocked += 1;
+        for (const p of audit.problems) { const k = p.replace(/\(.*\)/, '').trim(); report.reasons[k] = (report.reasons[k] || 0) + 1; }
+      }
+      if (audit.verdict === 'FAIL' || promises.length) {
+        samples.push({ file: path.basename(file), verdict: audit.verdict, claims: audit.claims.map((c) => c.text),
+          problems: audit.problems, promises: promises.map((p) => p.text), tail: message.slice(-700) });
+      }
+    }
+  }
+  const ms = report.auditMs.sort((a, b) => a - b);
+  const summary = { ...report, auditMs: undefined,
+    armRate: report.turns ? +(report.armed / report.turns).toFixed(3) : 0,
+    blockRate: report.turns ? +(report.blocked / report.turns).toFixed(3) : 0,
+    promiseTurnRate: report.turns ? +(report.turnsWithPromise / report.turns).toFixed(3) : 0,
+    auditP50Ms: +(ms[Math.floor(ms.length / 2)] || 0).toFixed(2), auditP99Ms: +(ms[Math.floor(ms.length * 0.99)] || 0).toFixed(2),
+    approximation: 'final assistant text of each turn stands in for last_assistant_message' };
+  if (out) fs.writeFileSync(out, samples.map((s) => JSON.stringify(s)).join('\n') + '\n');
+  console.log(JSON.stringify(summary, null, 2));
+}
+
+const isMain = (() => { try { return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url)); } catch { return false; } })();
+if (isMain) main();