ruvnet-brain 3.9.133-dev → 4.0.1

package/kb/zip-extract.mjs

@@ -47,15 +47,28 @@ const SIG_EOCD64_LOC = 0x07064b50;
 const SIG_CENTRAL = 0x02014b50;
 const SIG_LOCAL = 0x04034b50;
 
+export const ZIP_LIMITS = Object.freeze({
+  archiveBytes: 2 * 1024 ** 3,
+  entries: 100_000,
+  centralDirectoryBytes: 128 * 1024 ** 2,
+  entryBytes: 2 * 1024 ** 3,
+  totalBytes: 8 * 1024 ** 3,
+  compressionRatio: 1_000,
+});
+
 // zlib.crc32 landed in Node 20.15.0 / 22.2.0. package.json engines allow >=18, so it is OPTIONAL —
 // present it is used, absent the size check still stands and the caller is told which happened.
 // Reimplementing CRC-32 here would be hand-rolling something the runtime ships.
 const crc32 = typeof zlib.crc32 === 'function' ? zlib.crc32 : null;
 
 class Tally extends Transform {
-  constructor() { super(); this.bytes = 0; this.crc = 0; }
+  constructor(maxBytes) { super(); this.bytes = 0; this.crc = 0; this.maxBytes = maxBytes; }
   _transform(chunk, _enc, cb) {
     this.bytes += chunk.length;
+    if (this.bytes > this.maxBytes) {
+      cb(new Error(`uncompressed entry exceeded the ${this.maxBytes}-byte safety limit`));
+      return;
+    }
     if (crc32) this.crc = crc32(chunk, this.crc);
     this.push(chunk);
     cb();
@@ -181,10 +194,40 @@ export async function extractZip(zipPath, destDir) {
   try {
     const size = fs.fstatSync(fd).size;
     if (size === 0) throw new Error('archive is empty (0 bytes)');
+    if (size > ZIP_LIMITS.archiveBytes) {
+      throw new Error(`archive is ${size} bytes, above the ${ZIP_LIMITS.archiveBytes}-byte safety limit`);
+    }
     const { cdSize, cdOffset } = centralDirectoryLocation(fd, size);
+    if (cdSize > ZIP_LIMITS.centralDirectoryBytes) {
+      throw new Error(`central directory is ${cdSize} bytes, above the ${ZIP_LIMITS.centralDirectoryBytes}-byte safety limit`);
+    }
     if (cdOffset + cdSize > size) throw new Error(`central directory runs past end of file (offset ${cdOffset} + ${cdSize} > ${size})`);
     const entries = parseCentralDirectory(readAt(fd, cdSize, cdOffset));
     if (entries.length === 0) throw new Error('central directory contains no entries');
+    if (entries.length > ZIP_LIMITS.entries) {
+      throw new Error(`archive has ${entries.length} entries, above the ${ZIP_LIMITS.entries}-entry safety limit`);
+    }
+    let declaredTotal = 0;
+    for (const entry of entries) {
+      const unixType = (entry.externalAttrs >>> 16) & 0xf000;
+      if ((entry.versionMadeBy >> 8) === 3 && unixType === 0xa000) {
+        throw new Error(`entry "${entry.name}" is a symbolic link — downloaded bundles may contain regular files and directories only`);
+      }
+      if (!Number.isSafeInteger(entry.uncompSize) || entry.uncompSize < 0) {
+        throw new Error(`entry "${entry.name}" has an unsafe uncompressed size`);
+      }
+      if (entry.uncompSize > ZIP_LIMITS.entryBytes) {
+        throw new Error(`entry "${entry.name}" claims ${entry.uncompSize} bytes, above the ${ZIP_LIMITS.entryBytes}-byte safety limit`);
+      }
+      declaredTotal += entry.uncompSize;
+      if (!Number.isSafeInteger(declaredTotal) || declaredTotal > ZIP_LIMITS.totalBytes) {
+        throw new Error(`archive claims ${declaredTotal} uncompressed bytes, above the ${ZIP_LIMITS.totalBytes}-byte safety limit`);
+      }
+      const ratio = entry.uncompSize / Math.max(entry.compSize, 1);
+      if (ratio > ZIP_LIMITS.compressionRatio) {
+        throw new Error(`entry "${entry.name}" has compression ratio ${ratio.toFixed(1)}, above the ${ZIP_LIMITS.compressionRatio}:1 safety limit`);
+      }
+    }
 
     fs.mkdirSync(destDir, { recursive: true });
     let files = 0;
@@ -234,17 +277,6 @@ export async function extractZip(zipPath, destDir) {
         throw new Error(`entry "${e.name}" uses unsupported compression method ${e.method} (only stored=0 and deflate=8 are implemented)`);
       }
 
-      const isSymlink = (e.versionMadeBy >> 8) === 3 && ((e.externalAttrs >>> 16) & 0xf000) === 0xa000;
-      if (isSymlink) {
-        // A symlink's payload is its target path — always tiny, so it is read whole rather than streamed.
-        const comp = e.compSize === 0 ? Buffer.alloc(0) : readAt(fd, e.compSize, dataStart);
-        const linkTarget = (e.method === 8 ? zlib.inflateRawSync(comp) : comp).toString('utf8');
-        fs.rmSync(target, { recursive: true, force: true });
-        fs.symlinkSync(linkTarget, target);
-        files++;
-        continue;
-      }
-
       // A zero-length entry has no data range to stream (start > end would be a nonsense read), so
       // it is written directly. Its size/CRC assertions below still apply.
       if (e.compSize === 0) {
@@ -254,25 +286,32 @@ export async function extractZip(zipPath, destDir) {
         continue;
       }
 
-      const tally = new Tally();
+      const tally = new Tally(Math.min(e.uncompSize, ZIP_LIMITS.entryBytes));
+      const partial = path.join(path.dirname(target), `.ruvnet-extract-${process.pid}-${entryIndex}.tmp`);
+      try { fs.rmSync(partial, { force: true }); } catch { /* absent */ }
       const stages = [fs.createReadStream(zipPath, { start: dataStart, end: dataStart + e.compSize - 1 })];
       if (e.method === 8) stages.push(zlib.createInflateRaw());
-      stages.push(tally, fs.createWriteStream(target));
+      stages.push(tally, fs.createWriteStream(partial, { flags: 'wx' }));
 
       try {
         await pipeline(...stages);
       } catch (err) {
+        try { fs.rmSync(partial, { force: true }); } catch { /* best effort */ }
         throw new Error(`entry "${e.name}" failed to inflate (${err && err.code ? err.code : ''}${err && err.message ? ` ${err.message}` : ''}) — the archive is corrupt or truncated`);
       }
       if (tally.bytes !== e.uncompSize) {
+        fs.rmSync(partial, { force: true });
         throw new Error(`entry "${e.name}" is corrupt: expected ${e.uncompSize} bytes, extracted ${tally.bytes}`);
       }
       if (crc32 && (tally.crc >>> 0) !== (e.crc >>> 0)) {
+        fs.rmSync(partial, { force: true });
         // Zero-padded to 8 hex digits so the value is directly comparable to the one Info-ZIP's
         // own `unzip` prints for the same damaged entry ("bad CRC 811e0dd1 (should be 0f6994e4)").
         const hex = (n) => (n >>> 0).toString(16).padStart(8, '0');
         throw new Error(`entry "${e.name}" failed its CRC-32 check (expected ${hex(e.crc)}, got ${hex(tally.crc)}) — the archive is corrupt`);
       }
+      if (process.platform === 'win32') fs.rmSync(target, { recursive: true, force: true });
+      fs.renameSync(partial, target);
 
       // Unix permission bits, when the archive carries them. Skipped on Windows, which has no
       // POSIX mode and where chmod is a no-op at best.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "3.9.133-dev",
+  "version": "4.0.1",
   "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": {
@@ -49,11 +49,17 @@
     "cap:ab": "node scripts/rerank-cap-warm-ab.mjs"
   },
   "files": [
+    ".claude-plugin/marketplace.json",
     "bin/install.mjs",
+    "plugin/",
     "plugin/mcp/managed-cli-interface.mjs",
     "plugin/mcp/server.mjs",
     "plugin/scripts/codex-hook-wrapper.mjs",
+    "plugin/scripts/host-update.mjs",
+    "plugin/scripts/update-apply.mjs",
     "!plugin/README.md",
+    "!plugin/scripts/.ruvnet-brain/",
+    "!plugin/test/",
     "README.md",
     "LICENSE",
     "config/model-router/",

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

@@ -0,0 +1,13 @@
+{
+  "name": "ruvnet-brain",
+  "owner": {
+    "name": "Stuart Kerr"
+  },
+  "plugins": [
+    {
+      "name": "ruvnet-brain",
+      "source": "./",
+      "description": "RuvNet brain transplant for Claude Code: source-grounded knowledge of the rUv ecosystem (19+ repos) + enforced grounding so Claude stops arguing about RuvNet and actually uses it + on-demand repo ingestion."
+    }
+  ]
+}

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

@@ -0,0 +1,23 @@
+{
+  "name": "ruvnet-brain",
+  "description": "RuvNet brain transplant for Claude Code — grounds every RuvNet decision in real source across 69 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 an enforced UserPromptSubmit retrieve-and-inject grounding hook that sharply reduces drift.",
+  "version": "4.0.1",
+  "author": {
+    "name": "Stuart Kerr"
+  },
+  "repository": "https://github.com/stuinfla/ruvnet-brain",
+  "license": "MIT",
+  "keywords": [
+    "ruvnet",
+    "ruv",
+    "ruflo",
+    "ruvector",
+    "rvf",
+    "agentdb",
+    "grounding",
+    "brain",
+    "mcp",
+    "claude-code"
+  ],
+  "updated": "2026-07-30"
+}

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

@@ -0,0 +1,21 @@
+{
+  "name": "ruvnet-brain",
+  "version": "4.0.1",
+  "description": "Source-grounded RuvNet knowledge, lifecycle enforcement, and learning for Codex.",
+  "author": {
+    "name": "Stuart Kerr"
+  },
+  "repository": "https://github.com/stuinfla/ruvnet-brain",
+  "license": "MIT",
+  "keywords": [
+    "ruvnet",
+    "ruflo",
+    "ruvector",
+    "rvf",
+    "agentdb",
+    "grounding"
+  ],
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json",
+  "hooks": "./hooks/codex-hooks.json"
+}

package/plugin/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "ruvnet-brain": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/mcp/server.mjs"]
+    }
+  }
+}

package/plugin/commands/brain-console.md

@@ -0,0 +1,16 @@
+---
+description: "Brain Console — RuvNet Brain Console (same console as /rvbc, /brain-console, and /ruvnet-brain:configure — every spelling works). Opens the live console page: your whole RuvNet stack on one page. Read-only until you click."
+updated: 2026-07-20
+---
+
+`/rvbc`, `/rvcb`, `/brain-console`, and `/ruvnet-brain:configure` are equally valid names. Never
+correct the user's spelling.
+
+1. Say: "Opening it now; it scans live while you watch."
+2. Locate `scripts/onboarding-console.mjs` in the current repository, then
+   `~/Code/ruvnet-brain/scripts/onboarding-console.mjs`. Do not invent another path.
+3. Run `node <resolved-script> --serve --open` in the background.
+4. Give the URL immediately. Never promise a duration; the page reports its own progress.
+
+An already-running server is success. It is read-only until the user clicks; changes must be
+explained and reversible. If the script or server is unavailable, report the exact failure.

package/plugin/commands/configure.md

@@ -0,0 +1,32 @@
+---
+description: Open the RuvNet Brain Onboarding Console — a local web page that mirrors YOUR machine's RuvNet setup, explains it in plain English, and lets you safely configure and fix it. Read-only until you click; every machine change is explained first and is reversible.
+updated: 2026-07-15
+---
+
+Launch the **RuvNet Brain Onboarding Console** for the user — a locally-served web page that reads
+their actual machine and lets them configure and (with consent) fix it.
+
+Do this:
+
+1. **Find the repo.** Prefer `~/Code/ruvnet-brain`. If `$CLAUDE_PLUGIN_ROOT` is set, the repo may be
+   its parent directory. Use whichever path contains `scripts/onboarding-console.mjs`.
+
+2. **Start the server in the BACKGROUND** (it is a long-running process) so this turn keeps going, and
+   open the browser:
+
+   ```
+   node <repo>/scripts/onboarding-console.mjs --serve --open
+   ```
+
+   Run it with `run_in_background: true`. It binds `127.0.0.1` only and prints a line like
+   `http://127.0.0.1:7411/`.
+
+3. **Give the user the link** as a clickable `http://127.0.0.1:<port>/`, with one warm sentence:
+   the page is **read-only until you click**, everything it can change to your computer is **explained
+   in plain English and confirmed first**, and **Settings save at your user level**
+   (`~/.claude/ruvnet-brain/config.json`) without touching how anything else on your machine runs.
+
+4. If the server errors (e.g. `sqlite3` not found, or a bad node version), report it plainly and offer
+   to fix it — don't leave them staring at a dead tab.
+
+Do **not** narrate the machine yourself — the page is the mirror. Your job is just to get it open.

package/plugin/commands/rvbc.md

@@ -0,0 +1,78 @@
+---
+description: "RvBC — RuvNet Brain Console. Opens the live console page: your whole RuvNet stack on one page — what's installed, what your AI learned, one-click reversible fixes. Read-only until you click. (Also: /rvcb, /brain-console — all the same thing.)"
+updated: 2026-07-20
+---
+
+Launch the **RuvNet Brain Console** for the user. Same console as `/ruvnet-brain:configure`,
+`/rvcb`, and `/brain-console` — every spelling lands here, so never tell the user they typed it wrong.
+
+## The contract you are keeping
+
+The page **opens immediately and scans itself while they watch.** The server never blocks: a cold or
+new-project read is answered in milliseconds with "measuring…", the page keeps its skeletons and
+narrates the wait, and each card fills in as its own measurement lands. A chip in the header says how
+old the picture is and re-measures when clicked.
+
+So there is nothing to wait for and nothing to warn them about. **Your entire job is: say one
+sentence, start the server in the background, hand over the URL, and get out of the way.**
+
+## 1. SPEAK FIRST — one short sentence, before any tool call
+
+Your FIRST output — before any tool call, any file read, any search — is one warm line saying you are
+opening it now and it will scan itself live in their browser. Something in the spirit of:
+
+> "Opening your console now — it'll come up right away and scan your setup live while you watch."
+
+Say it like a person, not a status bar. **Do not** promise 20 seconds, a minute, or any duration: the
+page carries its own timing now, and a number invented here is a number the page will contradict.
+
+## 2. Find the repo
+
+Prefer `~/Code/ruvnet-brain`. If `$CLAUDE_PLUGIN_ROOT` is set, the repo may be its parent
+directory. Use whichever path actually contains `scripts/onboarding-console.mjs`.
+
+## 3. Start it in the BACKGROUND and open the browser
+
+```
+node <repo>/scripts/onboarding-console.mjs --serve --open
+```
+
+**`run_in_background: true`, ALWAYS — never in the foreground.** This is a server: it does not exit,
+so a foreground run hangs the tool call until the 120-second timeout and turns an instant page into
+two minutes of dead air. It binds `127.0.0.1` only and prints `http://127.0.0.1:7411/` within about a
+third of a second.
+
+**Then post the URL immediately.** Do not poll the log, do not wait for a scan, do not check whether
+the data has landed — the page reports its own progress and none of it is visible from here.
+
+**If it reports it is already running**, that is a success, not an error: open the URL yourself with
+`open "http://127.0.0.1:<port>/"`. One honest caveat, worth half a sentence if it comes up — a
+console that is already running is serving the project it was *launched* from, so if they want this
+project's view they can stop that one (`^C` in its terminal) and run this again.
+
+## 4. Hand it over and stop
+
+Give them the URL as a clickable line, and one warm sentence: the page is **read-only until you
+click**, every machine change is **explained first and reversible**, and Settings save at the user
+level only. Worth naming once: the brain's on/off switch is the first card on the page, and the
+header chip says how fresh the reading is and re-measures if they click it.
+
+## 5. If it errors
+
+Report it plainly — the real error, not a guess — and offer to fix it. Never leave them staring at
+a dead tab wondering whether it is still loading.
+
+---
+
+## Things NOT to do before the page is open
+
+Each of these has cost a real user real minutes of silence, and not one of them is needed to open a
+local web page:
+
+- **No knowledge search, no memory recall, no source grounding, no repo exploration.** A cold
+  embedding-model load alone is allowed up to 180 seconds.
+- **No model selection or routing work.**
+- **No reading this repo to "check" anything first.** Find the script, run it.
+
+Do **not** narrate the machine yourself afterwards; the page is the mirror. Your job is to open it,
+say one sentence, and get out of the way.

package/plugin/commands/rvcb.md

@@ -0,0 +1,16 @@
+---
+description: "RvCB — RuvNet Brain Console (same console as /rvbc, /brain-console, and /ruvnet-brain:configure — every spelling works). Opens the live console page: your whole RuvNet stack on one page. Read-only until you click."
+updated: 2026-07-20
+---
+
+`/rvbc`, `/rvcb`, `/brain-console`, and `/ruvnet-brain:configure` are equally valid names. Never
+correct the user's spelling.
+
+1. Say: "Opening it now; it scans live while you watch."
+2. Locate `scripts/onboarding-console.mjs` in the current repository, then
+   `~/Code/ruvnet-brain/scripts/onboarding-console.mjs`. Do not invent another path.
+3. Run `node <resolved-script> --serve --open` in the background.
+4. Give the URL immediately. Never promise a duration; the page reports its own progress.
+
+An already-running server is success. It is read-only until the user clicks; changes must be
+explained and reversible. If the script or server is unavailable, report the exact failure.

package/plugin/commands/whats-new.md

@@ -0,0 +1,57 @@
+---
+description: "What's new in RuvNet Brain — the big things in the current MAJOR release (4.0), in plain English. Not the point-release churn — the headline changes since 3.x. Ends by offering to open the Console so you can see it live."
+updated: 2026-07-25
+---
+
+# RuvNet-Brain: what's new
+
+The user wants the headline story of the **major** release they're on — the 4.0-vs-3.0 kind of change,
+**not** the "3.9.x → 3.9.y" point-release churn. Deliver it warmly and honestly, then offer the Console.
+
+**First, ground — never recite this from memory (it drifts every release):**
+1. Read the running version from `${CLAUDE_PLUGIN_ROOT}/.claude-plugin/plugin.json`. State it honestly.
+   **Do NOT claim "you're on 4.0"** unless the version literally starts with `4.` — per ADR-042 the
+   number stays `3.9.x-dev` until the 4.0 line is field-verified. The honest framing is: *"these are the
+   4.0-line enhancements, and you already have them — the version stamps to 4.0 once they're proven in
+   real use."*
+2. Read `docs/RELEASE-NOTES-4.0.md` (the curated highlights + its VERSION STATUS banner). Its content is
+   the source of truth for what follows — summarize it, don't invent beside it, and carry its honest
+   version framing.
+
+**Then tell them what the 4.0 line is — the honest headline (adapt to the notes file; do NOT overclaim):**
+
+The 4.0 line is where the brain got **honest, legible, fast, and self-measuring** — landing now in the
+3.9.x releases. The big things:
+
+- **The Console is the front door.** One live local page (type `/rvbc`) — your whole RuvNet stack on
+  one screen: what's installed, what the AI has actually learned from *your* projects (real memories +
+  distilled lessons, drill-down to the verbatim cards), which subscription pays for what, and one-click
+  **reversible** fixes for anything stale. New in 4.0: a plain-English explainer on every card, each
+  suggestion labelled with its blast radius (*just this project* vs *every project*), safe on/off
+  checkboxes that only appear where the undo is proven, and a terminal-first install.
+- **It will not lie about your machine.** Every number is measured live; "we couldn't check" never
+  renders as "off"; one project's state can never leak into another's view.
+- **Fast, and it tells you when it's ready.** The console and tips page paint in well under a second;
+  on a first scan it shows a countdown and then says *"it's live — take a look at your page,"* so you're
+  never staring at nothing.
+- **It measures itself now.** The brain records when it offered help and whether you acted on it, so it
+  can *prove* it's improving rather than assert it. **Be honest that this has only just started
+  collecting** — the proof accrues as you use it; it is not a claim of "proven better" yet.
+- **It learns across your projects.** A lesson proven in one project can be promoted to your global
+  brain and now survives an update (tested against the real updater, not argued).
+- **Runs on your account, cheapest capable model.** The QE suite and routing use your Claude account,
+  not an API key, at the least-powerful model that does the job.
+
+**Then offer the Console (the point of the whole thing):**
+
+End by offering to open it: *"Want me to open the Console so you can see all of this live? Just say the
+word — or type `/rvbc`."* If they say yes, follow `rvbc.md` in this same directory exactly (including the
+warm heads-up about the ~20s scan).
+
+**Honesty rules for this command (same as the product):**
+- If `docs/RELEASE-NOTES-4.0.md` is missing, say the notes aren't written yet and summarize from what
+  you can verify — never fabricate a highlight.
+- Never claim a metric ("40% better", "95/100") the release has not independently earned. The self-
+  measurement is new and still filling; say so plainly.
+- This is the MAJOR story only. If the user wants the point-release detail, point them at the repo's
+  release notes / `git log`.

package/plugin/hooks/codex-hooks.json

@@ -0,0 +1,160 @@
+{
+  "description": "RuvNet Brain lifecycle hooks for Codex. Every command enters through a generation-independent wrapper and adapts the shared Brain hook bodies to Codex contracts.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" session-start",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" ground-ruvnet",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" unprompted-speech UserPromptSubmit",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "^(Bash|Edit|Write|exec_command|functions\\.exec_command|functions__exec_command|apply_patch)$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" hijack-ruvnet",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|spawn_agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" route-dispatch",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "^(Edit|Write|apply_patch)$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" ground-before-write",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" protect-state",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" unprompted-speech PreToolUse-write",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "^(Bash|exec_command|functions\\.exec_command|functions__exec_command)$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" verify-interface",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" design-wall",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" unprompted-speech PreToolUse-bash",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "^(?:.*__)?search_ruvnet$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" grounding-stamp",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "^(Bash|Edit|Write|exec_command|functions\\.exec_command|functions__exec_command|apply_patch)$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" learn-capture",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "^(Edit|Write|apply_patch)$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" md-stamp",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "^(Bash|exec_command|functions\\.exec_command|functions__exec_command)$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" signal-watch",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "other",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" learn-flush",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$HOME/.cache/ruvnet-brain/codex-hook.mjs\" continuation-gate",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}