ruvnet-brain 4.0.8 → 4.0.24

package/scripts/console-runtime-identity.mjs

@@ -0,0 +1,74 @@
+// ONE definition of "what the persistent Console runtime is" and "which generation is running".
+//
+// #79 reported a Console that survived an update: the browser was served the new frontend from disk
+// while the Node process kept its pre-update router in memory, and every relaunch said "already
+// running". The reuse check compared a `sourceSha256` computed from a SINGLE file —
+// scripts/onboarding-console.mjs — while the runtime the server actually executes is this whole
+// surface: ~230 modules it imports plus the frontend it serves. Two genuinely different candidates
+// whose entrypoint bytes happened to match produced byte-identical identities, so an update that
+// changed console-engine.mjs, capability-registry.mjs or console/app.js was invisible to the
+// launcher. The identity has to derive from something an update cannot leave behind, which is the
+// installed bytes themselves — all of them.
+//
+// #76 reported the same disease at the asset boundary: the runtime copied plugin/scripts without
+// the sibling docs/ and manifest that plugin/scripts/whats-new.mjs reads, so the executable
+// travelled and its assets did not. The copy list and the identity list were two separate
+// enumerations of one payload; they are one list now, so an asset added to the runtime is part of
+// its generation by construction.
+//
+// The installer hashes the staged tree with this function and the running server hashes its own
+// root with this function, over this list. Neither side can define the fact differently.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+/**
+ * Every path the persistent Console runtime carries, relative to both the candidate source root and
+ * the installed runtime root (they are laid out identically). This is simultaneously the installer's
+ * copy list and the generation's digest input — one enumeration, so they cannot drift.
+ */
+export const CONSOLE_RUNTIME_SURFACE = Object.freeze([
+  'console',
+  'scripts',
+  'plugin/scripts',
+  // whats-new.mjs resolves its version manifest and curated notes relative to its own plugin root
+  // (#76). Shipping the executable without them is how the installed skill lost its release notes.
+  'plugin/docs',
+  'plugin/.claude-plugin',
+  'data/model-catalog.json',
+  'kb/brain-profile.mjs',
+  'bin/install.mjs',
+  'package.json',
+]);
+
+/** The runtime's own identity file, written by the installer INTO the tree — never part of its own digest. */
+export const CONSOLE_RUNTIME_IDENTITY_FILE = 'runtime-identity.json';
+
+/**
+ * Deterministic content digest of the runtime surface under `root`.
+ *
+ * A path that is absent is hashed as absent rather than skipped: a runtime that lost a file is a
+ * different generation, not the same one, and a launcher must be able to see that.
+ *
+ * @param {string} root runtime root (an installed `.console-runtime`, a marketplace clone, or a checkout)
+ * @returns {string} hex sha256
+ */
+export function consoleRuntimeDigest(root) {
+  const hash = crypto.createHash('sha256');
+  const visit = (absolute, relative) => {
+    let stat;
+    try { stat = fs.lstatSync(absolute); } catch { hash.update(`absent\0${relative}\0`); return; }
+    if (stat.isDirectory()) {
+      hash.update(`d\0${relative}\0`);
+      let entries = [];
+      try { entries = fs.readdirSync(absolute).sort(); } catch { hash.update(`unreadable\0${relative}\0`); return; }
+      for (const entry of entries) visit(path.join(absolute, entry), `${relative}/${entry}`);
+      return;
+    }
+    hash.update(`f\0${relative}\0`);
+    try { hash.update(fs.readFileSync(absolute)); } catch { hash.update(`unreadable\0${relative}\0`); }
+  };
+  for (const relative of CONSOLE_RUNTIME_SURFACE) visit(path.join(root, relative), relative);
+  return hash.digest('hex');
+}

package/scripts/corpus-qa.mjs

@@ -26,9 +26,12 @@
 //         drift (~0.035 measured) exceeds the true gap between near-dups — the row IS stored and
 //         readable (fact.big id=722: rank 6, Δ0.007 behind rank 1), so that's a photo-finish,
 //         not a broken store. Photo-finish passes are still surfaced as a `note` so the
