ruvnet-brain 4.7.20 → 4.7.22

package/scripts/learning-replay-cli.mjs

@@ -40,13 +40,17 @@ import { GPT_5_6_SOL_ID } from './review-model-defaults.mjs';
 const usage = () => `Usage:
   node scripts/learning-replay.mjs [--trap ${TRAP.MEMORY_SEARCH}|${TRAP.POST_TASK}] [--n N] [--host codex|claude-code] [--model MODEL]
   node scripts/learning-replay.mjs --check
-  node scripts/learning-replay.mjs --check-portfolio
+  node scripts/learning-replay.mjs --check-portfolio [--tolerate-stale]
   node scripts/learning-replay.mjs --measure-portfolio --host codex --model MODEL
   node scripts/learning-replay.mjs --check-mutants
+  node scripts/learning-replay.mjs --check-wire      (token-free; needs the global ruflo)
   node scripts/learning-replay.mjs --dry-run
   node scripts/learning-replay.mjs --mutant <${Object.keys(MUTANTS).join('|')}>
 
-Exit: 0=PASS, 1=FAIL, 3=INCONCLUSIVE, 4=UNKNOWN.`;
+Exit: 0=PASS, 1=FAIL, 3=INCONCLUSIVE, 4=UNKNOWN. --tolerate-stale exits 0 for an UNKNOWN caused only by
+out-of-date evidence (load-bearing files changed since it was measured, or past the age limit) and prints
+STALE-TOLERATED, and only when every trap and mutant artifact still verifies and recomputes to its expected
+result; every FAIL, INCONCLUSIVE and other UNKNOWN in any artifact keeps its exit code.`;
 
 function parse(argv) {
   const has = (flag) => argv.includes(flag);
@@ -57,29 +61,85 @@ function parse(argv) {
   return { has, arg };
 }
 
-function wireProbe(dirs, spec, stateDir) {
-  const result = spawnSync(process.execPath, [
-    path.join(ROOT, 'plugin', 'scripts', 'hook-shim.mjs'),
-    'unprompted-speech', 'UserPromptSubmit',
-  ], {
+// Fire project B's prompt hook exactly as each host registers it: Claude through hook-shim.mjs
+// (plugin/hooks/hooks.json), Codex through the Brain home's stable codex-hook.mjs wrapper. The user's
+// nudge setting and the runtime's test seams are pinned to the DEFAULT install, so an ambient
+// RUVNET_STOP_NUDGES=full on the measuring machine can never hide a regression that every user has.
+export function wireOutput(dirs, spec, stateDir, host = 'claude-code') {
+  const argv = host === 'codex'
+    ? [path.join(dirs.brainHome, 'codex-hook.mjs'), 'unprompted-speech', 'UserPromptSubmit']
+    : [path.join(ROOT, 'plugin', 'scripts', 'hook-shim.mjs'), 'unprompted-speech', 'UserPromptSubmit'];
+  const env = {
+    ...process.env,
+    RUVNET_BRAIN_HOME: dirs.brainHome,
+    RUVNET_BRAIN_STATE_DIR: stateDir,
+    RUVNET_CONFIG_ROOT: path.join(dirs.base, 'config'),
+    RUVNET_LESSON_STORE: dirs.lessons,
+    RUVNET_LESSON_GATE_STATE: dirs.gateState,
+    CLAUDE_PLUGIN_ROOT: path.join(ROOT, 'plugin'),
+    RUVNET_STOP_NUDGES: '',
+  };
+  for (const seam of ['RUVNET_UNPROMPTED_CHANNELS', 'RUVNET_UNPROMPTED_PRODUCERS', 'RUVNET_REPLAY_SEQUENCE_FILE']) delete env[seam];
+  const result = spawnSync(process.execPath, argv, {
     input: JSON.stringify({
+      hook_event_name: 'UserPromptSubmit',
       prompt: spec.prompt,
-      session_id: `dry-${Date.now()}`,
+      session_id: `wire-${Date.now()}`,
       cwd: dirs.projectB,
     }),
     encoding: 'utf8',
     cwd: dirs.projectB,
-    env: {
-      ...process.env,
-      RUVNET_BRAIN_HOME: dirs.brainHome,
-      RUVNET_BRAIN_STATE_DIR: stateDir,
-      RUVNET_CONFIG_ROOT: path.join(dirs.base, 'config'),
-      RUVNET_LESSON_STORE: dirs.lessons,
-      RUVNET_LESSON_GATE_STATE: dirs.gateState,
-      CLAUDE_PLUGIN_ROOT: path.join(ROOT, 'plugin'),
-    },
+    timeout: 60_000,
+    env,
   });
-  return (result.stdout || '').length;
+  return result.stdout || '';
+}
+
+const wireProbe = (dirs, spec, stateDir) => wireOutput(dirs, spec, stateDir).length;
+
+// THE TOKEN-FREE HALF OF D4, measured on every schedule. No model is called, so this does NOT prove a
+// model changed its behaviour (that is --check-portfolio, priced in tokens). It proves the brain's half
+// of the loop on the current code with the real global ruflo: a lesson recorded independently in two
+// projects is promoted, survives a refresh, and reaches project B's prompt on BOTH hosts — while the
+// brain-off control never receives it and deleting the lesson removes it (the causal mutant).
+export function checkWire({ fire = wireOutput, premise = verifyRufloFlag, hosts = ['claude-code', 'codex'] } = {}) {
+  const ruflo = premise();
+  if (!ruflo.ok) return { status: VERDICT.UNKNOWN, why: `ruflo premise not verified: ${ruflo.why}` };
+  const checked = [];
+  for (const trap of [TRAP.MEMORY_SEARCH, TRAP.POST_TASK]) {
+    const spec = trapSpec(trap);
+    const probe = spec.lesson.slice(0, 60);
+    const base = allocateRunBase();
+    const dirs = buildFixtures(base);
+    try {
+      const record = recordInProjectA(dirs, { trap });
+      if (!record.sources.every((source) => source.recorded)) {
+        return { status: VERDICT.UNKNOWN, why: `${trap}: ruflo could not record the lesson in project A`, checked };
+      }
+      if (!record.ok || !record.promoted) return { status: VERDICT.FAIL, why: `${trap}: lesson was not promoted across two projects`, checked };
+      const refresh = nightlyRefresh(dirs);
+      if (!refresh.lessonSurvived) return { status: VERDICT.FAIL, why: `${trap}: lesson did not survive refresh`, checked };
+      for (const host of hosts) {
+        if (fire(dirs, spec, dirs.stateOff, host).includes(probe)) {
+          return { status: VERDICT.INCONCLUSIVE, why: `${trap}/${host}: the brain-off control also received the lesson`, checked };
+        }
+        if (!fire(dirs, spec, dirs.stateOn, host).includes(probe)) {
+          return { status: VERDICT.FAIL, why: `${trap}/${host}: the promoted lesson did not reach project B's prompt`, checked };
+        }
+      }
+      saveLessons([], dirs.lessons);
+      for (const host of hosts) {
+        if (fire(dirs, spec, dirs.stateOn, host).includes(probe)) {
+          return { status: VERDICT.FAIL, why: `${trap}/${host}: delete-lesson mutant still delivered it — delivery is not caused by the lesson`, checked };
+        }
+      }
+      checked.push(trap);
+    } finally {
+      cleanupFixtureDaemons(dirs);
+      removeFixture(base);
+    }
+  }
+  return { status: VERDICT.PASS, why: `both lessons reached project B on ${hosts.join(' and ')}; control and delete-lesson mutant stayed silent`, checked };
 }
 
 function printed(label, result) {
@@ -87,6 +147,23 @@ function printed(label, result) {
   return EXIT[result.status] ?? EXIT.UNKNOWN;
 }
 
+// The scheduled workflow reports out-of-date model evidence without paging on it (nothing scheduled can
+// re-measure it); a recomputed FAIL, a forged or missing artifact, or any other UNKNOWN stays non-zero.
+// The strict check stops at the first stale artifact, so tolerance re-checks the WHOLE portfolio (both traps
+// and all four mutants, every transcript verified and recomputed) with only staleness waived, and softens
+// nothing unless that passes: staleness never hides a defect behind it (Codex 4.7.21 r4 #2, Opus r2 #3).
+function portfolioExit(result, tolerateStale) {
+  if (!tolerateStale || result.status !== VERDICT.UNKNOWN || result.stale !== true) {
+    return printed(`${INVARIANT}-PORTFOLIO`, result);
+  }
+  const waived = checkPortfolio({ tolerateStale: true });
+  if (waived.status !== VERDICT.PASS) return printed(`${INVARIANT}-PORTFOLIO`, waived);
+  printed(`${INVARIANT}-PORTFOLIO`, result);
+  console.log('  STALE-TOLERATED: every artifact verified and recomputed, but the committed model evidence predates'
+    + ' the current code; re-measure to restore a verdict.\n');
+  return EXIT.PASS;
+}
+
 // A portfolio includes both positive traps AND all four causal mutants. Run every scenario even
 // after a failure, then let the unchanged evidence checker decide the result; child exit 1 is the
 // expected outcome of a causal mutant, and is never by itself a successful portfolio measurement.
@@ -125,8 +202,9 @@ export async function main(argv = process.argv.slice(2)) {
   if (has('--check')) {
     return printed(INVARIANT, checkArtifact({ file: PORTFOLIO_RESULT_FILES[trap] }));
   }
-  if (has('--check-portfolio')) return printed(`${INVARIANT}-PORTFOLIO`, checkPortfolio());
+  if (has('--check-portfolio')) return portfolioExit(checkPortfolio(), has('--tolerate-stale'));
   if (has('--check-mutants')) return printed(`${INVARIANT}-MUTANTS`, checkMutantArtifacts());
+  if (has('--check-wire')) return printed(`${INVARIANT}-WIRE`, checkWire());
   if (has('--measure-portfolio')) return measurePortfolio({ host, model });
 
   const source = checkSourceIdentity();

package/scripts/learning-replay-execution.mjs

@@ -151,6 +151,8 @@ export function verifyRufloFlag(bin = RUFLO_BIN) {
   const result = spawnSync(bin, ['memory', 'search', '--help'], {
     encoding: 'utf8',
     timeout: 30_000,
+    cwd: os.tmpdir(), // ruflo writes .claude-flow/ into its cwd; never the checkout
+
     env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' },
   });
   const output = `${result.stdout || ''}${result.stderr || ''}`;

package/scripts/learning-replay-fixture.mjs

@@ -31,6 +31,9 @@ const sh = (cmd, args, options = {}) => {
   return spawnSync(binary, argv, {
     encoding: 'utf8',
     timeout: 120_000,
+    // Never the checkout: ruflo writes `.claude-flow/` and `agentdb.rvf.idmap.json` into its cwd, and release
+    // qualification requires the checkout to stay byte-identical.
+    cwd: os.tmpdir(),
     ...options,
     // A ruflo started here would auto-start a daemon and run its in-cwd self-update (`npm install @claude-flow/cli`,
     // 1.3 GB measured 2026-10-22) in the fixture project; a caller's own env still wins.

package/scripts/learning-replay-proof.mjs

@@ -220,14 +220,14 @@ function currency(artifact, repo, maxAgeDays) {
     const changed = diff.status === 0
       ? diff.stdout.split('\n').map((value) => value.trim()).filter(Boolean)
       : [];
-    if (changed.length) return { ok: false, why: `load-bearing files changed: ${changed.join(', ')}` };
+    if (changed.length) return { ok: false, stale: true, why: `load-bearing files changed: ${changed.join(', ')}` };
   }
   const age = artifact.at ? (Date.now() - Date.parse(artifact.at)) / 86_400_000 : Infinity;
-  if (!(age <= maxAgeDays)) return { ok: false, why: `artifact is older than ${maxAgeDays} days` };
+  if (!(age <= maxAgeDays)) return { ok: false, stale: true, why: `artifact is older than ${maxAgeDays} days` };
   return { ok: true };
 }
 
-export function checkArtifact({ file = RESULT_FILE, repo = ROOT, maxAgeDays = 14 } = {}) {
+export function checkArtifact({ file = RESULT_FILE, repo = ROOT, maxAgeDays = 14, tolerateStale = false } = {}) {
   if (!fs.existsSync(file)) return { status: VERDICT.UNKNOWN, why: 'result artifact does not exist' };
   let artifact;
   try { artifact = JSON.parse(fs.readFileSync(file, 'utf8')); }
@@ -236,7 +236,8 @@ export function checkArtifact({ file = RESULT_FILE, repo = ROOT, maxAgeDays = 14
   const source = checkSourceIdentity({ repo });
   if (!source.clean) return { status: VERDICT.UNKNOWN, why: source.why, artifact };
   const current = currency(artifact, repo, maxAgeDays);
-  if (!current.ok) return { status: VERDICT.UNKNOWN, why: current.why, artifact };
+  // `stale`: the one UNKNOWN a re-measurement fixes. Waiving it still verifies and recomputes everything below.
+  if (!current.ok && !(tolerateStale && current.stale)) return { status: VERDICT.UNKNOWN, why: current.why, ...(current.stale ? { stale: true } : {}), artifact };
   const evidence = verifyRuns(artifact, repo);
   if (!evidence.ok) return { status: VERDICT.UNKNOWN, why: evidence.why, artifact };
   const recomputed = aggregate(evidence.inputs);
@@ -244,7 +245,7 @@ export function checkArtifact({ file = RESULT_FILE, repo = ROOT, maxAgeDays = 14
     return { status: VERDICT.UNKNOWN, why: recomputed.why, artifact, recomputed };
   }
   const mismatch = aggregateMismatch(artifact, recomputed);
-  if (mismatch) return { status: VERDICT.FAIL, why: mismatch, artifact, recomputed };
+  if (mismatch) return { status: VERDICT.FAIL, inconsistent: true, why: mismatch, artifact, recomputed }; // claims contradict own evidence
   return {
     status: recomputed.verdict,
     why: `${recomputed.verdict} — ${recomputed.passes}/${recomputed.n} recomputed runs on ${artifact.sha.slice(0, 8)}`,
@@ -279,18 +280,18 @@ function causalMutantCheck(artifact, recomputed, mutant) {
 export function checkMutantArtifacts({
   files = MUTANT_RESULT_FILES,
   repo = ROOT,
-  maxAgeDays = 14,
+  maxAgeDays = 14, tolerateStale = false,
 } = {}) {
   const checked = [];
   for (const trap of [TRAP.MEMORY_SEARCH, TRAP.POST_TASK]) {
     for (const mutant of ['delete-lesson', 'brain-off-treated']) {
       const file = files[trap]?.[mutant];
       if (!file) return { status: VERDICT.UNKNOWN, why: `${trap}/${mutant}: artifact absent`, checked };
-      const result = checkArtifact({ file, repo, maxAgeDays });
+      const result = checkArtifact({ file, repo, maxAgeDays, tolerateStale });
       if (result.status === VERDICT.UNKNOWN) return { ...result, why: `${trap}/${mutant}: ${result.why}`, checked };
-      if (result.artifact?.mutant !== mutant || result.artifact?.trap !== trap) {
-        return { status: VERDICT.FAIL, why: `${trap}/${mutant}: artifact identity mismatch`, checked };
-      }
+      // Only a FAIL recomputed from self-consistent evidence is the expected one; claims that contradict the hashed transcripts are a forged receipt (Codex 4.7.21 r5 #1).
+      if (result.inconsistent) return { status: VERDICT.FAIL, why: `${trap}/${mutant}: mutant evidence is inconsistent: ${result.why}`, checked };
+      if (result.artifact?.mutant !== mutant || result.artifact?.trap !== trap) return { status: VERDICT.FAIL, why: `${trap}/${mutant}: artifact identity mismatch`, checked };
       const causal = causalMutantCheck(result.artifact, result.recomputed, mutant);
       if (causal) return { status: VERDICT.FAIL, why: `${trap}/${mutant}: ${causal}`, checked };
       checked.push(`${trap}/${mutant}`);
@@ -303,11 +304,11 @@ export function checkPortfolio({
   files = PORTFOLIO_RESULT_FILES,
   mutantFiles = MUTANT_RESULT_FILES,
   repo = ROOT,
-  maxAgeDays = 14,
+  maxAgeDays = 14, tolerateStale = false,
 } = {}) {
   const artifacts = [];
   for (const trap of [TRAP.MEMORY_SEARCH, TRAP.POST_TASK]) {
-    const result = checkArtifact({ file: files[trap], repo, maxAgeDays });
+    const result = checkArtifact({ file: files[trap], repo, maxAgeDays, tolerateStale });
     if (result.status !== VERDICT.PASS) return { ...result, why: `${trap}: ${result.why}`, artifacts };
     const metrics = result.recomputed;
     const artifact = result.artifact;
@@ -328,7 +329,7 @@ export function checkPortfolio({
     || artifacts[0].artifact.taskHash === artifacts[1].artifact.taskHash) {
     return { status: VERDICT.FAIL, why: 'portfolio traps are not independent', artifacts };
   }
-  const mutants = checkMutantArtifacts({ files: mutantFiles, repo, maxAgeDays });
+  const mutants = checkMutantArtifacts({ files: mutantFiles, repo, maxAgeDays, tolerateStale });
   if (mutants.status !== VERDICT.PASS) return { ...mutants, why: `portfolio mutants: ${mutants.why}`, artifacts };
   return { status: VERDICT.PASS, why: 'portfolio recomputed both traps and all causal mutants', artifacts, mutants };
 }

package/scripts/learning-replay.mjs

@@ -3,13 +3,13 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { main } from './learning-replay-cli.mjs';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 
 export * from './learning-replay-contract.mjs';
 export * from './learning-replay-execution.mjs';
 export * from './learning-replay-fixture.mjs';
 export * from './learning-replay-proof.mjs';
-export { main, measurePortfolio } from './learning-replay-cli.mjs';
+export { main, measurePortfolio, checkWire } from './learning-replay-cli.mjs';
 
-const invokedDirectly = process.argv[1]
-  && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+const invokedDirectly = isDirectInvocation(import.meta.url);
 if (invokedDirectly) process.exit(await main());

package/scripts/learnings.mjs

@@ -9,6 +9,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { learningScope, learnerCwd } from '../plugin/scripts/runtime-preferences.mjs';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 
 const HOME = os.homedir();
 
@@ -73,4 +74,4 @@ export function learnings({ statsPath, queueDir, now = Date.now(), cwd, env, hom
 
 export function printLearnings(l) { console.log(JSON.stringify(l, null, 2)); }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) printLearnings(learnings());
+if (isDirectInvocation(import.meta.url)) printLearnings(learnings());

package/scripts/lesson-ratify.mjs

@@ -24,23 +24,27 @@
  * Demotion is STICKY — it survives every future mining run. A one-click reject that the next
  * nightly quietly undoes is worse than no control at all, because the user stops trusting it and,
  * correctly, stops using it.
+ *
+ * MUTATIONS GO THROUGH `updateLessons()`, NOT `loadLessons()` + `saveLessons()`. The earlier version
+ * read `lessons` once at module load, then handed that same in-memory snapshot to `saveLessons()`
+ * after transforming it — the exact unlocked read-modify-write `lesson-store.mjs`'s own header
+ * documents destroying three ratified rules on 2026-07-22, and the exact race `updateLessons()` was
+ * written to close. `saveLessons()` taking a lock around the WRITE never protected the READ that
+ * preceded it: two ratify/demote invocations overlapping (a double-click, a script driving two calls
+ * back to back) could both load the same pre-change snapshot, and the second writer's save would
+ * silently discard the first writer's change — on the one file this CLI exists to make trustworthy.
+ * `updateLessons()` holds the lock across read → transform → write, so a concurrent writer's change
+ * is never lost.
  */
+import fs from 'node:fs';
 import os from 'node:os';
-import { loadLessons, saveLessons, ratify, demote, weightOf, pending, ENFORCEMENT, STATUS, ORIGIN, SOURCE_CLASS, TRIGGERS } from './lesson-store.mjs';
-
-const argv = process.argv.slice(2);
-const arg = (f) => { const i = argv.indexOf(f); return i >= 0 && argv[i + 1] ? argv[i + 1] : null; };
-const has = (f) => argv.includes(f);
-
-const lessons = loadLessons();
-if (!lessons.length) {
-  console.log('\n  No personal lessons stored yet. They appear after an explicit user correction is captured.\n');
-  process.exit(0);
-}
+import { fileURLToPath } from 'node:url';
+import { loadLessons, updateLessons, ratify, demote, weightOf, pending, ENFORCEMENT, STATUS, ORIGIN, SOURCE_CLASS, TRIGGERS } from './lesson-store.mjs';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 
 const FORCE = { block: '⛔ BLOCKS', checklist: '☑ checklist', inject: '· context', review: '👁 review only' };
 
-function list() {
+export function list(lessons) {
   const pend = pending(lessons);
   console.log(`\n  ${lessons.length} lessons — ${pend.length} awaiting your decision.\n`);
   console.log('  Nothing here refuses your work until YOU ratify it. The model does not get to');
@@ -67,35 +71,79 @@ function list() {
   console.log('  node scripts/lesson-ratify.mjs --ratify-all-user-stated\n');
 }
 
-function show(next, id, verb) {
-  const l = next.find((x) => x.id === id);
-  if (!l) { console.log(`\n  No lesson with id "${id}". Run --list to see them.\n`); process.exit(1); }
-  saveLessons(next);
-  console.log(`\n  ✓ ${verb} ${l.id}`);
-  console.log(`      now: ${FORCE[l.enforcement] || l.enforcement}${l.demoted ? '  (demoted — will never fire again, including after future mining runs)' : ''}`);
+/**
+ * Apply `mutate(id, lessons)` to the lesson `id`, holding the store lock across the read and the
+ * write (via `updateLessons`) so a concurrent ratify/demote can never be read as stale and clobbered.
+ * Returns the lesson's new state, or null if no lesson with `id` exists (the store is left untouched).
+ */
+export function applyMutation(id, mutate, file) {
+  let result = null;
+  updateLessons((fresh) => {
+    if (!fresh.find((x) => x.id === id)) return fresh;
+    const next = mutate(id, fresh);
+    result = next.find((x) => x.id === id);
+    return next;
+  }, file);
+  return result;
+}
+
+/**
+ * Bulk convenience, deliberately scoped: it can only touch lessons the USER stated. Model-inferred
+ * lessons are never swept up by a bulk action — that would be exactly the hole the boundary closes.
+ * Also lock-protected end to end, for the same reason as `applyMutation`.
+ */
+export function applyRatifyAllUserStated(file) {
+  let ratifiedIds = [];
+  let nowBlocking = 0;
+  updateLessons((fresh) => {
+    const targets = fresh.filter((l) => l.origin === ORIGIN.USER_STATED
+      && l.sourceClass === SOURCE_CLASS.CURRENT_USER
+      && l.status === STATUS.CANDIDATE
+      && !l.demoted);
+    let next = fresh;
+    for (const l of targets) next = ratify(l.id, next);
+    ratifiedIds = targets.map((l) => l.id);
+    nowBlocking = next.filter((l) => l.enforcement === ENFORCEMENT.BLOCK).length;
+    return next;
+  }, file);
+  return { ratifiedCount: ratifiedIds.length, nowBlocking };
+}
+
+function printResult(result, id, verb) {
+  if (!result) { console.log(`\n  No lesson with id "${id}". Run --list to see them.\n`); process.exit(1); }
+  console.log(`\n  ✓ ${verb} ${result.id}`);
+  console.log(`      now: ${FORCE[result.enforcement] || result.enforcement}${result.demoted ? '  (demoted — will never fire again, including after future mining runs)' : ''}`);
   console.log(`      stored at ${(process.env.RUVNET_LESSON_STORE || '~/.config/ruvnet-brain/lessons.json').replace(os.homedir(), '~')}\n`);
 }
 
-if (has('--ratify')) {
-  const id = arg('--ratify');
-  show(ratify(id, lessons), id, 'ratified');
-} else if (has('--demote')) {
-  const id = arg('--demote');
-  show(demote(id, lessons), id, 'demoted');
-} else if (has('--ratify-all-user-stated')) {
-  // Bulk convenience, deliberately scoped: it can only touch lessons the USER stated. Model-inferred
-  // lessons are never swept up by a bulk action — that would be exactly the hole the boundary closes.
-  let next = lessons;
-  const targets = lessons.filter((l) => l.origin === ORIGIN.USER_STATED
-    && l.sourceClass === SOURCE_CLASS.CURRENT_USER
-    && l.status === STATUS.CANDIDATE
-    && !l.demoted);
-  for (const l of targets) next = ratify(l.id, next);
-  saveLessons(next);
-  const nowBlocking = next.filter((l) => l.enforcement === ENFORCEMENT.BLOCK).length;
-  console.log(`\n  ✓ ratified ${targets.length} lesson(s) you stated yourself.`);
-  console.log(`      ${nowBlocking} now BLOCK at their decision point. Model-inferred lessons were left`);
-  console.log(`      as candidates — a bulk action may never promote something the model inferred.\n`);
-} else {
-  list();
+/** am I the entrypoint? — `fileURLToPath`, never `.pathname` (Windows); `realpathSync` guarded (vitest). */
+function isEntrypoint() {
+  return isDirectInvocation(import.meta.url);
+}
+
+if (isEntrypoint()) {
+  const argv = process.argv.slice(2);
+  const arg = (f) => { const i = argv.indexOf(f); return i >= 0 && argv[i + 1] ? argv[i + 1] : null; };
+  const has = (f) => argv.includes(f);
+
+  const lessons = loadLessons();
+  if (!lessons.length) {
+    console.log('\n  No personal lessons stored yet. They appear after an explicit user correction is captured.\n');
+    process.exit(0);
+  }
+
+  if (has('--ratify')) {
+    const id = arg('--ratify');
+    printResult(applyMutation(id, ratify), id, 'ratified');
+  } else if (has('--demote')) {
+    const id = arg('--demote');
+    printResult(applyMutation(id, demote), id, 'demoted');
+  } else if (has('--ratify-all-user-stated')) {
+    const { ratifiedCount, nowBlocking } = applyRatifyAllUserStated();
+    console.log(`\n  ✓ ratified ${ratifiedCount} lesson(s) you stated yourself.`);
+    console.log(`      ${nowBlocking} now BLOCK at their decision point. Model-inferred lessons were left`);
+    console.log(`      as candidates — a bulk action may never promote something the model inferred.\n`);
+  } else {
+    list(lessons);
+  }
 }

package/scripts/loop-checkpoint.mjs

@@ -26,6 +26,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 
 const argv = process.argv.slice(2);
 const cmd = argv[0];
@@ -91,7 +92,7 @@ export function checkCheckpoint(file = FILE, runner = (c) => spawnSync('sh', ['-
   return { code: 0, verdict: `continue — iteration ${cp.iteration}, next: ${cp.next}` };
 }
 
-const invokedDirectly = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+const invokedDirectly = isDirectInvocation(import.meta.url);
 if (invokedDirectly) {
   if (cmd === 'read') {
     console.log(JSON.stringify(readCheckpoint() ?? {}, null, 2));

package/scripts/metaharness-receipts.mjs

@@ -12,6 +12,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { CLAUDE_MODEL_IDS } from './route-cheap.mjs';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 
 export function receiptsPath() {
   return (
@@ -165,4 +166,4 @@ function main() {
   if (skipped) console.log(`(${skipped} corrupt line(s) skipped)`);
 }
 
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) main();
+if (isDirectInvocation(import.meta.url)) main();

package/scripts/model-catalog.mjs

@@ -8,6 +8,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, '..');
@@ -70,7 +71,7 @@ export function providerChoices(catalog) {
   return Object.entries(catalog.providers || {}).map(([id, p]) => ({ id, label: p.label || id }));
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+if (isDirectInvocation(import.meta.url)) {
   const c = loadCatalog();
   const det = detectProvider(c, {});
   console.log(`detected house: ${det.provider} (${det.source})`);

package/scripts/model-currency-evidence.mjs

@@ -96,7 +96,9 @@ export function parseCodingAgentEvidence(html, methodology, { url, checkedAt, id
   const walk = (value) => {
     if (Array.isArray(value)) { for (const child of value) walk(child); return; }
     if (!value || typeof value !== 'object') return;
-    if (typeof value.hostModelSlug === 'string' && typeof value.id === 'string' && value.indexScore !== undefined) { rows.set(value.id, value); return; }
+    // A row is an agent/configuration record: harness name + index score. AA dropped `hostModelSlug` and
+    // `modelRelease` from the page in October 2026, so neither may be a key; both stay optional evidence.
+    if (typeof value.agentName === 'string' && typeof value.id === 'string' && value.indexScore !== undefined) { rows.set(value.id, value); return; }
     for (const child of Object.values(value)) walk(child);
   };
   for (const match of html.matchAll(/self\.__next_f\.push\((.*?)\)<\/script>/gs)) {
@@ -104,12 +106,12 @@ export function parseCodingAgentEvidence(html, methodology, { url, checkedAt, id
       const envelope = JSON.parse(match[1]);
       if (typeof envelope[1] !== 'string') continue;
       for (const line of envelope[1].split('\n')) {
-        if (!line.includes('hostModelSlug')) continue;
+        if (!line.includes('agentName')) continue;
         try { walk(JSON.parse(line.slice(line.indexOf(':') + 1))); } catch { /* unrelated frame */ }
       }
     } catch { /* required contract checked below */ }
   }
-  const source = { url, checkedAt, sha256: digest(html), parser: 'aa-coding-agents-flight-v1' };
+  const source = { url, checkedAt, sha256: digest(html), parser: 'aa-coding-agents-flight-v2' };
   const records = [];
   const skippedIncomplete = [];
   for (const row of rows.values()) {
@@ -129,7 +131,7 @@ export function parseCodingAgentEvidence(html, methodology, { url, checkedAt, id
     if (binding && (!binding.model || !binding.evidence || !binding.checkedAt)) throw new Error('Invalid coding-agent native identity binding');
     const effort = nativeHost ? row.display.model.match(/\((low|medium|high|xhigh|max|minimal|none)\)/i)?.[1]?.toLowerCase() ?? null : null;
     records.push({ sourceId: row.id, harness: row.agentName, provider: row.provider, nativeHost,
-      sourceModelSlug: row.hostModelSlug, sourceReleaseSlug: row.modelRelease?.slug ?? null,
+      sourceModelSlug: typeof row.hostModelSlug === 'string' ? row.hostModelSlug : null, sourceReleaseSlug: row.modelRelease?.slug ?? null,
       displayModel: row.display.model, configurationLabel: row.displayLabel, effort,
       model: binding?.model ?? null, identityEvidence: binding ?? null,
       fallback: /fallback/i.test(row.displayLabel ?? row.display.model),

package/scripts/model-currency.mjs

@@ -8,6 +8,7 @@ import { randomUUID } from 'node:crypto';
 import { buildWeeklyAssessment } from './model-weekly-assessment.mjs';
 import { fileURLToPath } from 'node:url';
 import { WEEK_MS, digest, parseInventory, parseArtificialAnalysis, parseCodingAgentEvidence, currencyStatus } from './model-currency-evidence.mjs';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 
 export const DEFAULT_ROUTER_DIR = path.join(os.homedir(), '.claude', 'model-router');
 export const AA_URLS = [
@@ -218,13 +219,42 @@ export async function refreshModelCurrency({ routerDir = DEFAULT_ROUTER_DIR, now
   } finally { release(routerDir, lock); }
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === SELF) {
+/** The weekly CI verdict. Core evidence is the inventory, the effort evaluations and the local instruction; a
+ *  third-party scrape that only feeds the advisory sections (coding agents, official docs, extra benchmark
+ *  archives) failing on its own is `partial`: exit 0 with a warning, because the router's own facts are fresh. */
+const ANCILLARY_ERROR = /^(coding agents|official |coding benchmark )/;
+export function refreshOutcome(result) {
+  const errors = result?.lastAttempt?.errors ?? result?.errors ?? [];
+  const core = errors.filter((error) => !ANCILLARY_ERROR.test(error));
+  if (result?.action !== 'refreshed' || result.inventoryFresh !== true || result.evaluationsFresh !== true || core.length) {
+    return { status: 'failed', exitCode: 1, errors: core.length ? core : [...errors, result?.reason ?? 'core evidence not fresh'] };
+  }
+  return errors.length ? { status: 'partial', exitCode: 0, warnings: errors } : { status: 'complete', exitCode: 0, warnings: [] };
+}
+export function outcomeSummary(outcome) {
+  const lines = [`### model-currency refresh: ${outcome.status}`, ''];
+  for (const message of outcome.errors ?? []) lines.push(`- error: ${message}`);
+  for (const message of outcome.warnings ?? []) lines.push(`- warning: ${message}`);
+  if (outcome.status === 'partial') lines.push('', 'Inventory and evaluations are fresh; only a third-party advisory source failed.');
+  return `${lines.join('\n')}\n`;
+}
+
+if (isDirectInvocation(import.meta.url)) {
   const dirIndex = process.argv.indexOf('--router-dir');
   const routerDir = dirIndex >= 0 ? process.argv[dirIndex + 1] : DEFAULT_ROUTER_DIR;
   if (!routerDir || !path.isAbsolute(routerDir)) throw new Error('--router-dir must be absolute');
-  if (process.argv.includes('--refresh')) {
+  if (process.argv.includes('--summarize')) {
+    // Markdown for the CI job summary from a captured `--refresh` stdout; a missing or unreadable capture says so.
+    let outcome;
+    try { outcome = JSON.parse(fs.readFileSync(process.argv[process.argv.indexOf('--summarize') + 1], 'utf8').split('\n')[0]).outcome; }
+    catch { outcome = null; }
+    process.stdout.write(outcome ? outcomeSummary(outcome) : '### model-currency refresh: no result (the refresh step crashed before reporting)\n');
+  } else if (process.argv.includes('--refresh')) {
     refreshModelCurrency({ routerDir, claimToken: process.argv.includes('--claim-token') ? process.argv[process.argv.indexOf('--claim-token') + 1] : null }).then((result) => {
-      console.log(JSON.stringify(result)); if (result.status === 'stale') process.exitCode = 1;
+      const outcome = refreshOutcome(result);
+      console.log(JSON.stringify({ ...result, outcome }));
+      if (outcome.status === 'partial') console.log(`::warning title=model-currency partial::${outcome.warnings.join('; ').replace(/[\r\n]+/g, ' ')}`);
+      process.exitCode = outcome.exitCode;
     }).catch((error) => { console.error(error.message); process.exitCode = 1; });
   } else console.log(JSON.stringify(process.argv.includes('--catch-up') ? maybeLaunchCurrencyRefresh({ routerDir }) : readCurrencyStatus({ routerDir })));
 }

package/scripts/model-native-catalog.mjs

@@ -5,6 +5,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 const HOSTS = { codex: 'openai', 'claude-code': 'anthropic' };
 const EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
 const read = (file, optional = false) => {
@@ -104,7 +105,7 @@ export async function refreshNativeCatalog({ routerDir = path.join(os.homedir(),
     if (acquired) { try { fs.rmdirSync(guard); } catch { /* not acquired */ } }
   }
 }
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+if (isDirectInvocation(import.meta.url)) {
   const option = name => { const at = process.argv.indexOf(name); return at < 0 ? undefined : process.argv[at + 1]; };
   refreshNativeCatalog({ routerDir: option('--router-dir'), deadline: option('--deadline') === undefined ? undefined : Number(option('--deadline')) })
     .then(result => { console.log(JSON.stringify(result)); if (result.status !== 'current') process.exitCode = 1; });

package/scripts/model-router-agent-hook.mjs

@@ -10,6 +10,7 @@ import { execFileSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { readCodexAllowance } from './native-subscription-usage.mjs';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 
 const DIR = path.dirname(fileURLToPath(import.meta.url));
 const TASK_CLASSES = new Set(['fast', 'medium', 'substantial', 'hard', 'exceptional']);
@@ -126,7 +127,7 @@ async function main(argv) {
   // The host's normal transcript records its tool input. This hook persists no task text.
   process.stdout.write(JSON.stringify(output) + '\n');
 }
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+if (isDirectInvocation(import.meta.url)) {
   main(process.argv.slice(2)).catch(() => {
     const args = process.argv.slice(2); const harness = args[args.indexOf('--harness') + 1];
     const result = harness === 'codex' && loadScope(harness).strict ? deny('Agent routing hook failed; managed dispatch required.')