ruvnet-brain 4.7.16 → 4.7.18

package/README.md

@@ -9,7 +9,7 @@ Created: 2026-06-29 22:36:38 EDT
 
 ### Discover the stack. Read the source. Build with confidence.
 
-[![RuvNet Brain version 4.6.2 — README updated 2026-10-10 EDT](https://img.shields.io/badge/version_4.7.16-updated_2026--10--10_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](plugin/.claude-plugin/plugin.json)
+[![RuvNet Brain version 4.6.2 — README updated 2026-10-10 EDT](https://img.shields.io/badge/version_4.7.18-updated_2026--10--10_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](plugin/.claude-plugin/plugin.json)
 
 **A source-grounded companion for Claude Code and Codex that helps you find and use Reuven Cohen's (rUv's) RuvNet ecosystem.**
 
@@ -255,7 +255,7 @@ uses the protected release workflow; a consumer update downloads an available ge
 does not rebuild upstream knowledge. Check `--doctor`, `SOURCE.json` and refresh receipts
 before treating an installation as current.
 
-The **4.6.0 published-corpus baseline** is **203 public stores · 164,863 public source chunks**.
+The **4.6.0 published-corpus baseline** is **205 public stores · 165,488 public source chunks**.
 Those are bundle census values, not a claim that every upstream repository is fresh today.
 Later corpus publication may advance the knowledge generation independently of code changes.
 

package/bin/install.mjs

@@ -54,6 +54,8 @@ import {
   installNightlyRunner,
   installScheduler,
   nightlyArtifact,
+  nightlyModuleCurrency,
+  refreshNightlyModules,
   removeScheduler,
   readNightlyRegistration,
   resolveNightlyProofBundle,
@@ -2026,25 +2028,53 @@ export function codexMarketplaceRows(value) {
   return Array.isArray(value) ? value : [];
 }
 
-function runCodexJson(args, {
+// Codex refuses EVERY plugin command while any configured marketplace snapshot fails to load, including one that is
+// not the Brain's. Measured 2026-10-23: a 7:21 p.m. ET update failed host convergence on "`claude-code-plugins` at
+// ~/.codex/.tmp/marketplaces/claude-code-plugins: marketplace root does not contain a supported manifest" while Codex
+// was refreshing that Git snapshot; the same step passed at 5 a.m. Reproduced with a snapshot missing its manifest:
+// `codex plugin list` exits 1, and `codex plugin marketplace upgrade <name>` repairs it (codex-cli 0.164.0).
+const CODEX_SNAPSHOT_FAILURE = /failed to load configured marketplace snapshot/i;
+export function codexBrokenMarketplaces(text) {
+  return [...String(text || '').matchAll(/^- `([^`]+)` at /gm)].map((m) => m[1]);
+}
+const sleepSync = (ms) => { if (ms > 0) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); };
+
+export function runCodexJson(args, {
   codexBin = process.env.CODEX_BIN || 'codex',
   codexHome = codexHomeDir(),
   cwd = process.cwd(),
+  run = runHostCli,
+  waitMs = 5_000,
+  // Refreshing another tool's marketplace is a network write; only an install/update that is about to change the
+  // Brain's Codex plugin opts in. --doctor and listings report the broken snapshot and change nothing (review 2026-10-24).
+  repair = false,
 } = {}) {
-  const r = runHostCli(codexBin, args, {
-    stdio: 'pipe',
-    shell: false,
-    cwd,
-    env: { ...process.env, CODEX_HOME: codexHome },
-    encoding: 'utf8',
-    timeout: 30_000,
-    maxBuffer: 20 * 1024 * 1024,
-  });
+  const options = { stdio: 'pipe', shell: false, cwd, env: { ...process.env, CODEX_HOME: codexHome }, encoding: 'utf8',
+    timeout: 30_000, maxBuffer: 20 * 1024 * 1024 };
+  const snapshotFailure = (res) => !res.missingBinary && res.status !== 0 && CODEX_SNAPSHOT_FAILURE.test(String(res.stderr || res.stdout || ''));
+  let r = run(codexBin, args, options);
+  // One wait covers a refresh Codex is finishing; then refresh only the OTHER Git marketplaces it named (the Brain's
+  // own local snapshot is repaired by prepareCodexMarketplace), once, and ask again. Bounded: at most three asks.
+  const repaired = [];
+  if (snapshotFailure(r)) { sleepSync(waitMs); r = run(codexBin, args, options); }
+  if (repair && snapshotFailure(r)) {
+    for (const name of codexBrokenMarketplaces(r.stderr || r.stdout).filter((n) => n !== CODEX_MARKETPLACE)) {
+      const up = run(codexBin, ['plugin', 'marketplace', 'upgrade', name, '--json'], options);
+      repaired.push(`${name}: ${up.status === 0 ? 'refreshed' : `refresh failed (exit ${up.status})`}`);
+    }
+    if (repaired.length) r = run(codexBin, args, options);
+  }
   if (r.missingBinary) return { ok: false, error: r.message };
   if (r.error || r.status !== 0) {
-    const detail = String(r.stderr || r.stdout || r.error?.message || `exit ${r.status}`).trim();
-    return { ok: false, error: detail };
+    let detail = String(r.stderr || r.stdout || r.error?.message || `exit ${r.status}`).trim();
+    if (snapshotFailure(r)) {
+      const names = codexBrokenMarketplaces(r.stderr || r.stdout);
+      detail += ` — Codex cannot load its ${names.map((n) => `\`${n}\``).join(', ') || 'configured'} marketplace snapshot`
+        + `${repaired.length ? ` (tried: ${repaired.join('; ')})` : ''}; repair with: ${names.map((n) => `codex plugin marketplace upgrade ${n}`).join(' && ') || 'codex plugin marketplace upgrade'}`;
+    }
+    return { ok: false, error: detail, ...(repaired.length ? { repaired } : {}) };
   }
+  if (repaired.length && !TEST_MODE) info(`  Codex marketplace snapshot repaired before the Brain step (${repaired.join('; ')})`);
   try { return { ok: true, value: JSON.parse(r.stdout || 'null') }; }
   catch { return { ok: false, error: `Codex returned non-JSON output for ${args.join(' ')}` }; }
 }
@@ -2103,7 +2133,7 @@ export function wireCodexPlugin({
   aliasHome,
 } = {}) {
   if (!fs.existsSync(codexDir)) return { host: false, action: 'no-host' };
-  const options = { codexBin, codexHome, cwd };
+  const options = { codexBin, codexHome, cwd, repair: true };
   // Codex loads every configured marketplace before it can report plugin state. Repair only an
   // absent/malformed Brain-owned snapshot before that probe, or the probe can fail before its own
   // repair path is reachable. A healthy current cache stays byte-untouched, and plugin enablement
@@ -3179,8 +3209,14 @@ async function doctorRun({ json }) {
   const brainHome = process.env.RUVNET_BRAIN_HOME || path.dirname(cacheDir);
   const nightlyHealth = schedulerStatus({ platform: process.platform, env: process.env,
     brainHome, kbDir: cacheDir });
+  // Does the scheduled job run the code installed now? Its module snapshot is refreshed by --update, its runner only
+  // by --enable-nightly (measured stale 2026-10-22). Read-only; `unregistered` is already covered by the state lines.
+  let nightlyCode = { state: 'unregistered' };
+  try { nightlyCode = nightlyModuleCurrency({ brainHome, runnerSource: path.join(REPO_ROOT, 'bin', 'nightly-refresh.mjs') }); } catch (error) { nightlyCode = { state: 'unknown', why: error.message }; }
   if (nightlyHealth.state === 'on') {
     ok(`nightly scheduler: ${nightlyHealth.evidence}`);
+    if (nightlyCode.state === 'current') ok('nightly runs current code: the registered update modules are the installed set');
+    else if (nightlyCode.fix) warn(`nightly runs ${nightlyCode.state === 'runner-changed' ? 'an older runner' : 'stale update modules'} — fix:  ${c.bold(nightlyCode.fix)}`);
     if (nightlyHealth.runHealth?.state === 'ok' || nightlyHealth.runHealth?.state === 'running') {
       ok(`nightly execution: ${nightlyHealth.runHealth.evidence}`);
     } else if (nightlyHealth.runHealth?.state === 'failed') {
@@ -3436,6 +3472,10 @@ async function doctorRun({ json }) {
       : codexReadinessFailed ? 'MCP readiness blocked' : 'lifecycle hooks unhealthy') : 'wired', 'npx ruvnet-brain')] : []),
     check('nightly', 'Nightly', nightlyFailed, `${nightlyHealth.state}${nightlyHealth.runHealth?.state ? `, last run ${nightlyHealth.runHealth.state}` : ''}`,
       nightlyHealth.state === 'degraded' ? 'npx ruvnet-brain --enable-nightly' : 'npx ruvnet-brain --update'),
+    // Scheduler ON but running yesterday's code: an advisory naming the exact fix, never a failing verdict.
+    ...(nightlyHealth.state === 'on' && nightlyCode.state !== 'unregistered' ? [check('nightly-code', 'Nightly code', nightlyCode.state !== 'current',
+      nightlyCode.state === 'current' ? 'registered update modules match the installed set' : `${nightlyCode.state}: registered ${String(nightlyCode.registered || '?').slice(0, 12)}, installed ${String(nightlyCode.current || '?').slice(0, 12)}`,
+      nightlyCode.fix || 'npx ruvnet-brain@latest --update', { advisory: true })] : []),
     check('host-convergence', 'Hosts sync', !hostConvergence.healthy, hostConvergence.state, 'npx ruvnet-brain --update'),
     ...(rufloOperational ? [rufloCheckLine(rufloOperational)] : []),
     ...(agentdbLine ? [agentdbLine] : []),
@@ -3862,7 +3902,9 @@ export function syncHostsAfterUpdate(cacheDir = resolvedKbDir(), {
   const fail = (detail = {}) => {
     runtimeTransaction.rollback();
     hostLock.release();
-    return { ok: false, results, ...detail };
+    // Three paths below returned no error at all, so the refresh receipt recorded `state: null, error: null` and the
+    // failure could not be diagnosed afterwards (2026-10-23 7:21 p.m. ET). Every failure now carries its reason.
+    return { ok: false, results, ...detail, error: detail.error || hostFailureReason(results) };
   };
 
   try {
@@ -4023,6 +4065,18 @@ export function classifyHostConvergence(receipt, expectedVersion = PACKAGE_VERSI
 }
 
 /** Activation and host readiness are independent; never claim a rollback from a host refusal. */
+/** Why host synchronization stopped, from the per-host results it had gathered; null when nothing says. */
+export function hostFailureReason(results = {}) {
+  const firstLines = (text) => String(text || '').trim().split('\n').slice(0, 3).join(' ');
+  if (results.claude?.host && !results.claude.wired) {
+    return `Claude Code plugin ${results.claude.action || 'wiring failed'}${results.claude.version ? ` (installed ${results.claude.version}, required ${results.claude.expectedVersion || PACKAGE_VERSION})` : ''}`;
+  }
+  if (results.codex && !['unchanged', 'installed', 'updated', 'disabled'].includes(results.codex.action)) {
+    return `Codex plugin ${results.codex.action || 'failed'}${results.codex.error ? `: ${firstLines(results.codex.error)}` : ''}`;
+  }
+  return null;
+}
+
 export function hostSynchronizationFailureMessage(convergence, active, expectedVersion = PACKAGE_VERSION) {
   const verified = active?.version === expectedVersion && Number.isSafeInteger(active.generation) && active.generation > 0
     && active.codeRoot === `versions/${expectedVersion}`;
@@ -4081,11 +4135,36 @@ function refuseOverSetAsideBrain() {
   return true;
 }
 
+/**
+ * A SOURCE CHECKOUT older than the runtime already installed cannot apply the current release: it downloads ~736 MB
+ * and then refuses on "staged ReleaseCoverage failed integrity — release version 4.7.17 differs from 4.5.2" (measured
+ * 2026-10-23: `npx ruvnet-brain --update` run inside a stale checkout resolves that checkout's own bin). Say so
+ * before the download, with the command that works. Only a checkout: a published installer can legitimately be
+ * older than active.json (a plugin seeded from main during a release window, a release candidate installed from a
+ * checkout), and the nightly and self-heal `@latest` updates must keep working then (review, 2026-10-24).
+ */
+export function olderInstallerRefusal({ brainHome, packageVersion = PACKAGE_VERSION, repoRoot = REPO_ROOT } = {}) {
+  let installed;
+  try { installed = JSON.parse(fs.readFileSync(path.join(brainHome, 'active.json'), 'utf8'))?.version; } catch { return null; }
+  if (!/^\d+\.\d+\.\d+$/.test(String(installed || ''))) return null;
+  try { if (cmpVersion(installed, packageVersion) <= 0) return null; } catch { return null; }
+  if (!fs.existsSync(path.join(repoRoot, '.git'))) return null;
+  return `this is ruvnet-brain ${packageVersion}, a source checkout at ${repoRoot}, older than the ${installed} already `
+    + 'installed here, and an older checkout cannot apply the current release. '
+    + 'Run  npx ruvnet-brain@latest --update  from any other folder, or bring this checkout up to date first (git pull).';
+}
+
 async function runUpdate() {
   printBanner('update');
   refuseUnmountedBrain();
   const kbDir = resolvedKbDir();
   const brainHome = process.env.RUVNET_BRAIN_HOME || path.dirname(kbDir);
+  const olderInstaller = olderInstallerRefusal({ brainHome });
+  if (olderInstaller) {
+    console.error(`\n${c.red('✗ update stopped before downloading:')} ${olderInstaller}\n`);
+    process.exitCode = 1;
+    return;
+  }
   if (FLAG_HOST_SYNC_ONLY) {
     info(c.dim('repairing host shells and managed model catalog without mutating KB bytes…\n'));
     const convergence = syncHostsAfterUpdate(kbDir);
@@ -4404,6 +4483,7 @@ async function runUpdate() {
     info(c.dim("\n--auto set: enrolling in Evergreen auto-update so you never run this again…\n"));
     enableNightly(); // exits on its own with verified output; if it returns, fall through to the update verdict
   }
+  if (updateStatus === 0) reconcileNightlyModules({ brainHome, refreshReceipt });
   let retention;
   try {
     retention = pruneLifecycleEvidence({ brainHome, kbDir, preserveRefreshRunIds: [refreshReceipt.runId],
@@ -4443,6 +4523,31 @@ async function runUpdate() {
   await printConfirmation({ footprint: footprint?.after || null });
 }
 
+/**
+ * After a successful --update: the nightly runs a content-addressed SNAPSHOT of the update modules (installNightlyRunner),
+ * which until now only --enable-nightly refreshed, so a fix shipped by --update stayed invisible to the 03:30 job
+ * (measured 2026-10-22: the 4.7.15 developer-update fix). A stale registration is re-pointed at the installed modules;
+ * a changed RUNNER would change the LaunchAgent command, which only explicit enablement may do, so that case is an
+ * advisory naming the fix. Advisory and fail-open: it never fails an otherwise good update.
+ */
+export function reconcileNightlyModules({ brainHome, refreshReceipt = null, runnerSource = path.join(REPO_ROOT, 'bin', 'nightly-refresh.mjs') } = {}) {
+  const advise = (status, detail) => { // the advisory write itself must never escape this step
+    try { if (refreshReceipt) recordRefreshAdvisory(refreshReceipt, 'nightly-modules', status, detail); } catch { /* the receipt is evidence, not the gate */ }
+    return { status, ...detail };
+  };
+  try {
+    const nightly = refreshNightlyModules({ brainHome, runnerSource });
+    if (nightly.state === 'refreshed') ok(`nightly scheduler now runs the installed update modules (${nightly.registered.slice(0, 16)}…)`);
+    else if (nightly.state === 'runner-changed') warn(`nightly scheduler runs an older runner; the LaunchAgent changes only on explicit enablement — run  ${c.bold(nightly.fix)}`);
+    else if (nightly.state === 'refused') warn(`nightly module snapshot was not refreshed: ${nightly.reason} — run  ${c.bold(nightly.fix)}`);
+    return advise(['runner-changed', 'refused'].includes(nightly.state) ? 'SKIP' : 'PASS',
+      { state: nightly.state, registered: nightly.registered ?? null, current: nightly.current ?? null, ...(nightly.reason ? { reason: nightly.reason } : {}), ...(nightly.fix ? { fix: nightly.fix } : {}) });
+  } catch (error) {
+    warn(`nightly module snapshot was not refreshed (${error.message}); the scheduler registration was left as it was`);
+    return advise('FAIL', { state: 'error', reason: error.message });
+  }
+}
+
 function enableNightly() {
   printBanner('enable nightly updates');
   const kbDir = resolvedKbDir();
@@ -5612,7 +5717,7 @@ const rufloProbeRun = (args, cli = 'ruflo', timeoutMs = 10_000) => {
   // (verified live: ~/.npm-global/lib/node_modules/ruflo/node_modules/@claude-flow/cli/dist/src/
   // services/daemon-autostart.js:85) — a read-only health probe must not leave one running.
   const result = spawnSync(cli, args, { cwd: process.cwd(), encoding: 'utf8', timeout: timeoutMs, shell: IS_WIN && /\.(?:cmd|bat)$/i.test(cli),
-    env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' } });
+    env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' } });
   // A spawn failure or a timeout is marked, so it can never pass for an (empty, "healthy") answer.
   return `${result.stdout || ''}\n${result.stderr || ''}${result.error ? `\n[ruflo-probe-error] ${result.error.code || result.error.message}` : ''}`;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.7.16",
+  "version": "4.7.18",
   "description": "One-command installer for RuvNet Brain — a portable, source-grounded brain over rUv's RuvNet building blocks, delivered as a Claude Code plugin so Claude uses the stack instead of fighting it.",
   "type": "module",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ruvnet-brain",
   "description": "RuvNet brain transplant for Claude Code — grounds every RuvNet decision in real source across 77 rUv repositories, prefers Ruflo / RuVector-RVF / AgentDB over training-prior defaults (pgvector, Pinecone, hand-rolled cosine), and can pull in any RuvNet repo on demand. Ships a UserPromptSubmit retrieve-and-inject grounding hook and a PreToolUse write gate that refuses ungrounded rUv-product code until search_ruvnet has been consulted (ADR-0012 / ADR-067).",
-  "version": "4.7.16",
+  "version": "4.7.18",
   "author": {
     "name": "Stuart Kerr"
   },

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.7.16",
+  "version": "4.7.18",
   "description": "Source-grounded RuvNet knowledge, lifecycle enforcement, and learning for Codex.",
   "author": {
     "name": "Stuart Kerr"

package/plugin/hooks/grok-hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "RuvNet Brain lifecycle plane for Grok CLI. Grok selects this file through plugin/.grok-plugin/plugin.json (measured on grok 1.0.50: a plugin directory carrying that manifest registers ONLY this file, so the Claude registry plugin/hooks/hooks.json is not also run). Every command enters plugin/scripts/grok-hook-adapter.mjs, which normalizes the Grok payload, withholds Grok's non-Claude transcript, skips the session-end Stop fire, runs the SAME hook-shim.mjs bodies as Claude and Codex, and returns Grok-valid output. Registered: decision-gate write route (PreToolUse, the only refuser), session-snapshot and grounding-stamp (PostToolUse), grounding-turn-mark (UserPromptSubmit, a marker file only), continuation-gate + session-snapshot + grounding-turn-gate (Stop), session-snapshot (PreCompact, SessionEnd). Deliberately NOT registered on Grok: session-start, ground-ruvnet, unprompted-speech and capacity-aware-parallel-work. Grok ignores SessionStart stdout and discards an allowing UserPromptSubmit hook's stdout (~/.grok/docs/user-guide/10-hooks.md:113, :507, :531), so they would spend time on every session or prompt and deliver nothing, and session-start would consume the once-only hook-failure summary where nobody sees it. UNVERIFIED (docs silent, not measured): whether Grok honours a SessionEnd timeout above its 1.5 s default (10-hooks.md:477-478); the payload tool_name of an MCP search_ruvnet call and whether grounding-stamp accepts Grok's toolResult shape; PreCompact delivery (no compaction was driven); Windows expansion of ${GROK_PLUGIN_ROOT} (10-hooks.md:581 describes it; not measured).",
+  "description": "RuvNet Brain lifecycle plane for Grok CLI. Grok selects this file through plugin/.grok-plugin/plugin.json (measured on grok 1.0.50: a plugin directory carrying that manifest registers ONLY this file, so the Claude registry plugin/hooks/hooks.json is not also run). Every command enters plugin/scripts/grok-hook-adapter.mjs, which normalizes the Grok payload, withholds Grok's non-Claude transcript, skips the session-end Stop fire, runs the SAME hook-shim.mjs bodies as Claude and Codex, and returns Grok-valid output. Registered (9 handlers): decision-gate write route (PreToolUse, the only refuser registered on Grok), session-snapshot and grounding-stamp (PostToolUse), grounding-turn-mark (UserPromptSubmit, a marker file only), continuation-gate + session-snapshot + grounding-turn-gate (Stop), session-snapshot (PreCompact, SessionEnd). Deliberately NOT registered on Grok: session-start, ground-ruvnet, unprompted-speech and capacity-aware-parallel-work. Grok ignores SessionStart stdout and discards an allowing UserPromptSubmit hook's stdout (~/.grok/docs/user-guide/10-hooks.md:113, :507, :531), so they would spend time on every session or prompt and deliver nothing, and session-start would consume the once-only hook-failure summary where nobody sees it. SessionEnd: \"A plugin's SessionEnd hook runs for at most that default [1.5 s], whatever its timeout\" (10-hooks.md:644-645), so the 3 s timeout below is not honoured; the adapter budgets 1400 ms and hands it to the body as RUVNET_CODEX_BUDGET_MS, which detaches the checkpoint (the Codex 3 s SessionEnd path) instead of an inline store+readback Grok would kill partway. UNVERIFIED (docs silent, not measured): the payload tool_name of an MCP search_ruvnet call and whether grounding-stamp accepts Grok's toolResult shape; PreCompact delivery (no compaction was driven); Windows expansion of ${GROK_PLUGIN_ROOT} (10-hooks.md:581 describes it; not measured).",
   "hooks": {
     "PreToolUse": [
       {

package/plugin/hooks/hook-contracts.json

@@ -28,7 +28,8 @@
       "class": "continuation nudge",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "responsibility": "May request one continuation for one explicitly authorized, project-scoped objective read from the user's own work ledger (ADR-043). Never a refusal, never a second task store. Amended 2026-09-30 (ADR-074 class `completion`, no new registration): the same Stop body also requests ONE correction when the final answer claims work is done without a verification command run after the last state change this turn (Claude transcript), a named check, and a NOT-verified disclosure — on Codex, whose rollout format is not parsed, only the answer-side half is enforced and the transcript half is reported UNKNOWN. It also records first-person promises from the final answer into the SAME per-project ledger (Claude only; capped; closed only by a later evidence-passing completion claim, never by --done) and requests continuation on them under the same loop guards and cooldown. Amended 2026-10-11 (ADR-106, no new registration): the same body asks ONCE when a Claude answer ends by asking permission for, or postponing, work a standing instruction or open promise already authorized and names no genuine blocker class (no-deferral); Codex is not enforced because its prompts are not parsed."
     },
@@ -38,7 +39,8 @@
       "class": "continuity capture",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "responsibility": "Write the redacted turn outcome with one bounded `ruflo memory store` in namespace turns and prove it by exact-key readback; a refusal is a hook-failures row. No journal, outbox or replay."
     },
@@ -48,7 +50,8 @@
       "class": "continuity capture",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "responsibility": "Store one append-only project-state-auto-<ms> checkpoint through `ruflo memory store` and read it back by exact key; start turn distillation (`ruflo memory distill run`)."
     },
@@ -58,7 +61,8 @@
       "class": "continuity capture",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "responsibility": "Store one append-only project-state-auto-<ms> checkpoint through `ruflo memory store` and read it back by exact key; start turn distillation (`ruflo memory distill run`)."
     },
@@ -88,7 +92,8 @@
       "class": "consequential-action authorization",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "responsibility": "The ONE process that may refuse a Write/Edit/MultiEdit/NotebookEdit/apply_patch (ADR-067): composes protect-state, hijack-ruvnet, ground-before-write (ADR-0012), adr-currency and duplicate-code (2026-09-30: a new code file or large new export duplicating existing code in this checkout, refused at most once per path per session) into one decision with one reason. Fails open on its own errors. apply_patch is Codex's raw write-tool name, added to the shared matcher 2026-09-12 after a real apply_patch call was measured to fire PreToolUse live (codex-cli 0.154.0); codex-hook-adapter.mjs normalizes it to the same Edit shape decision-gate.mjs's policies already read on Claude."
     },
@@ -98,7 +103,8 @@
       "class": "grounding receipt",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "responsibility": "After a SUCCESSFUL search_ruvnet, records which rUv products were consulted (a 24h stamp per term named in the query). It is the key that opens ground-before-write; without it the write gate would refuse every rUv-product write forever. Extended to Codex 2026-09-12: a real MCP search_ruvnet call fired PostToolUse with tool_name mcp__ruvnet_brain__search_ruvnet, which the existing matcher already recognized unchanged."
     },
@@ -108,7 +114,8 @@
       "class": "grounding turn marker",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "responsibility": "Records that ground-ruvnet's Gate 1 (the same regex, proven byte-identical by test) matched this turn's prompt, so grounding-turn-gate has something to check at Stop — Stop's own payload carries no prompt text. Amended 2026-09-30: also arms when the prompt asks a capability/feasibility/architecture question about any tool or platform, recording the subjects it named; a marker not yet consumed is merged without moving its mtime (a queued mid-turn prompt re-dating it was a measured false-alarm cause). Writes only a marker file under ~/.cache/ruvnet-brain/grounding-turn/; never blocks, never speaks to the model."
     },
@@ -118,7 +125,8 @@
       "class": "answered-without-search enforcement",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "responsibility": "The 'answered without searching' gate (2026-09-12): if grounding-turn-mark's marker shows Gate 1 fired this turn and grounding-stamp's own stamp evidence shows no search_ruvnet call happened since, forces continuation via the same hookSpecificOutput.additionalContext contract continuation-gate already uses on both hosts. A separate registration from continuation-gate — see grounding-turn-gate.mjs's header for why folding it into that file's ledger/cooldown semantics would corrupt them rather than extend them. Consumes its marker unconditionally so a stale one can never pressure an unrelated later turn. Amended 2026-09-30 (ADR-0030 #1): on Claude, 'was search_ruvnet called' is read from the transcript, and on an armed turn each capability claim in the final answer must be bound to a relevant strong source read this turn after the last weak one, else ONE correction naming the claim and what was read; on Codex (rollout not parsed) only rUv-term claims are judged, from stamps, and the rest are UNKNOWN. Gates #2/#3 are shadow-logged, never delivered."
     },
@@ -128,7 +136,8 @@
       "class": "normalized continuity observation",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "responsibility": "When learning is opted in, write one minimized workflow observation with `ruflo memory store` + exact-key readback; a refusal is a hook-failures row. No queue."
     }
@@ -204,7 +213,8 @@
       "event": "Stop",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "mode": "advisory",
       "offBehavior": "run",
@@ -216,7 +226,8 @@
       "event": "Stop",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "mode": "advisory",
       "offBehavior": "run",
@@ -228,7 +239,8 @@
       "event": "PreCompact",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "mode": "advisory",
       "offBehavior": "run",
@@ -240,7 +252,8 @@
       "event": "SessionEnd",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "mode": "advisory",
       "offBehavior": "run",
@@ -276,7 +289,8 @@
       "event": "PreToolUse",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "mode": "blocking",
       "offBehavior": "run",
@@ -288,7 +302,8 @@
       "event": "PostToolUse",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "mode": "advisory",
       "offBehavior": "silence",
@@ -300,7 +315,8 @@
       "event": "UserPromptSubmit",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "mode": "advisory",
       "offBehavior": "silence",
@@ -312,7 +328,8 @@
       "event": "Stop",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "mode": "advisory",
       "offBehavior": "silence",
@@ -324,7 +341,8 @@
       "event": "PostToolUse",
       "hosts": [
         "claude",
-        "codex"
+        "codex",
+        "grok"
       ],
       "mode": "advisory",
       "offBehavior": "run",

package/plugin/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "RuvNet Brain lifecycle plane. The broad legacy routing, learning, and release interceptors remain retired. Lifecycle memory only CALLS ruflo (owner ruling 2026-10-12, ADR-106): there is no hand-rolled store, queue, journal or outbox. SessionStart restores the newest project-state-current-* checkpoint (and a newer project-state-auto-* one) and lists lesson keys by exact-key `ruflo memory list|retrieve`, and summarizes hook failures once. UserPromptSubmit runs the single unprompted-speech chokepoint, ground-ruvnet grounding injection (with one bounded AgentDB recall search), a capacity-aware context hint, and grounding-turn-mark. PreToolUse runs decision-gate's write route, the ONE process that may refuse a Write/Edit/MultiEdit/NotebookEdit/apply_patch (ADR-067, ADR-0012); PostToolUse on a successful search_ruvnet mints the grounding stamp that opens that gate, and session-snapshot PostToolUse writes an opted-in learning observation with `ruflo memory store`. Stop runs the continuation gate, writes the turn outcome with `ruflo memory store` in namespace turns proven by exact-key readback, and runs grounding-turn-gate. PreCompact and SessionEnd store one append-only project-state-auto-<ms> checkpoint with exact-key readback and start `ruflo memory distill run`. Every body is advisory and fails open except decision-gate; a refused or unverified ruflo write, or a body stopped by the shim watchdog, is one row in hook-failures.jsonl, summarized at the next SessionStart.",
+  "description": "RuvNet Brain lifecycle plane. The broad legacy routing, learning, and release interceptors remain retired. Lifecycle memory only CALLS ruflo (owner ruling 2026-10-12, ADR-106): there is no hand-rolled store, queue, journal or outbox. SessionStart restores the newest project-state-current-* checkpoint (and a newer project-state-auto-* one) and lists lesson keys by exact-key `ruflo memory list|retrieve`, and summarizes hook failures once. UserPromptSubmit runs the single unprompted-speech chokepoint, ground-ruvnet grounding injection (with one bounded AgentDB recall search), a capacity-aware context hint, and grounding-turn-mark. PreToolUse runs decision-gate's write route, the ONE process that may refuse a Write/Edit/MultiEdit/NotebookEdit/apply_patch (ADR-067, ADR-0012); PostToolUse on a successful search_ruvnet mints the grounding stamp that opens that gate, and session-snapshot PostToolUse writes an opted-in learning observation with `ruflo memory store`. Stop runs the continuation gate, writes the turn outcome with `ruflo memory store` in namespace turns proven by exact-key readback, and runs grounding-turn-gate. PreCompact and SessionEnd store one append-only project-state-auto-<ms> checkpoint with exact-key readback and start `ruflo memory distill run`. Every body is advisory and fails open except decision-gate (refuses a write) and unprompted-speech (exit 2 for an opted-in lesson block at UserPromptSubmit); a refused or unverified ruflo write, or a body stopped by the shim watchdog, is one row in hook-failures.jsonl, summarized at the next SessionStart.",
   "hooks": {
     "SessionStart": [
       {

package/plugin/scripts/agentdb-recall-process.mjs

@@ -33,7 +33,7 @@ export function searchOnce({ ruflo, store, args, deadline, env, scratch, operati
     catch { cleanup(); resolve({ rows: [], state: 'unavailable' }); return; }
     let child;
     try {
-      child = spawn(inv.executable, inv.args, { cwd, env: { ...env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_MEMORY_PATH: undefined },
+      child = spawn(inv.executable, inv.args, { cwd, env: { ...env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false', CLAUDE_FLOW_MEMORY_PATH: undefined },
         stdio: ['ignore', 'pipe', 'ignore'], detached: process.platform !== 'win32', windowsHide: true });
     } catch { cleanup(); resolve({ rows: [], state: 'unavailable' }); return; }
     let out = '', outputBytes = 0;

package/plugin/scripts/agentdb-recall-reader.mjs

@@ -8,7 +8,7 @@ import { resolveRuflo, rufloInvocationOrPlain } from './ruflo-bin.mjs';
 const call = (bin, args, deadline) => new Promise((resolve) => {
   const timeout = Math.max(1, deadline - Date.now());
   const inv = rufloInvocationOrPlain(bin, args, { env: process.env });
-  execFile(inv.executable, inv.args, { timeout, killSignal: 'SIGKILL', encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' } },
+  execFile(inv.executable, inv.args, { timeout, killSignal: 'SIGKILL', encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false' } },
     (error, stdout) => resolve(error ? null : String(stdout || '')));
 });
 

package/plugin/scripts/brain-confirmation.mjs

@@ -181,8 +181,15 @@ export function confirm({ footprint, env = process.env, home = os.homedir(), now
   // Footprint
   const parts = Object.entries(footprint.breakdown).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k} ${formatBytes(v)}`);
   const foreign = footprint.unowned.reduce((n, i) => n + (i.bytes || 0), 0);
+  // `--clean` is the fix only when it can remove something. Measured 2026-10-24: 3.01 GB of a 2.23 GB budget with
+  // zero cruft, the line said "fix: --clean", and --clean freed nothing — the bytes were a 1.3 GB npm install ruflo's
+  // self-update left in ruvnet-brain/ruflo-cwd, counted as Brain state. Name where the bytes are instead.
+  const reclaimable = footprint.cruft.some((i) => ['remove', 'remove-if-proven', 'rotate', 'truncate', 'collect', 'prune'].includes(i.action));
+  const largest = footprint.items.filter((i) => i.kind === 'state' && i.bytes).sort((a, b) => b.bytes - a.bytes).slice(0, 2);
+  const footprintFix = reclaimable || !largest.length ? CLEAN
+    : `${CLEAN} has nothing to remove; the largest Brain folders are ${largest.map((i) => `${i.path} (${formatBytes(i.bytes)})`).join(' and ')} — see what is filling them`;
   lines.push(line('footprint', 'Footprint', footprint.withinBudget ? 'ok' : 'fail',
-    `${formatBytes(footprint.totalBytes)} of ${formatBytes(footprint.budgetBytes)} budget (${parts.join(' · ')})${foreign ? `; not counted: ${formatBytes(foreign)} owned by other tools` : ''}`, CLEAN));
+    `${formatBytes(footprint.totalBytes)} of ${formatBytes(footprint.budgetBytes)} budget (${parts.join(' · ')})${foreign ? `; not counted: ${formatBytes(foreign)} owned by other tools` : ''}`, footprintFix));
 
   // No cruft
   const cruft = footprint.cruft;

package/plugin/scripts/brain-footprint.mjs

@@ -25,6 +25,7 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { isKbTree, kbCopyProof } from './kb-copy-proof.mjs';
 import { brainLocation } from './brain-location.mjs';
+import { RUFLO_CWD_ARTIFACTS } from './ruflo-bin.mjs';
 import { assessMoveLeftovers, cachedKept, cmpVersion, isVolumeMetadata, keptCopyFix, physical, pidAlive, readProofCache, rememberKept, removeWithin, rotate,
   treeBytes, truncateToTail } from './footprint-io.mjs';
 
@@ -59,7 +60,8 @@ export const LOG_FILES = Object.freeze(['evidence.jsonl', 'token-ledger.jsonl',
   'capability-live-evidence.jsonl', 'design-grades.jsonl', 'grounding-overrides.jsonl']);
 const TEXT_LOG = /^\.(?:last-[A-Za-z0-9-]+|seed)\.log$/;
 const RECOVERY_LEFTOVER = /(?:\.(?:bak|retired|dead)-\d{6,}|^bootstrap-backup-\d)/;
-const RUFLO_DEBRIS = new Set(['.swarm', '.claude', '.claude-flow', 'ruvector.db']);
+// One list with ruflo-bin.mjs, which clears the same names before each call (incl. a self-update's npm install, 1.3 GB on 2026-10-22).
+const RUFLO_DEBRIS = new Set(RUFLO_CWD_ARTIFACTS);
 // Directories in the brain home that hold data another tool owns: measured, shown, never budgeted or removed.
 const FOREIGN = { 'ruvector-mcp': 'RuVector MCP server working store (its own live memory)',
   'worktree-recovery': 'hand-made recovery archives, not created by the Brain' };

package/plugin/scripts/continuity-hook-policy.mjs

@@ -134,7 +134,7 @@ export const CONTINUITY_EVENTS = Object.freeze({
     // The "answered without searching" gate, half 1 of 2 (2026-09-12) — see grounding-turn-gate.mjs's
     // header for the full rationale. Records that ground-ruvnet's Gate 1 fired for this turn, since
     // Stop's own payload carries no prompt text for grounding-turn-gate to test.
-    registration('grounding-turn-mark', '*', ['claude', 'codex']),
+    registration('grounding-turn-mark', '*', ['claude', 'codex', 'grok']),
   ]),
   // The write gate and its key (ADR-0012 / ADR-067), re-registered 2026-09-11 — see the header.
   // Extended to Codex 2026-09-12: a real `apply_patch` write was measured to fire PreToolUse on
@@ -143,7 +143,7 @@ export const CONTINUITY_EVENTS = Object.freeze({
   // Claude's `Edit` shape for decision-gate.mjs's own policies (protect-state, hijack-ruvnet,
   // ground-before-write, adr-currency all then see tool_name:"Edit" exactly as on Claude).
   PreToolUse: Object.freeze([
-    registration('decision-gate', '^(Write|Edit|MultiEdit|NotebookEdit|apply_patch)$', ['claude', 'codex']),
+    registration('decision-gate', '^(Write|Edit|MultiEdit|NotebookEdit|apply_patch)$', ['claude', 'codex', 'grok']),
   ]),
   // Extended to Codex 2026-09-12: a real MCP `search_ruvnet` call was measured to fire PostToolUse
   // on codex-cli 0.154.0 with tool_name "mcp__ruvnet_brain__search_ruvnet" — the matcher below
@@ -153,18 +153,18 @@ export const CONTINUITY_EVENTS = Object.freeze({
   // "Searched N RuvNet repos" banner and query text the script already looks for).
   PostToolUse: Object.freeze([
     // Learning observation (consent-gated `ruflo memory store`) runs inside session-snapshot's PostToolUse body.
-    registration('session-snapshot', '*', ['claude', 'codex']),
-    registration('grounding-stamp', '^(?:.*__)?search_ruvnet$', ['claude', 'codex']),
+    registration('session-snapshot', '*', ['claude', 'codex', 'grok']),
+    registration('grounding-stamp', '^(?:.*__)?search_ruvnet$', ['claude', 'codex', 'grok']),
   ]),
   Stop: Object.freeze([
-    registration('continuation-gate', '*', ['claude', 'codex']),
+    registration('continuation-gate', '*', ['claude', 'codex', 'grok']),
     // Codex added 2026-09-29 (owner requirement: every turn's outcome recorded on BOTH hosts —
     // turn-outcome-capture.mjs). Codex SessionEnd carries no last_assistant_message, so Stop is the
     // only boundary that can record a Codex turn. Evidence: codex-cli 0.158.0's own
     // stop.command.input schema (last_assistant_message, turn_id) and the two Codex Stop handlers
     // already registered above/below. NOT yet live-observed firing — see the probe box: the capture
     // fails open, so an unfired registration costs nothing but must not be read as proof.
-    registration('session-snapshot', '*', ['claude', 'codex']),
+    registration('session-snapshot', '*', ['claude', 'codex', 'grok']),
     // The "answered without searching" gate, half 2 of 2 (2026-09-12). Forces continuation
     // (hookSpecificOutput.additionalContext — the same contract continuation-gate.mjs already uses
     // and codex-hook-adapter.mjs already translates to Codex's decision:block on both hosts) when
@@ -172,13 +172,13 @@ export const CONTINUITY_EVENTS = Object.freeze({
     // (grounding-stamp.sh) postdates it. A separate registration from continuation-gate on purpose —
     // see grounding-turn-gate.mjs's header for why folding it in would corrupt that file's ledger
     // semantics rather than extend them.
-    registration('grounding-turn-gate', '*', ['claude', 'codex']),
+    registration('grounding-turn-gate', '*', ['claude', 'codex', 'grok']),
   ]),
   PreCompact: Object.freeze([
-    registration('session-snapshot', '*', ['claude', 'codex']),
+    registration('session-snapshot', '*', ['claude', 'codex', 'grok']),
   ]),
   SessionEnd: Object.freeze([
-    registration('session-snapshot', '*', ['claude', 'codex']),
+    registration('session-snapshot', '*', ['claude', 'codex', 'grok']),
   ]),
 });
 

package/plugin/scripts/decision-record.mjs

@@ -138,7 +138,7 @@ function runRuflo(ruflo, db, args, { spawn = spawnSync } = {}) {
   try {
     const { executable, args: argv } = rufloInvocation(ruflo, args);
     const r = spawn(executable, argv, { cwd, encoding: 'utf8', timeout: 60_000, windowsHide: true,
-      env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_MEMORY_PATH: undefined } });
+      env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false', CLAUDE_FLOW_MEMORY_PATH: undefined } });
     return { status: Number.isInteger(r.status) ? r.status : 1, stdout: String(r.stdout || ''), output: `${r.stderr || ''}\n${r.stdout || ''}${r.error ? `\n${r.error.message}` : ''}` };
   } finally { fs.rmSync(cwd, { recursive: true, force: true }); }
 }