-//         near-dup-noise signal feeds the dedup backlog instead of being hidden. A row absent
-//         from top-10 (or far from the leader) remains a hard FAIL — missing/zero vectors and
-//         broken read paths cannot hide behind the epsilon.
+//         near-dup-noise signal feeds the dedup backlog instead of being hidden.
+//         Anything that is NOT a top-3 hit and NOT a photo-finish is RE-QUERIED WIDE (WIDE_K,
+//         bounded to half the corpus) before any verdict — see the wide-k arm at R1 below.
+//         Present at wide k => PASS with a loud `deep crowd` note carrying rank + crowd size.
+//         ABSENT at wide k => hard FAIL, always: a missing vector, a zero vector, a mis-slotted
+//         vector and a broken read path are absent at ANY k, and nothing forgives them.
 //         Proves embed-write AND read-path in one check. Retrieval QUALITY (real questions) stays
 //         forge-guard/prove's job; this gate proves the machinery, not the answers.
 //
@@ -62,6 +65,24 @@ const FULL_BODY_MARK = '(full body):';
 // distance (fact.big id=722 replay); near-dup siblings sit within ~0.005 of each other. 0.02
 // forgives the drift-scale tie WITHOUT forgiving genuinely different rows.
 const NEAR_DUP_EPS = 0.02;
