ruvnet-brain 4.7.15 → 4.7.17

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.15-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.17-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,668 public source chunks**.
+The **4.6.0 published-corpus baseline** is **205 public stores · 165,153 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,
@@ -3179,8 +3181,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 +3444,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] : []),
@@ -4404,6 +4416,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 +4456,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.7.15",
+  "version": "4.7.17",
   "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.15",
+  "version": "4.7.17",
   "author": {
     "name": "Stuart Kerr"
   },

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

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.7.15",
+  "version": "4.7.17",
   "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/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/coverage-integrity.mjs

@@ -293,11 +293,17 @@ export function eligibleRepositoryStanding(row) {
   if (status === 'CURRENT') return carry === undefined && failure === undefined ? 'shipped' : null;
   if (status === 'STALE' && carry && typeof carry === 'object' && failure === undefined) {
     const carried = String(carry.carriedSourceCommit || '').toLowerCase();
+    const upstream = String(row.upstream?.sha || '').toLowerCase();
+    // Two honest shapes. A refresh that FAILED: upstream was read, differs from the carried commit, and is named
+    // as missedUpstream. An upstream nobody could READ tonight (transient, source-coverage.mjs): the row is pinned
+    // at the carried commit, says `upstreamUnavailable`, and missedUpstream is null -- unknown, never invented.
+    const missed = String(carry.missedUpstream || '').toLowerCase();
+    const upstreamKnown = HEX40.test(missed) && missed === upstream && carried !== missed;
+    const upstreamUnread = carry.missedUpstream === null && row.upstreamUnavailable === true && row.upstreamUnavailableKind === 'transient'
+      && carry.reason === 'transient: upstream unreadable' && carried === upstream;
     const shipped = typeof carry.reason === 'string' && carry.reason.length > 0
       && HEX40.test(carried) && carried === String(row.artifact?.sourceCommit || '').toLowerCase()
-      && HEX40.test(String(carry.missedUpstream || '').toLowerCase())
-      && String(carry.missedUpstream).toLowerCase() === String(row.upstream?.sha || '').toLowerCase()
-      && carried !== String(carry.missedUpstream).toLowerCase()
+      && (upstreamKnown || upstreamUnread)
       && isAttemptCount(carry.attempts) && isIsoOrNull(carry.carriedCommittedAt)
       && row.artifact?.bytesVerified === true && row.artifact?.passagesPresent === true;
     return shipped ? 'shipped' : null;

package/plugin/scripts/grok-hook-adapter.mjs

@@ -48,11 +48,14 @@ export const GROK_OUTPUT_EVENTS = Object.freeze(new Set(['PreToolUse', 'PostTool
 
 /**
  * This adapter's own kill budget, below the registration timeout in grok-hooks.json so the adapter,
- * not Grok, ends a slow body and records it. SessionEnd: Grok bounds each SessionEnd hook by its own
- * timeout (default 1.5 s, 10-hooks.md:477-478); 2200 ms sits under the 3 s registration.
+ * not Grok, ends a slow body and records 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 budget sits under 1500 ms and
+ * is handed to the body (RUVNET_CODEX_BUDGET_MS, the host-budget seam the Codex wrapper already uses), which
+ * then detaches its checkpoint instead of starting an inline store+readback Grok would kill partway.
  */
+export const SESSION_END_BUDGET_MS = 1_400;
 export function budgetFor(hookId, event) {
-  if (event === 'SessionEnd') return 2_200;
+  if (event === 'SessionEnd') return SESSION_END_BUDGET_MS;
   if (hookId === 'decision-gate') return 6_500;
   if (hookId === 'grounding-stamp' || hookId === 'grounding-turn-mark') return 4_000;
   return 8_500;
@@ -133,6 +136,7 @@ async function main() {
     CLAUDE_PROJECT_DIR: projectDir,
     CLAUDE_SESSION_ID: String(payload.session_id || process.env.GROK_SESSION_ID || ''),
     RUVNET_HOOK_HOST: 'grok',
+    ...(event === 'SessionEnd' ? { RUVNET_CODEX_BUDGET_MS: String(budget) } : {}), // the body plans inside Grok's 1.5 s
   };
   const r = spawnSync(process.execPath, [path.join(HERE, 'hook-shim.mjs'), hookId, ...extra], {
     input: JSON.stringify(payload), encoding: 'utf8', env, cwd, timeout: budget, killSignal: 'SIGKILL',

package/plugin/scripts/hook-failures.mjs

@@ -9,16 +9,21 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { createHash } from 'node:crypto';
 
 export const FAILURE_FILE = 'hook-failures.jsonl';
 export const FAILURE_LINE_PREFIX = '[RuvNet Brain — HOOK FAILURES]';
 const CURSOR_FILE = 'hook-failures.cursor';
+const WINDOW_FILE = 'hook-failures.window.json';
 const MAX_READ = 256 * 1024;
+export const REPEAT_WINDOW_MS = 10 * 60_000;
+const MAX_WINDOWS = 64;
 
 /** Summarize failures recorded after the cursor; advance it. Returns '' when there is nothing new. */
-export function failureLine(brainHome, { advance = true } = {}) {
+export function failureLine(brainHome, { advance = true, now = Date.now() } = {}) {
   const file = path.join(brainHome, FAILURE_FILE);
   const cursorFile = path.join(brainHome, CURSOR_FILE);
+  try { flushRepeats(brainHome, now, { all: true }); } catch { /* the rows already on disk are still reported */ } // the report is now
   let size;
   try { size = fs.statSync(file).size; } catch { return ''; }
   let offset = 0;
@@ -33,29 +38,92 @@ export function failureLine(brainHome, { advance = true } = {}) {
   if (advance) { try { fs.writeFileSync(cursorFile, JSON.stringify({ offset: size })); } catch { /* re-reported next session */ } }
   if (!rows.length) return '';
   const byHook = new Map();
+  let total = 0;
   for (const r of rows) {
     const id = String(r.hook || 'unknown').slice(0, 40);
-    const why = r.note ? String(r.note).split(':')[0].slice(0, 48) : r.error ? String(r.error).slice(0, 40) : r.signal ? String(r.signal) : `exit ${r.status}`;
+    const why = r.note ? String(r.note).split(':')[0].slice(0, 48) : r.error ? String(r.error).replace(/ \(repeated\)$/, '').slice(0, 40) : r.signal ? String(r.signal) : `exit ${r.status}`;
     const e = byHook.get(id) || { n: 0, why: new Set() };
-    e.n += 1; e.why.add(why); byHook.set(id, e);
+    const n = Number(r.count) > 0 ? Number(r.count) : 1; // an aggregated row stands for `count` runs
+    e.n += n; total += n; e.why.add(why); byHook.set(id, e);
   }
   const parts = [...byHook.entries()].sort((a, b) => b[1].n - a[1].n)
     .map(([id, e]) => `${id} ×${e.n} (${[...e.why].slice(0, 3).join(', ')})`);
-  return `${FAILURE_LINE_PREFIX} ${rows.length} advisory hook run(s) did not complete or did not resolve since ${rows[0].at}: ${parts.join('; ')}. `
+  return `${FAILURE_LINE_PREFIX} ${total} advisory hook run(s) did not complete or did not resolve since ${rows[0].at}: ${parts.join('; ')}. `
     + `They failed open. Details: ${file}`;
 }
 
+function appendRow(brainHome, row) {
+  const file = path.join(brainHome, FAILURE_FILE);
+  fs.mkdirSync(brainHome, { recursive: true });
+  try { if (fs.statSync(file).size > 256 * 1024) fs.renameSync(file, `${file}.1`); } catch { /* absent */ }
+  fs.appendFileSync(file, `${JSON.stringify(row)}\n`, { mode: 0o600 });
+}
+
+/** Hashes and long numbers vary per row (`workflow-<sha>`, pids, ms, timestamps); short ones (exit codes, counts) are the error. */
+export const normalizeFailure = (text) => String(text || '').replace(/[0-9a-f]{16,}/gi, '*').replace(/\d{5,}/g, 'N').slice(0, 160);
+const windowFile = (brainHome) => path.join(brainHome, WINDOW_FILE);
+/**
+ * A window entry must be one this module could have written: a real epoch `at` no later than one window ahead (a
+ * Date cannot hold -1e300 or 1e300, and 8.64e15+1 never expires), an integer count ≥ 1, string hook and error.
+ * Entries failing that are dropped, the rest kept; any other file shape is an empty window file.
+ */
+const validWindow = (w, now) => w && typeof w === 'object' && !Array.isArray(w) && Number.isFinite(w.at) && w.at >= 0 && w.at <= now + REPEAT_WINDOW_MS
+  && Number.isInteger(w.count) && w.count >= 1 && typeof w.hook === 'string' && typeof w.error === 'string';
+function loadWindows(brainHome, now) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(windowFile(brainHome), 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
+    return Object.fromEntries(Object.entries(parsed).filter(([, w]) => validWindow(w, now)));
+  } catch { return {}; }
+}
+function saveWindows(brainHome, windows) { // rename, so a concurrent reader never sees a torn file
+  const tmp = `${windowFile(brainHome)}.${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(windows), { mode: 0o600 }); fs.renameSync(tmp, windowFile(brainHome));
+}
+
+/** A closed window whose repeats were held back becomes ONE row carrying their count. */
+function closeWindow(brainHome, w, now) {
+  if (w.count > 1) appendRow(brainHome, { at: new Date(now).toISOString(), hook: w.hook, event: w.event, error: `${w.error} (repeated)`, count: w.count - 1, since: new Date(w.at).toISOString() });
+}
+
+/** Close the expired windows; `all` closes the open ones too (SessionStart reports now). Returns the windows left open. */
+function flushRepeats(brainHome, now, { all = false } = {}) {
+  const windows = loadWindows(brainHome, now);
+  let changed = false;
+  for (const [sig, w] of Object.entries(windows)) {
+    if (!all && now - w.at < REPEAT_WINDOW_MS) continue;
+    try { closeWindow(brainHome, w, now); } catch { /* one bad window must not stop the others being reported */ }
+    delete windows[sig]; changed = true;
+  }
+  if (changed) try { saveWindows(brainHome, windows); } catch { /* the rows are written; the window file is a cache */ }
+  return windows;
+}
+
 /**
  * The writer for bodies that run OUTSIDE the shim's watchdog (a refused `ruflo memory store`, a failed
  * exact readback). Same file, same row shape as hook-shim.mjs's inlined recordFailure, so the next
  * SessionStart's failureLine() reports it. Never throws: an unrecordable failure must not become a second one.
+ *
+ * REPEATS ARE COUNTED, NOT APPENDED (measured 2026-10-21: 1,162 rows, 826 of them one learn-capture failure
+ * repeated, so the real failures were invisible). The first occurrence of (hook, event, normalized error)
+ * is a row at once; repeats inside REPEAT_WINDOW_MS only increment a count in hook-failures.window.json,
+ * and the window closes as ONE row carrying `count`. Distinct errors keep distinct rows. The window file has no
+ * lock: two writers racing can lose an increment (under-count), and two processes closing the same expired window
+ * can both write its count row (over-count). Tolerated: the ledger is a signal, never an audit. The first row is
+ * appended BEFORE its window is saved, so a failed append never leaves a window claiming a row that is not there.
  */
-export function recordHookFailure(fields, { brainHome = process.env.RUVNET_BRAIN_HOME || path.join(os.homedir(), '.cache', 'ruvnet-brain') } = {}) {
+export function recordHookFailure(fields, { brainHome = process.env.RUVNET_BRAIN_HOME || path.join(os.homedir(), '.cache', 'ruvnet-brain'), now = Date.now() } = {}) {
   try {
-    const file = path.join(brainHome, FAILURE_FILE);
     fs.mkdirSync(brainHome, { recursive: true });
-    try { if (fs.statSync(file).size > 256 * 1024) fs.renameSync(file, `${file}.1`); } catch { /* absent */ }
-    fs.appendFileSync(file, `${JSON.stringify({ at: new Date().toISOString(), ...fields })}\n`, { mode: 0o600 });
+    const windows = flushRepeats(brainHome, now);
+    const error = normalizeFailure(fields.error ?? fields.note ?? (fields.signal || `exit ${fields.status}`));
+    const sig = createHash('sha256').update(`${fields.hook}\0${fields.event || ''}\0${error}`).digest('hex').slice(0, 16);
+    if (windows[sig]) { windows[sig].count += 1; saveWindows(brainHome, windows); return true; }
+    appendRow(brainHome, { at: new Date(now).toISOString(), ...fields });
+    windows[sig] = { at: now, count: 1, hook: fields.hook, event: fields.event || '', error };
+    const oldest = Object.keys(windows).sort((a, b) => windows[a].at - windows[b].at).slice(0, Math.max(0, Object.keys(windows).length - MAX_WINDOWS));
+    for (const old of oldest) { closeWindow(brainHome, windows[old], now); delete windows[old]; } // bounded: the oldest close early
+    try { saveWindows(brainHome, windows); } catch { /* the row is on disk; the next repeat starts a fresh window */ }
     return true;
   } catch { return false; }
 }