ruvnet-brain 4.7.16 → 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.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.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,863 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.16",
+  "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.16",
+  "version": "4.7.17",
   "author": {
     "name": "Stuart Kerr"
   },

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

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.7.16",
+  "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/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; }
 }

package/plugin/scripts/learn-capture.mjs

@@ -1,14 +1,66 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
 import os from 'node:os';
+import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { readStdinBounded } from './hook-input.mjs';
 import { learningContext } from './runtime-preferences.mjs';
-import { recordLearningObservation, distillObservations } from './learning-store.mjs';
+import { recordLearningObservation, distillObservations, observationKey } from './learning-store.mjs';
 import { resolveRuflo } from './ruflo-bin.mjs';
 import { recordHookFailure } from './hook-failures.mjs';
 
+// LOAD BOUNDS (measured 2026-10-21: one busy session spawned hundreds of concurrent detached `ruflo memory store`
+// children, which timed out against each other and wrote 826 ledger rows in a day). Owner ruling 2026-10-12 stands:
+// no local queue, no replay — an observation that finds no slot is DROPPED and counted.
+export const OBSERVE_SLOTS = 2;           // detached --observe children alive at once, per Brain home
+export const SLOT_STALE_MS = 60_000;      // a slot older than this, or held by a dead pid, is reclaimed
+export const COALESCE_MS = 10 * 60_000;   // an identical observation key inside this window does not spawn again
+const defaultBrainHome = (env) => env.RUVNET_BRAIN_HOME || path.join(os.homedir(), '.cache', 'ruvnet-brain');
+const learnDir = (brainHome, sub) => { const dir = path.join(brainHome, 'learn-capture', sub); fs.mkdirSync(dir, { recursive: true, mode: 0o700 }); return dir; };
+
+/** Parent-side coalescing: marker file per key under `learn-capture/recent/`, pruned when it grows past 256 entries. */
+export function recentlyCaptured(brainHome, key, now = Date.now()) {
+  try { return now - fs.statSync(path.join(learnDir(brainHome, 'recent'), key)).mtimeMs < COALESCE_MS; } catch { return false; }
+}
+export function markCaptured(brainHome, key, now = Date.now()) {
+  const dir = learnDir(brainHome, 'recent');
+  try { fs.writeFileSync(path.join(dir, key), '', { mode: 0o600 }); } catch { return; }
+  const names = fs.readdirSync(dir);
+  if (names.length > 256) for (const name of names) { try { if (now - fs.statSync(path.join(dir, name)).mtimeMs >= COALESCE_MS) fs.unlinkSync(path.join(dir, name)); } catch { /* raced */ } }
+}
+
+function slotStale(slot, now) {
+  let held;
+  try { held = JSON.parse(fs.readFileSync(slot, 'utf8')); } catch { try { return now - fs.statSync(slot).mtimeMs > SLOT_STALE_MS; } catch { return false; } }
+  if (!Number.isInteger(held?.pid) || now - Number(held.at) > SLOT_STALE_MS) return true;
+  try { process.kill(held.pid, 0); return false; } catch (error) { return error.code === 'ESRCH'; }
+}
+/** O_EXCL slot files `learn-capture/slots/slot-N`; a stale one is reclaimed by rename, so only one claimant wins it. */
+export function acquireObserveSlot(brainHome, now = Date.now()) {
+  const dir = learnDir(brainHome, 'slots');
+  for (let i = 0; i < OBSERVE_SLOTS; i += 1) {
+    const slot = path.join(dir, `slot-${i}`);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try { fs.writeFileSync(slot, JSON.stringify({ pid: process.pid, at: now }), { flag: 'wx', mode: 0o600 }); return slot; } catch (error) { if (error.code !== 'EEXIST') break; }
+      if (!slotStale(slot, now)) break;
+      const claim = `${slot}.reclaim-${process.pid}`;
+      try { fs.renameSync(slot, claim); fs.unlinkSync(claim); } catch { break; } // another claimant took it
+    }
+  }
+  return null;
+}
+export function releaseObserveSlot(slot, pid = process.pid) {
+  try { if (JSON.parse(fs.readFileSync(slot, 'utf8')).pid === pid) fs.unlinkSync(slot); } catch { /* reclaimed already */ }
+}
+
+/** Every shed is one fixed-string ledger call; hook-failures.mjs's own window counts the repeats on one row. */
+export const SHED_ERROR = 'shed observation (load)';
+export function shedObservation(brainHome) {
+  recordHookFailure({ hook: 'learn-capture', event: 'PostToolUse', error: SHED_ERROR }, { brainHome });
+  return false;
+}
+
 // Fixed vocabulary: arbitrary executable names, arguments, basenames and paths never persist.
 const verbs = new Set('git npm node python python3 cargo rustc go gh cd ls rg cat export mkdir rm cp mv bash sh curl wget npx ruflo'.split(' '));
 const subs = new Set('status diff log show add commit push pull fetch checkout switch branch test run install ci build check fmt clippy auth workflow release memory hooks'.split(' '));