+// R1 wide-k arm. Measured 2026-08-06 on the store that failed the nightly six times in three
+// nights (metaharness.big, chunk:2b7c2755…, submissions/swe-bench-lite/…/django__django-13315/
+// test_output.txt): ABSENT from top-10, but rank 188 at k=500, Δ0.0557 behind #1 — and all 187
+// hits ahead of it were near-duplicates of it (187/187, conda-activation boilerplate). 49.3% of
+// that corpus (4,428 of 8,979 rows) is submissions/swe-bench-lite/** of that shape, so a row with
+// ordinary embed drift sinks below its own siblings. That is a corpus-composition fact, not a
+// broken store, and asserting otherwise made this gate assert retrieval QUALITY — explicitly not
+// its job (see header). 500 is ~5.6% of that corpus: deep enough to see under the crowd, far too
+// shallow for a missing/zero/mis-slotted vector to hide in.
+const WIDE_K = 500;
+// Never let wide k reach the whole corpus — a k that returns every row makes "present" vacuous and
+// would silently retire the failure class this gate exists for. Half the corpus is the ceiling.
+const wideKFor = (n) => Math.min(WIDE_K, Math.max(10, Math.floor(n / 2)));
+// Crowd measure for the note: how many hits ahead of the row open with the same normalized text.
+// Cheap, deterministic, model-free — it turns "rank 188" into "rank 188 behind 187 of its own
+// near-duplicates", which is the signal the dedup backlog actually needs.
+const CROWD_PREFIX = 200;
+const crowdKey = (s) => String(s ?? '').replace(/\s+/g, ' ').trim().slice(0, CROWD_PREFIX);
 
 function fnv1a(s) {
   let h = 0x811c9dc5;
@@ -113,7 +134,7 @@ function getPipeline(embedConf) {
  * `fails` is [] on PASS; every entry is a specific reason string (receipts, not adjectives).
  * `notes` are non-fatal signals (e.g. near-dup crowding) that should reach the dedup backlog.
  */
-export async function qaStore(dir, store, variant, { roundtrip = true, samples = 3 } = {}) {
+export async function qaStore(dir, store, variant, { roundtrip = true, samples = 3, pipeline = null } = {}) {
   const base = variant === 'big' ? `${store}.big` : store;
   const rvfPath = path.join(dir, `${base}.rvf`);
   const variantPassages = path.join(dir, `${base}.passages.jsonl`);
@@ -160,7 +181,10 @@ export async function qaStore(dir, store, variant, { roundtrip = true, samples =
       const byId = new Map(rows.map((r) => [String(r.id), r]));
       let hit = 0;
       const misses = [];
-      const pipe = await getPipeline(embedConf);
+      // `pipeline` is the unit tier's injection seam (same shape as getPipeline's resolved value:
+      // (texts, opts) => { dims, data }). Production always passes null and loads the real model.
+      const pipe = pipeline || await getPipeline(embedConf);
+      const wideK = wideKFor(rows.length);
       for (const i of picks) {
         const r = rows[i];
         // Re-embed EXACTLY what the pipeline indexed for this variant (forge-build/forge-big):
@@ -179,7 +203,21 @@ export async function qaStore(dir, store, variant, { roundtrip = true, samples =
           hit++; // photo-finish behind near-duplicates: stored + readable; surface the crowd as a note
           res.notes.push(`near-dup crowd: id=${r.id} rank ${rank + 1}, Δ${(top[rank].distance - top[0].distance).toFixed(4)} behind #1 (${r.path})`);
         } else {
-          misses.push(`id=${r.id} ${rank < 0 ? 'ABSENT from top-10' : `rank ${rank + 1}, Δ${(top[rank].distance - top[0].distance).toFixed(4)}`} ${r.path}`);
+          // Not a top-3 hit and not a photo-finish. Before declaring the store broken, ask the
+          // question this gate is actually for: is the row IN there and READABLE at all? Re-query
+          // wide. This covers BOTH shapes of miss — absent from top-10 (a deep near-dup crowd) and
+          // present-but-far inside top-10 (a shallow one) — because the alternative is perverse:
+          // a row buried under 187 siblings would pass while the same row buried under 5 failed.
+          const wide = await db.query(Array.from(out.data), wideK);
+          const wideRank = wide.findIndex(matches);
+          if (wideRank >= 0) {
+            hit++; // stored + readable, just outranked by its own near-duplicates
+            const mine = crowdKey(r.text);
+            const crowd = wide.slice(0, wideRank).filter((t) => crowdKey(byId.get(String(t.id))?.text) === mine).length;
+            res.notes.push(`deep crowd: id=${r.id} rank ${wideRank + 1}/${wideK}${rank < 0 ? ' (absent from top-10)' : ''}, Δ${(wide[wideRank].distance - wide[0].distance).toFixed(4)} behind #1, ${crowd}/${wideRank} ahead are near-duplicates (${r.path})`);
+          } else {
+            misses.push(`id=${r.id} ABSENT from top-${wideK} ${r.path}`);
+          }
         }
       }
       res.roundtrip = `${hit}/${picks.length}`;

package/scripts/distill-project.mjs

@@ -37,9 +37,13 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { execFileSync, spawnSync } from 'node:child_process';
+import { resolveRuflo, RUFLO_MISSING } from '../plugin/scripts/ruflo-bin.mjs';
 
 const HOME = os.homedir();
-const RUFLO = process.env.RUFLO_BIN || path.join(HOME, '.npm-global/bin/ruflo');
+// Issue #99: this was `process.env.RUFLO_BIN || path.join(HOME, '.npm-global/bin/ruflo')`, so every
+// install whose npm prefix is not the owner's (Homebrew, nvm, Volta, plain `npm -g`) was told its
+// tool was missing while ruflo sat on their PATH. One resolver, shared — see ruflo-bin.mjs.
+const RUFLO = resolveRuflo();
 const RUFLO_ENV = { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' };
 
 const argv = process.argv.slice(2);
@@ -126,6 +130,10 @@ if (has('--restore')) {
 }
 
 // ── PRE-FLIGHT ─────────────────────────────────────────────────────────────────────────────────────
+// Two different facts, so two different sentences. `null` means we looked everywhere and found
+// nothing; a path that does not exist means the user pointed RUFLO_BIN somewhere empty, and naming
+// that exact path back to them is the whole value of the message.
+if (!RUFLO) die(RUFLO_MISSING);
 if (!fs.existsSync(RUFLO)) die(`ruflo is not at ${RUFLO.replace(HOME, '~')} — install it with \`npm i -g ruflo@latest\``);
 if (!fs.existsSync(DB)) die(`no memory store at ${DB.replace(HOME, '~')} — nothing to distill for this project`);
 

package/scripts/doc-currency.mjs

@@ -296,8 +296,36 @@ export function deriveDrift(root, docRel, governed) {
   const doc = lastCommit(root, docRel);
   if (!doc) return { state: 'not-applicable', commits: 0, days: 0, reason: 'document has no git history' };
 
-  const rl = git(root, ['rev-list', '--count', `${doc.sha}..HEAD`, '--', ...paths]);
-  const commits = rl.ok ? parseInt(rl.out || '0', 10) || 0 : 0;
+  // A VERSION BUMP IS NOT DRIFT (2026-08-06). `scripts/sync-version.mjs` rewrites the plugin
+  // manifests, package.json, kb/package.json and RVF-GENERATIONS.json on EVERY release bump, and
+  // several ADRs legitimately `govern:` those files. So every bump marked those documents
+  // presumed-stale whether or not anything they decide had moved — measured four times in one day
+  // on ADR-050/051/057/058, each time resolving to "re-read, nothing changed but a version string".
+  //
+  // That is not a harmless nuisance. A gate that fires on every bump teaches people to stamp
+  // without reading, and this repo has already blanket-stamped 61 ADRs from a bad grep exactly
+  // once. It also blocks unattended release automation, which cannot author a currency row.
+  //
+  // Drift is MOVEMENT IN WHAT THE DOCUMENT DECIDES. A commit whose entire diff inside the governed
+  // paths is version-identifier lines cannot have changed any decision, so it does not count. Any
+  // commit touching one substantive line still counts in full — this narrows the trigger, never the
+  // verdict.
+  const shas = (() => {
+    const r = git(root, ['rev-list', `${doc.sha}..HEAD`, '--', ...paths]);
+    return r.ok && r.out ? r.out.split('\n').filter(Boolean) : [];
+  })();
+  const VERSION_FIELD = /^[+-]\s*"?(version|releaseTag|brainVersion|softwareVersion|tag)"?\s*[:=]/i;
+  const isVersionOnly = (sha) => {
+    const d = git(root, ['show', '--unified=0', '--format=', sha, '--', ...paths]);
+    if (!d.ok || !d.out) return false;
+    const changed = d.out.split('\n')
+      .filter((l) => /^[+-]/.test(l) && !/^(\+\+\+|---)/.test(l));
+    // No changed lines at all (pure rename/mode) is not evidence of a decision change either, but
+    // be conservative: only EXEMPT when there is at least one line and every one is a version field.
+    return changed.length > 0 && changed.every((l) => VERSION_FIELD.test(l));
+  };
+  const substantive = shas.filter((s) => !isVersionOnly(s));
+  const commits = substantive.length;
 
   const codeR = git(root, ['log', '-1', '--format=%ad', '--date=short', `${doc.sha}..HEAD`, '--', ...paths]);
   const codeDate = codeR.ok && codeR.out ? codeR.out.split('\n')[0] : null;
@@ -408,6 +436,7 @@ export function evaluateDoc(root, rel, opts = {}) {
     status: k.status ?? null,
     date: k.date ?? null,
     updated: k.updated ?? null,
+    updatedPinned: k.updated_pinned === true || k.updated_pinned === 'true',
     implStored: k.impl ?? null,
     verifiedStamp: k.verified ?? null,
     verifiedDigestStored: k.verified_digest ?? null,
@@ -455,7 +484,19 @@ export function evaluateDoc(root, rel, opts = {}) {
     if (Number.isFinite(d) && Number.isFinite(g)) {
       const deltaDays = Math.round((g - d) / 86400000);
       if (deltaDays >= 1) {
-        add(BLOCK, 'stamp-lags-doc',
+        // `updated_pinned: true` — the date is a HISTORICAL RECORD, not a currency stamp.
+        //
+        // Some documents record WHEN SOMETHING HAPPENED, not when the file was last edited.
+        // ADR-050's `updated: 2026-08-02` is an incident cutoff and is asserted by
+        // tests/unit/fix-workstream-guidance. A blanket "make the stamp match the last commit"
+        // rule cannot tell those apart, so it silently rewrote the pinned date — putting two gates
+        // into direct contradiction, one demanding the pinned value and one demanding the commit
+        // date, with no way to satisfy both. The document itself is the only thing that knows
+        // which kind of date it carries, so it now says so, and --fix must never overwrite it.
+        if (doc.updatedPinned) {
+          add(WARN, 'stamp-pinned',
+            `updated: ${doc.updated} is PINNED (updated_pinned: true) and deliberately does not track the last commit ${docCommit.date} — it records an event, not the edit`);
+        } else add(BLOCK, 'stamp-lags-doc',
           `updated: ${doc.updated} but the document's own last commit is ${docCommit.date} (${docCommit.sha.slice(0, 8)}) — edited without touching its own stamp`);
       } else if (deltaDays <= -1) {
         // Typed ahead. WARN only: a stamp dated today on a change not yet committed is CORRECT, and
@@ -610,7 +651,7 @@ export function planFix(root, doc) {
     if (doc.dirty) blocked.push({ code: 'missing-updated', why: 'working tree is modified — the last commit date is not the date of the current contents' });
     else if (doc.docCommit) changes.push({ key: 'updated', value: doc.docCommit.date, source: 'derived-from-git', evidence: `git log -1 ${doc.file} → ${doc.docCommit.sha.slice(0, 8)}` });
     else blocked.push({ code: 'missing-updated', why: 'git reports no commit touching this path' });
-  } else if (doc.findings.some((f) => f.code === 'stamp-lags-doc') && doc.docCommit && !doc.dirty) {
+  } else if (!doc.updatedPinned && doc.findings.some((f) => f.code === 'stamp-lags-doc') && doc.docCommit && !doc.dirty) {
     changes.push({ key: 'updated', value: doc.docCommit.date, source: 'derived-from-git', replaces: doc.updated, evidence: `git log -1 ${doc.file} → ${doc.docCommit.sha.slice(0, 8)}` });
   }
   return { changes, blocked };

package/scripts/gates.mjs

@@ -1,146 +1,4 @@
-// gates.mjs — what stands between the model and your machine, and what it has caught.
-//
-// ─────────────────────────────────────────────────────────────────────────────────────────────────
-// WHY (2026-07-17). Stuart, looking at the console's wiring card: "I have no idea what message it's
-// supposed to tell me… it seems to be facts without purpose." The card counted launch sites. Nobody
-// wants a census. The question worth answering is the one the harness exists for: WHAT STOPS CLAUDE
-// FROM BEING WRONG, AND HAS IT EVER ACTUALLY STOPPED IT?
-//
-// Two things had to be true before that card could be honest, and neither was:
-//
-//   1. The console never read the gates. wiringSurvey() walks ~/Code project settings only, so the
-//      12 machine-wide hooks in ~/.claude/settings.json and the 9 in the plugin's own hooks.json —
-//      including the design wall that blocks commits — were invisible to the page bragging about them.
-//
-//   2. The gates never recorded a block. Only successes were logged, so "the harness caught Claude"
-//      had no receipt. gate-receipt.sh now writes one at the moment of refusal.
-//
-// THE HONEST DISTINCTION this module exists to draw: a hook wired with `|| true` CANNOT block —
-// it injects context and the tool call proceeds regardless. Only a gate that can exit non-zero
-// stops anything. Counting all hooks as "protection" would be the same inflation as counting
-// cloned upstream repos as your own wiring. Advisory and blocking are different claims.
-//
-// Reads only. Never asserts a count it cannot source from a file on this machine.
-// ─────────────────────────────────────────────────────────────────────────────────────────────────
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const HOME = os.homedir();
-const BLOCKS = path.join(HOME, '.cache/ruvnet-brain/gate-blocks.jsonl');
-
-function readJSON(f) { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return null; } }
-
-// Two independent things must BOTH be true for a hook to stop anything, and conflating them is how
-// a census gets sold as protection:
-//   1. The EVENT must be one that runs before the thing it would stop. PreToolUse gates a tool call;
-//      UserPromptSubmit gates a prompt. SessionStart has nothing to refuse yet, and PostToolUse /
-//      PreCompact / SessionEnd arrive after the fact — those inject or record, they never block.
-//   2. The COMMAND must not end in `|| true`, which swallows the exit code the gate would refuse with.
-const BLOCKING_EVENTS = new Set(['PreToolUse', 'UserPromptSubmit']);
-const swallowsExit = (cmd) => /\|\|\s*true\s*$/.test(String(cmd || '').trim());
-const canBlock = (event, cmd) => BLOCKING_EVENTS.has(event) && !swallowsExit(cmd);
-
-const NAME = (cmd) => {
-  const m = String(cmd || '').match(/([\w-]+)\.(sh|mjs|js)/);
-  return m ? m[1] : String(cmd || '').split(/\s+/).filter((t) => !t.startsWith('-')).pop()?.slice(0, 28) || 'hook';
-};
-
-function collect(hooksObj, source) {
-  const out = [];
-  for (const [event, groups] of Object.entries(hooksObj || {})) {
-    const list = Array.isArray(groups) ? groups : [groups];
-    for (const g of list) {
-      const hooks = Array.isArray(g?.hooks) ? g.hooks : (g?.command ? [g] : []);
-      for (const h of hooks) {
-        if (!h?.command) continue;
-        out.push({ event, matcher: g?.matcher ?? '*', name: NAME(h.command), blocking: canBlock(event, h.command), source });
-      }
-    }
-  }
-  return out;
-}
-
-// Every catch the gates have recorded. This file only exists once a gate has actually refused
-// something — an empty ledger is an honest "nothing caught yet", never a failure.
-export function gateBlocks() {
-  try {
-    return fs.readFileSync(BLOCKS, 'utf8').trim().split('\n')
-      .map((l) => { try { return JSON.parse(l); } catch { return null; } })
-      .filter(Boolean);
-  } catch { return []; }
-}
-
-export function gatesSurvey({ repo } = {}) {
-  const machine = collect(readJSON(path.join(HOME, '.claude/settings.json'))?.hooks, 'machine');
-  const pluginCfg = repo ? readJSON(path.join(repo, 'plugin/hooks/hooks.json')) : null;
-  const plugin = collect(pluginCfg?.hooks || pluginCfg, 'plugin');
-
-  const all = [...machine, ...plugin];
-  const blocking = all.filter((g) => g.blocking);
-
-  // THE LEDGER IS MACHINE-WIDE; THIS SURVEY IS ABOUT ONE PROJECT. Every catch ever recorded on the
-  // machine used to be counted here, so standing in an empty folder produced "203 refusals have been
-  // recorded" — this repo's history, attributed to a project that has never run a gate. Each record
-  // carries the `cwd` it was caught in, so when a project is named, only its own catches count.
-  //
-  // KNOWN LIMIT, stated rather than hidden: `cwd` is a basename, so two projects sharing a folder
-  // name share a count. That is a real ambiguity and it is narrow; attributing the whole machine's
-  // history to whichever directory you happen to be standing in was neither.
-  const here = repo ? path.basename(path.resolve(repo)) : null;
-  const allBlocks = gateBlocks();
-  const blocks = here ? allBlocks.filter((b) => b.cwd === here) : allBlocks;
-
-  // Same gate, same event, wired both machine-wide AND by the plugin — it runs twice on every
-  // matching call. Harmless to correctness (these gates are idempotent) but it is real duplicated
-  // work, and counting it as two protections would inflate the only number on the card that matters.
-  const seen = new Map();
-  const duplicated = [];
-  for (const g of all) {
-    const k = `${g.event}:${g.name}`;
-    if (seen.has(k) && seen.get(k) !== g.source) { if (!duplicated.includes(g.name)) duplicated.push(g.name); }
-    seen.set(k, g.source);
-  }
-  const uniqueBlocking = new Set(blocking.map((g) => `${g.event}:${g.name}`)).size;
-
-  // Group the catches by gate so the card can say WHAT was caught, not just how many times.
-  const byGate = {};
-  for (const b of blocks) (byGate[b.gate] ||= []).push(b);
-
-  const weekAgo = Date.now() - 7 * 864e5;
-  const recent = blocks.filter((b) => Date.parse(b.at || 0) >= weekAgo);
-
-  // THREE NUMBERS, ONE UNIT. This block used to mix two: `blocking` was DEDUPLICATED
-  // (distinct event:name) while `advisory` was `all.length - blocking.length`, computed from the
-  // RAW array. So `blocking + advisory` fell short of `armed` by exactly the number of duplicated
-  // blocking wirings, and the console printed "N gates armed — B can stop a call. The other A add
-  // context" where B + A ≠ N. On a machine with 4 duplicate blocking gates the sentence silently
-  // lost four of them — in the one sentence whose entire job is to account for all of them.
-  //
-  // It summed correctly on any machine with no duplicates, which is why it survived: the defect was
-  // invisible exactly where it was most often looked at. Found by Fable 5, 2026-07-24, by adding up
-  // the numbers on the owner's own console.
-  //
-  // Fixed by reporting all three in WIRED-ENTRY units, so armed = blocking + advisory holds by
-  // construction. The distinct-gate count is still exported — it is genuinely the more meaningful
-  // number for "how many different things can refuse" — but under its own name, where it cannot be
-  // mistaken for a term in that sum.
-  const blockingWired = blocking.length;
-  return {
-    summary: {
-      armed: all.length,
-      blocking: blockingWired,           // wired entries that can refuse — same unit as `armed`
-      advisory: all.length - blockingWired,
-      blockingDistinct: uniqueBlocking,  // distinct gates that can refuse; ≤ blocking when wired twice
-      duplicated,                        // wired twice; runs twice
-      caughtTotal: blocks.length,
-      caughtThisWeek: recent.length,
-      everRecorded: blocks.length > 0,
-    },
-    gates: all.sort((a, b) => Number(b.blocking) - Number(a.blocking)),
-    // Newest first — the most recent catch is the one worth reading.
-    catches: blocks.slice(-12).reverse(),
-    byGate: Object.fromEntries(Object.entries(byGate).map(([k, v]) => [k, v.length])),
-  };
-}
+// Compatibility export for repository tools. The executable implementation belongs inside the
+// self-contained plugin payload so Stable Spine and Codex-only installs never depend on a separate
+// Claude marketplace checkout.
+export * from '../plugin/scripts/gates.mjs';