@@ -30,7 +82,7 @@ export function safeAction(tool, value) {
  * session-snapshot's PostToolUse boundary. learningContext() owns consent and brain-off. A refused or
  * unverified write is LOUD: one row in the hook-failures ledger, summarized at the next SessionStart.
  */
-export function captureLearning(input, { env = process.env, binary = resolveRuflo({ env }), brainHome, detach = false } = {}) {
+export function captureLearning(input, { env = process.env, binary = resolveRuflo({ env }), brainHome = defaultBrainHome(env), detach = false } = {}) {
   let tool; let action;
   try {
     const context = learningContext();
@@ -48,24 +100,37 @@ export function captureLearning(input, { env = process.env, binary = resolveRufl
     if (!['Bash', 'Write', 'Edit', 'MultiEdit'].includes(tool)) return false;
     action = safeAction(tool, tool === 'Bash' ? input.tool_input?.command : 'edit file');
     if (!action) return false;
-    if (!binary) throw new Error('ruflo not found');
+    if (!binary) throw new Error('ruflo not found'); // one ledger row per 10 min: recordHookFailure counts the repeats
     const observation = { tool, action, session: String(input.session_id || '') };
+    const key = observationKey(observation);
+    if (recentlyCaptured(brainHome, key)) return true; // identical observation already captured this window: no process
     // Review M3: on the hook path the store + exact readback run in a detached, bounded child, so the
     // tool call returns at once; that child writes the ledger row if the write is refused or unverified.
-    if (detach) return detachLearning('--observe', { env, brainHome, observation });
+    if (detach) {
+      const slot = acquireObserveSlot(brainHome);
+      if (!slot) return shedObservation(brainHome);
+      markCaptured(brainHome, key);
+      return detachLearning('--observe', { env: { ...env, RUFLO_BIN: binary }, brainHome, observation, slot });
+    }
     recordLearningObservation(binary, context, observation, { env, deadline: Date.now() + 6000 });
+    markCaptured(brainHome, key);
     return true;
   } catch (error) {
-    if (tool && action) recordHookFailure({ hook: 'learn-capture', event: 'PostToolUse', error: String(error?.message || error).slice(0, 160) }, brainHome ? { brainHome } : undefined);
+    if (tool && action) recordHookFailure({ hook: 'learn-capture', event: 'PostToolUse', error: String(error?.message || error).slice(0, 160) }, { brainHome });
     return false;
   }
 }
 
-/** Detached, bounded child (`--observe` one observation, `--distill` the namespace). Only fixed-vocabulary fields cross. */
-export function detachLearning(mode, { env = process.env, brainHome, observation } = {}) {
+/**
+ * Detached, bounded child (`--observe` one observation, `--distill` the namespace). Only fixed-vocabulary fields
+ * cross. The parent's resolved ruflo travels as RUFLO_BIN (resolveRuflo's authoritative seam), so the child never
+ * re-resolves it; the slot it holds travels as RUVNET_LEARN_SLOT and is re-stamped with the child's pid.
+ */
+export function detachLearning(mode, { env = process.env, brainHome, observation, slot } = {}) {
   const child = spawn(process.execPath, [fileURLToPath(import.meta.url), mode], { cwd: process.cwd(), detached: true, stdio: 'ignore', windowsHide: true,
-    env: { ...env, ...(observation ? { RUVNET_LEARN_OBSERVATION: JSON.stringify(observation) } : {}), ...(brainHome ? { RUVNET_BRAIN_HOME: brainHome } : {}) } });
+    env: { ...env, ...(observation ? { RUVNET_LEARN_OBSERVATION: JSON.stringify(observation) } : {}), ...(brainHome ? { RUVNET_BRAIN_HOME: brainHome } : {}), ...(slot ? { RUVNET_LEARN_SLOT: slot } : {}) } });
   child.unref();
+  if (slot) { try { fs.writeFileSync(slot, JSON.stringify({ pid: child.pid, at: Date.now() }), { mode: 0o600 }); } catch { /* reclaimed by age */ } }
   return true;
 }
 
@@ -80,7 +145,7 @@ function runDetached(mode) {
     const o = JSON.parse(process.env.RUVNET_LEARN_OBSERVATION || '{}');
     if (!['Bash', 'Write', 'Edit', 'MultiEdit'].includes(o.tool) || typeof o.action !== 'string') throw new Error('invalid detached observation');
     recordLearningObservation(binary, context, { tool: o.tool, action: o.action, session: String(o.session || '') }, { env: process.env, deadline: Date.now() + 14_000, allowed: () => learningContext().enabled });
-  } catch (error) { fail(error); }
+  } catch (error) { fail(error); } finally { if (process.env.RUVNET_LEARN_SLOT) releaseObserveSlot(process.env.RUVNET_LEARN_SLOT); }
 }
 
 const isMain = (() => { try { return Boolean(process.argv[1]) && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url)); } catch { return false; } })();

package/plugin/scripts/learning-store.mjs

@@ -42,22 +42,32 @@ export function runLearningRuflo(binary, args, db, { env = process.env, deadline
  * No local queue, no worker, no replay (owner ruling 2026-10-12): a failure throws to the caller, which
  * records it in the hook-failures ledger so SessionStart reports it.
  */
+// DETERMINISTIC per (session, tool, action) (review N1): with --no-upsert, rUv's store itself dedupes, so a
+// session holds at most one row per distinct pair and concurrent writers of the same pair collapse.
+export const observationKey = ({ session = '', tool, action }) => 'workflow-' + createHash('sha256').update(JSON.stringify([String(session), tool, action])).digest('hex');
+
 export function recordLearningObservation(binary, context, { tool, action, session = '' }, options = {}) {
   const db = learningTarget(context, options);
-  // DETERMINISTIC per (session, tool, action) (review N1): with --no-upsert, rUv's store itself dedupes, so a
-  // session holds at most one row per distinct pair and concurrent writers of the same pair collapse.
-  const key = 'workflow-' + createHash('sha256').update(JSON.stringify([session, tool, action])).digest('hex');
+  const key = observationKey({ session, tool, action });
   const value = JSON.stringify({ schemaVersion: 1, tool, action, scope: context.scope,
     authoritative: false, provenance: 'system-observation', outcome: 'host-reported-success' });
   const run = args => { if (options.allowed && !options.allowed()) throw new Error('learning consent changed'); return runLearningRuflo(binary, args, db, options); };
   const stored = run(['memory', 'store', '--key', key, '--value', value, '--namespace', LEARNING_NAMESPACE,
     '--no-upsert', '--provenance', 'system_observation', '--path', db]);
   const retrieved = run(['memory', 'retrieve', '--key', key, '--namespace', LEARNING_NAMESPACE, '--value-only', '--path', db]);
-  const exact = !retrieved.error && retrieved.status === 0 && String(retrieved.stdout || '').trim() === value;
-  // A refused store whose key already holds these exact bytes is the dedupe working, not a failure.
+  const readBack = !retrieved.error && retrieved.status === 0 ? String(retrieved.stdout || '').trim() : null;
+  const exact = readBack === value;
+  // A refused store whose key already holds these exact bytes is the dedupe working, not a failure (idempotent).
+  // Measured 2026-10-21: 141 ledger rows said "already exists" because the readback itself had timed out, so the
+  // row blamed the store; the reason names which step failed, and a key holding DIFFERENT bytes stays a failure.
   if (stored.error || stored.status !== 0) {
     if (exact) return { db, key, digest: createHash('sha256').update(value).digest('hex'), exactCli: true, alreadyStored: true };
-    throw new Error(`ruflo memory store refused the observation: ${captureFailureReason(stored, stored.status)}`);
+    const reason = captureFailureReason(stored, stored.status);
+    if (/already exists/i.test(reason)) {
+      if (readBack !== null) throw new Error('duplicate key holds a different observation');
+      throw new Error(`exact readback of the existing key failed: ${captureFailureReason(retrieved, retrieved.status)}`);
+    }
+    throw new Error(`ruflo memory store refused the observation: ${reason}`);
   }
   if (!exact) throw new Error('canonical exact CLI readback failed');
   return { db, key, digest: createHash('sha256').update(value).digest('hex'), exactCli: true };

package/plugin/scripts/nightly-scheduler.mjs

@@ -147,17 +147,23 @@ const BRIDGED_UPDATE_MODULES = [...HISTORICAL_UPDATE_MODULES, 'developer-update-
 const LEGACY_UPDATE_MODULES = [...BRIDGED_UPDATE_MODULES, 'developer-update-policy.mjs'];
 const PREVIOUS_DEVELOPER_MODULES = [...BRIDGED_UPDATE_MODULES, ...EXECUTION_MODULES.filter(name => name !== 'plugin-artifact-proof.mjs')];
 const DEVELOPER_UPDATE_MODULES = [...new Set([...LEGACY_UPDATE_MODULES, ...EXECUTION_MODULES])];
-function updateModules(directory, sourceDir = path.dirname(fileURLToPath(import.meta.url)), developerSuite = true) {
+/** The shipped module set and the content digest it is registered under (`update-modules-<digest>`); reads only. */
+function readModuleSet(sourceDir, developerSuite) {
   const files = developerSuite ? DEVELOPER_UPDATE_MODULES : LEGACY_UPDATE_MODULES;
   const bytes = Object.fromEntries(files.map(file => [file, fs.readFileSync(path.join(sourceDir, file))]));
-  const digest = sha256(Buffer.concat(files.flatMap(file => [Buffer.from(file), bytes[file]])));
+  return { files, bytes, digest: sha256(Buffer.concat(files.flatMap(file => [Buffer.from(file), bytes[file]]))) };
+}
+const registeredModuleDigest = (record) => /^update-modules-([a-f0-9]{64})$/.exec(path.basename(path.dirname(record.updateModules?.['automatic-update.mjs']?.path || '')))?.[1] || null;
+
+function updateModules(directory, sourceDir = path.dirname(fileURLToPath(import.meta.url)), developerSuite = true, { write = true } = {}) {
+  const { files, bytes, digest } = readModuleSet(sourceDir, developerSuite);
   const target = path.join(directory, `update-modules-${digest}`);
-  fs.mkdirSync(target, { recursive: true });
+  if (write) fs.mkdirSync(target, { recursive: true });
   return Object.fromEntries(files.map(file => {
     const dest = path.join(target, file);
     const hash = sha256(bytes[file]);
-    if (fs.existsSync(dest) && sha256(fs.readFileSync(dest)) !== hash) throw new Error('immutable update module was changed');
-    if (!fs.existsSync(dest)) fs.writeFileSync(dest, bytes[file], { mode: 0o600 });
+    if (write && fs.existsSync(dest) && sha256(fs.readFileSync(dest)) !== hash) throw new Error('immutable update module was changed');
+    if (write && !fs.existsSync(dest)) fs.writeFileSync(dest, bytes[file], { mode: 0o600 });
     return [file, { path: dest, sha256: hash }];
   }));
 }
@@ -174,31 +180,80 @@ function verifyUpdateModules(modules) {
   }
 }
 
+/**
+ * The ONE writer of a nightly registration. `dryRun` builds the exact record it WOULD write (runner, modules, record)
+ * and writes nothing — the refresh path compares that candidate before any rename. `environment`: undefined derives
+ * the allowlisted values from env; an object is kept verbatim; null omits the field (an older registration without it).
+ */
 export function installNightlyRunner({ brainHome, source, nodePath = process.execPath,
-  identity = NIGHTLY_LABEL, packageTarget, bundleTarget, env = {}, moduleSource, developerSuite = !NIGHTLY_PROOF_LABEL.test(identity) } = {}) {
+  identity = NIGHTLY_LABEL, packageTarget, bundleTarget, env = {}, environment, moduleSource, developerSuite = !NIGHTLY_PROOF_LABEL.test(identity), dryRun = false } = {}) {
   validateIdentity(identity);
   if (!source || !fs.existsSync(source)) throw new Error(`nightly runner source is missing: ${source || '(unset)'}`);
   const bytes = fs.readFileSync(source);
   const digest = sha256(bytes);
   const dir = path.join(brainHome, 'scheduler');
   const runnerPath = path.join(dir, `nightly-refresh-${digest}.mjs`);
-  fs.mkdirSync(dir, { recursive: true });
-  if (fs.existsSync(runnerPath) && sha256(fs.readFileSync(runnerPath)) !== digest) {
-    throw new Error(`nightly runner at ${runnerPath} does not match its content-addressed identity`);
+  if (!dryRun) {
+    fs.mkdirSync(dir, { recursive: true });
+    if (fs.existsSync(runnerPath) && sha256(fs.readFileSync(runnerPath)) !== digest) {
+      throw new Error(`nightly runner at ${runnerPath} does not match its content-addressed identity`);
+    }
+    if (!fs.existsSync(runnerPath)) fs.writeFileSync(runnerPath, bytes, { mode: 0o755 });
   }
-  if (!fs.existsSync(runnerPath)) fs.writeFileSync(runnerPath, bytes, { mode: 0o755 });
-  const modules = updateModules(dir, moduleSource, developerSuite);
+  const modules = updateModules(dir, moduleSource, developerSuite, { write: !dryRun });
   const record = { updateModules: modules, ...(developerSuite ? { mode: 'developer-suite' } : {}), schemaVersion: 2, kind: 'ruvnet-brain-nightly-scheduler', identity,
     nodePath: path.resolve(nodePath), runnerPath, runnerSha256: digest, argv: [],
-    environment: Object.fromEntries(NIGHTLY_ENV_ALLOWLIST.filter(key => env[key] !== undefined).map(key => [key, key === 'PATH' ? automaticPath({ nodePath, home: homeOf(env), env }) : String(env[key])])),
+    ...(environment === null ? {} : { environment: environment ?? Object.fromEntries(NIGHTLY_ENV_ALLOWLIST.filter(key => env[key] !== undefined).map(key => [key, key === 'PATH' ? automaticPath({ nodePath, home: homeOf(env), env }) : String(env[key])])) }),
     packageTarget: normalizePackageTarget(packageTarget), bundleTarget: normalizeBundleTarget(bundleTarget, identity) };
   const recordPath = path.join(dir, registrationName(identity));
+  if (dryRun) return { ...record, recordPath };
   const tmp = `${recordPath}.tmp-${process.pid}`;
   fs.writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\n`);
   fs.renameSync(tmp, recordPath);
   return { ...record, recordPath };
 }
 
+export const NIGHTLY_ENABLE_FIX = 'npx ruvnet-brain@latest --enable-nightly';
+export const NIGHTLY_UPDATE_FIX = 'npx ruvnet-brain@latest --update';
+/**
+ * Does the registered nightly run the code installed now? The scheduler executes a content-addressed snapshot of
+ * the update modules that only --enable-nightly used to refresh (measured 2026-10-22: the 4.7.15 developer-update
+ * fix shipped to disk and the 03:30 job still ran the old module). Pure read: `current`, `stale` (modules only;
+ * --update refreshes them), `runner-changed` (the LaunchAgent command would change: explicit enablement only),
+ * or `unregistered`.
+ */
+export function nightlyModuleCurrency({ brainHome, identity = NIGHTLY_LABEL, moduleSource = path.dirname(fileURLToPath(import.meta.url)), runnerSource } = {}) {
+  const registration = readNightlyRegistration({ brainHome, identity });
+  if (!registration.ok) return { state: 'unregistered', why: registration.why };
+  const record = registration.record;
+  const registered = registeredModuleDigest(record);
+  if (!registered) return { state: 'unregistered', why: 'registration carries no module snapshot', fix: NIGHTLY_ENABLE_FIX };
+  const current = readModuleSet(moduleSource, record.mode === 'developer-suite').digest;
+  if (runnerSource && sha256(fs.readFileSync(runnerSource)) !== record.runnerSha256) return { state: 'runner-changed', registered, current, record, fix: NIGHTLY_ENABLE_FIX };
+  return registered === current ? { state: 'current', registered, current, record } : { state: 'stale', registered, current, record, fix: NIGHTLY_UPDATE_FIX };
+}
+
+/**
+ * After a successful --update: re-point a stale registration at the installed module set. Same identity, node,
+ * runner bytes, environment and targets, so only registration.json and a new update-modules-<digest> dir change
+ * and the LaunchAgent command stays exactly what it was; anything else is refused and left as it was.
+ */
+export const SCHEDULER_VISIBLE_FIELDS = Object.freeze(['identity', 'nodePath', 'runnerPath', 'runnerSha256', 'argv', 'environment', 'packageTarget', 'bundleTarget', 'mode']);
+export function refreshNightlyModules(options = {}) {
+  const currency = nightlyModuleCurrency(options);
+  if (currency.state !== 'stale') return currency;
+  const { record } = currency;
+  const plan = { brainHome: options.brainHome, identity: record.identity, source: record.runnerPath, nodePath: record.nodePath, packageTarget: record.packageTarget,
+    bundleTarget: record.bundleTarget, environment: record.environment ?? null, moduleSource: options.moduleSource, developerSuite: record.mode === 'developer-suite' };
+  // Compare the candidate BEFORE anything is written (reviewer proof 2026-10-22: an older registration without
+  // `environment` was rewritten with {} and only then refused). `build` is the dry-run of the one writer.
+  const candidate = (options.build || ((p) => installNightlyRunner({ ...p, dryRun: true })))(plan);
+  const differs = SCHEDULER_VISIBLE_FIELDS.filter((key) => JSON.stringify(candidate[key] ?? null) !== JSON.stringify(record[key] ?? null));
+  if (differs.length) return { ...currency, state: 'refused', reason: `refresh would change ${differs.join(', ')}; registration left as it was`, fix: NIGHTLY_ENABLE_FIX };
+  const refreshed = installNightlyRunner(plan);
+  return { ...currency, state: 'refreshed', registered: registeredModuleDigest(refreshed), fix: undefined };
+}
+
 export function readNightlyRegistration({ brainHome, identity = NIGHTLY_LABEL,
   recordPath = path.join(brainHome, 'scheduler', registrationName(identity)) }) {
   try {

package/plugin/scripts/turn-outcome-capture.mjs

@@ -239,20 +239,18 @@ export function launchDetached(steps, { receipts, brainHome, projectDir, env = p
   return { launched: true, pid: child.pid };
 }
 
-function readTurnState(stateFile) {
-  try { return JSON.parse(fs.readFileSync(stateFile, 'utf8')) || {}; } catch { return {}; }
-}
+const readTurnState = (stateFile) => { try { return JSON.parse(fs.readFileSync(stateFile, 'utf8')) || {}; } catch { return {}; } };
+
+/** The newest store receipt for this exact key, while the receipt tail still holds it. */
+const storeReceipt = (receipts, key) => { try { return readTail(receipts, 128 * 1024).flatMap((l) => { try { return [JSON.parse(l)]; } catch { return []; } }).findLast((r) => r.kind === 'store' && r.key === key) || null; } catch { return null; } };
+const verifiedReceipt = (r) => r?.status === 0 && r.verified === true;
 
 function sameTurnSeen(stateFile, sessionKey, fingerprint, receipts) {
   const previous = readTurnState(stateFile)[sessionKey];
   if (previous?.fingerprint !== fingerprint) return false;
-  try {
-    const rows = readTail(receipts, 128 * 1024).flatMap((line) => { try { return [JSON.parse(line)]; } catch { return []; } });
-    const receipt = rows.findLast((r) => r.kind === 'store' && r.key === previous.key);
-    if (receipt) return receipt.status === 0 && receipt.verified === true;
-  } catch { /* queued worker has no receipt yet */ }
-  // An in-flight worker gets a bounded grace period; a killed/lost worker cannot consume the turn forever.
-  return Date.now() - previous.at < 2 * STEP_TIMEOUT_MS + 10_000;
+  const receipt = storeReceipt(receipts, previous.key);
+  // No receipt yet: an in-flight worker gets a bounded grace period; a killed/lost worker cannot consume the turn forever.
+  return receipt ? verifiedReceipt(receipt) : Date.now() - previous.at < 2 * STEP_TIMEOUT_MS + 10_000;
 }
 
 function markTurnQueued(stateFile, sessionKey, fingerprint, key) {
@@ -266,9 +264,8 @@ function markTurnQueued(stateFile, sessionKey, fingerprint, key) {
 }
 
 /**
- * Capture this turn's outcome (Stop) and/or queue distillation (SessionEnd, PreCompact).
- * Returns a plain report; `queued` means a worker request, never proof the store committed.
- * `skipped` / `distill.skipped` carry the reason whenever nothing is requested.
+ * Capture this turn's outcome (Stop) and/or start distillation (SessionEnd, PreCompact). Returns a plain report:
+ * `queued` means a request, never proof the store committed; `skipped` / `distill.skipped` carry the reason.
  */
 export function captureTurnOutcome({
   projectDir, event, payload = {}, host = 'claude',
@@ -322,10 +319,12 @@ export function captureTurnOutcome({
       const fingerprint = crypto.createHash('sha256').update(JSON.stringify([turn.finalText, turn.files])).digest('hex');
       const stateFile = path.join(brainHome, 'turn-capture', 'last-turn.json');
       const identity = crypto.createHash('sha256').update(`${host}:${db}:${sessionKey}`).digest('hex');
+      const key = `turn-${project}-${digest(`${identity}:${fingerprint}`).slice(0, 40)}`;
       if (sameTurnSeen(stateFile, identity, fingerprint, receipts)) report.skipped = 'same turn outcome already queued or verified';
+      // Proven at Stop already: SessionEnd/PreCompact must not re-send it (2026-10-19/20: each re-send was an "append rejected" row).
+      else if (verifiedReceipt(storeReceipt(receipts, key))) report.skipped = 'turn key already verified at an earlier boundary';
       else {
         const at = now();
-        const key = `turn-${project}-${digest(`${identity}:${fingerprint}`).slice(0, 40)}`;
         dedupe = { stateFile, identity, fingerprint, key };
         const value = buildTurnRecord({ turn, project, host, session: payload.session_id, at });
         steps.push({ ...binding, kind: 'store', ruflo, args: ['memory', 'store', '--key', key, '--value', value, '--namespace', TURN_NAMESPACE,
@@ -444,13 +443,14 @@ export function runSteps({ steps = [], receipts, event = '' } = {}, { run: suppl
       delete options.env.CLAUDE_FLOW_MEMORY_PATH;
       const r = run(invocation.executable, invocation.args, options);
       status = Number.isInteger(r.status) ? r.status : 1;
-      if (kind === 'store' && !verified && status === 0) verified = read({ ruflo, db, key, run, options }) === value;
-      if (verified) status = 0;
+      const duplicate = kind === 'store' && status !== 0 && /already exists/i.test(captureFailureReason(r, status)); // append-only refusal
+      if (kind === 'store' && (status === 0 || duplicate)) { verified = read({ ruflo, db, key, run, options }) === value; if (verified) status = 0; } // identical bytes = success
       if (kind === 'distill' && status === 0) {
         const match = /(?:^|\n)\s*skipped:\s*([^\n]+)/i.exec(String(r.stdout || '').replace(/\x1b\[[0-9;]*m/g, ''));
         if (match) skipped = redactText(match[1]).slice(0, 300);
       }
-      if (!verified && (r.error || status !== 0)) error = captureFailureReason(r, status);
+      if (!verified && duplicate) error = 'duplicate turn key holds different content';
+      else if (!verified && (r.error || status !== 0)) error = captureFailureReason(r, status);
       else if (kind === 'store' && !verified) { status = 1; error = 'exact turn key/content readback failed'; }
     } catch (e) { status = 1; error = redactText(e.message).slice(0, 300); }
     if (error) error = maskExcludedPaths(error, privacyPatterns, projectDir);

package/scripts/corpus-watchdog.mjs

@@ -400,6 +400,31 @@ export function failedStage(run) {
   return stage ? STAGE_NAMES[stage] || stage : `an unnamed job (conclusion ${run?.conclusion || 'unknown'})`;
 }
 
+/** A night's scheduled dispatches (the 07:36Z run and its retry slot) sit within this span; a day earlier is last night. */
+const NIGHT_SPAN_MS = 12 * HOUR;
+/**
+ * How many protected-release corpus runs belong to THIS night. Measured 2026-10-22: a manual workflow_dispatch proving
+ * run at 10:36Z Oct 21 and a stood-down retry slot at 11:25Z Oct 21 made ONE scheduled night read "attempt 2; 1 retried".
+ * The night is anchored on the newest `schedule` dispatcher that dispatched a run, plus scheduled dispatchers within
+ * NIGHT_SPAN_MS before it; a run counts only from that start and never when its dispatcher was a manual
+ * workflow_dispatch. A stood-down retry slot created no run, so it never counts. `runs` is newest-first, in window.
+ */
+export function nightAttempts(runs, dispatchers) {
+  const dispatchKey = (d) => `corpus-${d.id}-${d.attempt ?? 1}`;
+  const runKey = (run) => CORPUS_RUN_TITLE.exec(String(run.title || ''))?.[1];
+  const byKey = new Map(dispatchers.map((d) => [dispatchKey(d), d]));
+  const manual = (run) => byKey.get(runKey(run))?.event === 'workflow_dispatch';
+  const [newest] = runs;
+  if (manual(newest)) return ' (1 attempt; manual dispatch)';
+  const scheduled = dispatchers.filter((d) => !d.event || d.event === 'schedule'); // an undated event is read as the schedule
+  const anchor = scheduled.find((d) => runs.some((run) => runKey(run) === dispatchKey(d)));
+  const nightStart = anchor
+    ? Math.min(...scheduled.filter((d) => ms(d.createdAt) <= ms(anchor.createdAt) && ms(anchor.createdAt) - ms(d.createdAt) <= NIGHT_SPAN_MS).map((d) => ms(d.createdAt)))
+    : ms(newest.createdAt);
+  const count = runs.filter((run) => ms(run.createdAt) >= nightStart && !manual(run)).length || 1;
+  return count > 1 ? ` (attempt ${count} of the night; ${count - 1} retried)` : ' (1 attempt)';
+}
+
 /**
  * THE ONE LINE the owner reads first: what the night did, result first, in Eastern time. `input` is
  * gatherCorpusHealthInput's; the night is the newest corpus run of the last 24h and every retry of it.
@@ -410,9 +435,10 @@ export function summarizeNight(input, now) {
   const inWindow = (iso) => { const t = ms(iso); return t !== null && t <= at && at - t <= TONIGHT_WINDOW_MS; };
   const runs = (input?.corpusRuns || []).filter((run) => inWindow(run.createdAt))
     .map((run) => ({ ...run, outcome: run.outcome ?? classifyCorpusRun(run) })).sort((a, b) => ms(b.createdAt) - ms(a.createdAt));
-  const dispatcher = (input?.dispatcherRuns || []).filter((d) => inWindow(d.createdAt)).sort((a, b) => ms(b.createdAt) - ms(a.createdAt))[0];
+  const dispatchers = (input?.dispatcherRuns || []).filter((d) => inWindow(d.createdAt)).sort((a, b) => ms(b.createdAt) - ms(a.createdAt));
+  const [dispatcher] = dispatchers;
   const latest = input?.latestRelease;
-  const attempts = runs.length > 1 ? ` (attempt ${runs.length} of the night; ${runs.length - 1} retried)` : '';
+  const attempts = runs.length ? nightAttempts(runs, dispatchers) : '';
   const keep = latest ? `customers keep ${latest.tag} (${hours(Math.max(0, at - (ms(latest.generation || latest.publishedAt) ?? at)))} old)` : 'no promoted generation is observed';
   if (!runs.length) {
     if (!dispatcher) return { outcome: 'no-run', line: `night: no corpus run in the last 24h (no dispatcher run either); ${keep}` };