ruvnet-brain 3.9.68-dev → 3.9.72-dev

package/README.md

@@ -4,7 +4,7 @@
 
 # 🧠 RuvNet Brain
 
-### 🧠 RuvNet Brain — [![RuvNet Brain version 3.9.68-dev — updated 2026-07-24 16:29 EDT](https://img.shields.io/badge/version_3.9.68--dev-updated_2026--07--24_16:29_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](https://github.com/stuinfla/ruvnet-brain/blob/main/plugin/.claude-plugin/plugin.json)
+### 🧠 RuvNet Brain — [![RuvNet Brain version 3.9.72-dev — updated 2026-07-24 16:09 EDT](https://img.shields.io/badge/version_3.9.72--dev-updated_2026--07--24_16:09_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](https://github.com/stuinfla/ruvnet-brain/blob/main/plugin/.claude-plugin/plugin.json)
 
 **A portable, source-grounded brain over Reuven Cohen's (rUv's) RuvNet stack — delivered as a Claude Code plugin that makes Claude _use_ the stack instead of fighting it.**
 

package/bin/install.mjs

@@ -80,6 +80,7 @@ const FLAG_UNINSTALL = argv.includes('--uninstall'); // reverse everything, in o
 const FLAG_WHAT_CHANGED = argv.includes('--what-changed'); // show our footprint on this machine
 // ── onboarding-experience flags (all optional; every offer is safe to decline) ──
 const FLAG_YES = argv.includes('--yes') || argv.includes('-y'); // accept every optional offer non-interactively
+const FLAG_PLAN = argv.includes('--plan') || argv.includes('--dry-run'); // show the interactive checklist, then exit — install NOTHING
 const FLAG_WITH_STACK = argv.includes('--with-stack'); // add missing Ruflo/RuVector without prompting
 const FLAG_NO_STACK = argv.includes('--no-stack'); // skip the toolkit offer entirely
 const FLAG_ENHANCE_CLAUDE_MD = argv.includes('--enhance-claude-md'); // add the CLAUDE.md section without prompting
@@ -543,6 +544,121 @@ function wirePlugin() {
   return { wired: false, manualMarketplace, manualInstall };
 }
 
+// ── step: wire the Codex host (issue #42, Henrik Pettersen) ──────────────────────────────────────
+// We shipped a .codex/ directory AND a working MCP server and never wired them together, so on a
+// Codex host the brain was entirely absent — no search_ruvnet at all. Every artifact was present;
+// only the registration was missing. Codex reads its MCP servers from ~/.codex/config.toml, which is
+// the USER's file and already carries their own settings, so this MERGES and never rewrites wholesale.
+//
+// Two rules make that merge safe:
+//   1. Our lines live inside a comment-delimited managed block, so a reinstall rewrites exactly
+//      those bytes and leaves every other section byte-identical.
+//   2. An [mcp_servers.ruvnet-brain] found OUTSIDE our markers is the user's, not ours — we report
+//      it and touch nothing. Their hand-written config outranks our convenience.
+//
+// The registered path must also OUTLIVE the install. The npx checkout is ephemeral (the same reason
+// the spend watchdog and the router tools get copied under ~/.claude), and plugin/mcp/server.mjs is
+// self-contained — node builtins only — so it is copied to a persistent home and THAT absolute path
+// is what gets registered. Registering the npx dir would rot the moment the temp dir vanished.
+const CODEX_BLOCK_START = '# --- ruvnet-brain (managed block, installer-rewritten) ---';
+const CODEX_BLOCK_END = '# --- end ruvnet-brain ---';
+const codexHomeDir = () => path.join(os.homedir(), '.codex');
+const codexConfigPath = () => path.join(codexHomeDir(), 'config.toml');
+const codexServerDir = () => path.join(os.homedir(), '.claude', 'ruvnet-brain', 'mcp');
+
+// The exact bytes we own. Kept in one place so the writer and the doctor probe can never disagree.
+function codexManagedBlock(serverPath) {
+  return [
+    CODEX_BLOCK_START,
+    '# Written by `npx ruvnet-brain`. This block is rewritten on every reinstall;',
+    '# everything outside the two markers is yours and is never touched.',
+    '[mcp_servers.ruvnet-brain]',
+    'command = "node"',
+    `args = [${JSON.stringify(serverPath)}]`,
+    CODEX_BLOCK_END,
+  ].join('\n');
+}
+
+// Pure, so the merge contract is testable without going near a real ~/.codex. Returns the new text
+// plus which of the three things happened, and is idempotent: re-running over its own output
+// reproduces it byte for byte.
+export function mergeCodexConfig(existing, serverPath) {
+  const text = typeof existing === 'string' ? existing : '';
+  const block = codexManagedBlock(serverPath);
+  const start = text.indexOf(CODEX_BLOCK_START);
+  const end = text.indexOf(CODEX_BLOCK_END);
+  if (start !== -1 && end > start) {
+    return { text: text.slice(0, start) + block + text.slice(end + CODEX_BLOCK_END.length), action: 'rewritten' };
+  }
+  // Their own declaration, outside our markers. Never clobber a user's hand-written server entry.
+  if (/^[ \t]*\[mcp_servers\.(?:ruvnet-brain|"ruvnet-brain"|'ruvnet-brain')\]/m.test(text)) {
+    return { text, action: 'user-owned' };
+  }
+  const sep = text.length === 0 ? '' : text.endsWith('\n\n') ? '' : text.endsWith('\n') ? '\n' : '\n\n';
+  return { text: `${text}${sep}${block}\n`, action: 'added' };
+}
+
+// What the doctor asserts from disk — never from the fact that we once ran. "Wired" means our entry
+// is in the config AND the server.mjs it points at is really there, because a registration pointing
+// at a deleted file is worse than no registration: Codex fails at spawn time with nothing to read.
+export function codexStatus({ configPath = codexConfigPath(), codexDir = codexHomeDir() } = {}) {
+  let host = false;
+  try { host = fs.existsSync(codexDir); } catch { /* unreadable — treat as absent */ }
+  if (!host) return { host: false, wired: false, serverPath: null, serverExists: false };
+  let text = '';
+  try { text = fs.readFileSync(configPath, 'utf8'); } catch { /* no config yet */ }
+  const m = /^[ \t]*\[mcp_servers\.(?:ruvnet-brain|"ruvnet-brain"|'ruvnet-brain')\][^[]*?args\s*=\s*\[\s*"([^"]+)"/m.exec(text);
+  const serverPath = m ? m[1] : null;
+  let serverExists = false;
+  try { serverExists = serverPath ? fs.existsSync(serverPath) : false; } catch { /* unreadable */ }
+  return { host: true, wired: Boolean(serverPath) && serverExists, serverPath, serverExists };
+}
+
+export function wireCodexHost({
+  codexDir = codexHomeDir(),
+  configPath = path.join(codexDir, 'config.toml'),
+  serverDir = codexServerDir(),
+  source = path.join(__dirname, '..', 'plugin', 'mcp', 'server.mjs'),
+  announce = true,
+} = {}) {
+  let host = false;
+  try { host = fs.existsSync(codexDir); } catch { /* unreadable — treat as absent */ }
+  // No Codex on this machine is not a warning. Say nothing and change nothing.
+  if (!host) return { host: false, action: 'no-host' };
+
+  if (announce) {
+    step('Wiring the Codex host', 'Codex reads MCP servers from ~/.codex/config.toml — the brain was never registered there');
+  }
+  if (!fs.existsSync(source)) {
+    if (announce) warn('MCP server missing from this bundle — Codex left untouched (non-fatal)');
+    return { host: true, action: 'no-source' };
+  }
+  const serverPath = path.join(serverDir, 'server.mjs');
+  fs.mkdirSync(serverDir, { recursive: true });
+  fs.copyFileSync(source, serverPath);
+
+  let before = '';
+  try { before = fs.readFileSync(configPath, 'utf8'); } catch { /* first run — no config yet */ }
+  const { text, action } = mergeCodexConfig(before, serverPath);
+  if (action === 'user-owned') {
+    if (announce) {
+      ok('Codex already declares ruvnet-brain in your own config — left exactly as you wrote it');
+      info(`  to hand it to us instead, delete that ${c.bold('[mcp_servers.ruvnet-brain]')} block and re-run this installer`);
+    }
+    return { host: true, action, serverPath };
+  }
+  if (text !== before) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, text);
+  }
+  if (announce) {
+    ok(`search_ruvnet registered for Codex → ${c.bold(configPath)}`);
+    info(`  server: ${serverPath} ${c.dim('(persistent copy — the npx dir vanishes)')}`);
+    info(`  ${c.dim('only our marked block is written; every other section is byte-preserved')}`);
+  }
+  return { host: true, action, serverPath, changed: text !== before };
+}
+
 // ── step: verify the install is REAL (counts — never take "installed" on faith) ──────────────────
 // Shared state-gatherer behind verifyInstall / --doctor / --feedback: what is REALLY on disk.
 // Pure read, never prints — callers decide how to narrate (or, for --feedback, how to report) it.
@@ -865,13 +981,14 @@ async function doctor() {
   have('git')
     ? ok('git present (not required by this installer, but handy)')
     : info('git not found — that\'s fine, this installer never needs it');
+  cleanupStrayRuvectorDb(); // issue #39: sweep a leftover empty scaffold from before this fix, if one's here
   const env = detectEnvironment();
   env.ruflo
     ? ok('Ruflo present — orchestration / swarms / SPARC available')
     : warn('Ruflo not found — answers still work. To build: npm install -g claude-flow@alpha  (or /plugin add ruvnet/claude-flow)');
   env.ruvector
     ? ok('RuVector present — vector CLI / MCP available')
-    : warn('RuVector not found — answers still work. To add: claude mcp add ruvector --scope user -- npx -y ruvector mcp start');
+    : warn(`RuVector not found — answers still work. To add: ${buildRuvectorMcpAddCommand(env).say}`);
   // Network probe (issue #27, Jan Lafko): in a network-restricted sandbox the cold-cache embedder
   // pull used to hang FOREVER. Diagnose the condition here, explicitly and in 3 seconds flat: if the
   // model host is unreachable AND no local model cache exists, the first query needs the network and
@@ -911,11 +1028,34 @@ async function doctor() {
     console.log(`  ${c.yellow('! Grounding not verifiable')} on this bundle — it predates the citation verifier.`);
     console.log('    Re-run  npx ruvnet-brain  to refresh, then --doctor will prove it.');
   }
+  // Codex is a SECOND host, and until issue #42 the doctor was silent about it — so a machine where
+  // the brain was completely unavailable in Codex still read "Healthy … Grounding PROVEN". Probed
+  // from disk (our entry present AND the server.mjs it names really there), never asserted from the
+  // fact that an install once ran.
+  const cx = codexStatus();
+  if (!cx.host) {
+    console.log(`  ${c.dim('Codex: no host detected (no ~/.codex) — nothing to wire.')}`);
+  } else if (cx.wired) {
+    console.log(`  ${c.green('✓ Codex: wired.')} search_ruvnet is registered in ~/.codex/config.toml and its server exists.`);
+  } else {
+    console.log(`  ${c.yellow('! Codex: host detected but NOT wired')}${
+      cx.serverPath && !cx.serverExists ? ` — registered server is missing (${cx.serverPath})` : ' — no [mcp_servers.ruvnet-brain] entry'
+    }.`);
+    console.log(`    Codex cannot reach the brain until it is. Fix: re-run  ${c.bold('npx ruvnet-brain')}`);
+  }
   console.log(`  ${c.dim(meterSummaryLine())}`);
   if (allGreen) {
     console.log(`\n  ${c.bold('What this means for you:')}`);
-    console.log(`    • ${c.bold('It works in EVERY project')} — user-level (global). Open Claude Code in any repo or VS Code`);
-    console.log(`      window and it's there. ${c.bold('No reinstall per project. No second download.')} One brain, shared.`);
+    // "EVERY project" is a claim about Claude Code. On a machine with an unwired Codex host it would
+    // be read as "every editor", which is exactly the invisible gap issue #42 reported — so scope the
+    // sentence honestly instead of quietly overclaiming.
+    if (cx.host && !cx.wired) {
+      console.log(`    • ${c.bold('It works in EVERY project in Claude Code')} — user-level (global). Open Claude Code in any`);
+      console.log(`      repo or VS Code window and it's there. ${c.bold('No reinstall per project.')} ${c.yellow('Codex is NOT wired yet')} (above).`);
+    } else {
+      console.log(`    • ${c.bold('It works in EVERY project')} — user-level (global). Open Claude Code in any repo or VS Code`);
+      console.log(`      window and it's there. ${c.bold('No reinstall per project. No second download.')} One brain, shared.`);
+    }
     console.log(`    • ${c.bold('Nothing to git-ignore')} in your projects — it drops zero files into your working repos.`);
     console.log(`    • ${c.bold('To use it:')} just ask Claude about rUv's stack (RuVector, Ruflo, AgentDB, SPARC…) — it`);
     console.log(`      grounds the answer automatically and takes the lead on builds. You don't invoke anything.`);
@@ -1682,7 +1822,10 @@ export async function offerSpendGuard() {
   // NOT gated on FLAG_YES — second launchd job, same rule as the nightly updater above.
   if (!process.stdin.isTTY && !FLAG_ENABLE_SPEND_GUARD) { info(`No terminal to prompt on — install it any time with  ${c.bold('npx ruvnet-brain --enable-spend-guard')}`); return 'recommended'; }
   let yes = true;
-  if (!FLAG_ENABLE_SPEND_GUARD) {
+  const plannedSpend = plannedChoice('spend');
+  if (plannedSpend !== undefined) {
+    yes = plannedSpend;   // answered in the up-front checklist — never re-ask
+  } else if (!FLAG_ENABLE_SPEND_GUARD) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const answer = await new Promise((resolve) => rl.question(`    ${c.cyan('?')} Install the spend watchdog? ${c.dim('[Y/n]')} `, resolve));
     rl.close();
@@ -1848,7 +1991,11 @@ export async function offerNightly() {
   }
 
   let yes = true;
-  if (!FLAG_ENABLE_NIGHTLY) {
+  const planned = plannedChoice('nightly');
+  if (planned !== undefined) {
+    // Already answered in the up-front checklist — don't ask twice (the owner's complaint).
+    yes = planned;
+  } else if (!FLAG_ENABLE_NIGHTLY) {
     // Not ask(): its parser treats anything but y/yes as no. Here the DEFAULT is yes — only an
     // explicit n/no declines (parseNightlyAnswer holds that contract, and the tests hold it there).
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -1925,7 +2072,10 @@ export async function offerTelemetry(cacheDir) {
   }
 
   let yes = true; // --yes accepts every optional offer, this one included
-  if (!FLAG_YES) {
+  const plannedTelemetry = plannedChoice('telemetry');
+  if (plannedTelemetry !== undefined) {
+    yes = plannedTelemetry;   // answered in the up-front checklist — never re-ask
+  } else if (!FLAG_YES) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const answer = await new Promise((resolve) =>
       rl.question(`    ${c.cyan('?')} Share anonymous usage counts (installs/searches — never your queries or code)? ${c.dim('[Y/n]')} `, resolve),
@@ -2004,66 +2154,96 @@ async function printPlanAndConfirm() {
   const H = os.homedir();
   const short = (p) => p.replace(H, '~');
 
-  const steps = [
-    { auto: true,  name: 'Download the knowledge base',
-      // short() already renders $HOME as "~"; prefixing another one produced "~~/.cache/…".
+  // The REQUIRED core — always runs, shown for transparency, never a question (nothing works without
+  // these, so asking would be theatre).
+  const core = [
+    { name: 'Download the knowledge base',
       cost: short(resolveCacheDir().cacheDir),
-      what: 'Real rUv source, on your disk, so answers cite files instead of guessing.',
-      undo: 'npx ruvnet-brain --uninstall' },
-    { auto: true,  name: 'Register the Claude Code plugin + MCP server',
+      what: 'Real rUv source, on your disk, so answers cite files instead of guessing.' },
+    { name: 'Register the Claude Code plugin + MCP server',
       cost: `an entry in ${short(path.join(H, '.claude'))}`,
-      what: 'Gives Claude a search_ruvnet tool. Adds no hooks you have not agreed to.',
-      undo: 'npx ruvnet-brain --uninstall' },
-    { ask: true,   name: 'Add rUv tools you are missing',
-      cost: 'npm installs, only the ones you pick',
-      what: 'So the brain can build with them, not just answer questions about them.',
-      undo: 'npm uninstall -g <tool>' },
-    { ask: true,   name: 'Nightly auto-updates',
-      cost: 'one LaunchAgent',
-      what: 'Keeps the KB and plugin current. Recommended — rUv ships fast, and a stale brain is the main way this stops being useful.',
-      undo: 'npx ruvnet-brain --disable-nightly' },
-    { ask: true,   name: 'Spend watchdog',
-      cost: 'one LaunchAgent',
+      what: 'Gives Claude a search_ruvnet tool. Adds no hooks you have not agreed to.' },
+  ];
+  // The OPTIONAL steps — each asked ONCE here, stored in PLAN_CHOICES, and consumed by its offer
+  // later (no second prompt). `def` is the pre-check: nightly + spend are recommended (default yes),
+  // the rest default off. `rec` tags the two recommended ones for the display grouping.
+  const optional = [
+    { key: 'nightly', rec: true,  name: 'Evergreen auto-updates',
+      what: 'Keeps the KB and plugin current — declining makes updates manual forever. rUv ships fast, and a stale brain is the main way this stops being useful.',
+      undo: 'npx ruvnet-brain --disable-nightly', def: true },
+    { key: 'spend',   rec: true,  name: 'Spend watchdog',
       what: 'Warns you if an agent fleet starts burning API credit unexpectedly.',
-      undo: 'npx ruvnet-brain --disable-spend-guard' },
-    { ask: true,   name: 'Status-bar version segment',
-      cost: 'one line in settings.json',
+      undo: 'npx ruvnet-brain --disable-spend-guard', def: true },
+    { key: 'stack',   name: 'Add rUv tools you are missing',
+      what: 'So the brain can build with them, not just answer questions about them. The brain answers grounded questions fine without them.',
+      undo: 'npm uninstall -g <tool>', def: false },
+    { key: 'statusline', name: 'Status-bar version segment',
       what: 'Shows which brain version is live while you work.',
-      undo: 'npx ruvnet-brain --no-statusline, or delete the statusLine entry' },
-    { ask: true,   name: 'Anonymous usage counts',
-      cost: 'a counter ping',
+      undo: 'npx ruvnet-brain --no-statusline', def: false },
+    { key: 'telemetry', name: 'Anonymous usage counts',
       what: 'Installs and searches only — never your queries, your code, or your paths.',
-      undo: 'npx ruvnet-brain --no-telemetry' },
+      undo: 'npx ruvnet-brain --no-telemetry', def: true },
   ];
 
   console.log(`  ${c.bold('Here is everything this will do.')} Nothing has happened yet.\n`);
-  for (const s of steps) {
-    const mark = s.auto ? c.green('✓') : c.cyan('?');
-    console.log(`  ${mark} ${c.bold(s.name)}  ${c.dim('· ' + s.cost)}`);
-    console.log(`      ${s.what}`);
-    console.log(`      ${c.dim('undo: ' + s.undo)}\n`);
+  console.log(`  ${c.bold('The core')} ${c.dim('— required; happens automatically')}`);
+  for (const s of core) {
+    console.log(`    ${c.green('✓')} ${c.bold(s.name)}  ${c.dim('· ' + s.cost)}`);
+    console.log(`        ${s.what}`);
   }
-  console.log(`  ${c.green('✓')} happens automatically.  ${c.cyan('?')} is asked first — and "no" is a complete answer.`);
-  console.log(`  ${c.dim('Every step is reversible, and `npx ruvnet-brain --what-changed` lists everything it touched.')}\n`);
+  console.log('');
 
-  // FLAG_YES means the caller already decided; a plan screen that blocks automation would break
-  // agentic-kit and every scripted install. Print it, then proceed — the information is the point,
-  // the pause is a courtesy to humans.
+  // FLAG_YES / non-TTY: the caller already decided (agentic-kit, scripted installs). Print the plan,
+  // leave PLAN_CHOICES empty, and let each offer honor its own flags/defaults as before. Never block.
   if (FLAG_YES || FLAG_AUTO || !process.stdin.isTTY) {
+    console.log(`  ${c.dim('The rest (auto-update, spend watchdog, extras) is handled non-interactively by each step.')}`);
+    if (FLAG_PLAN) {
+      console.log(`  ${c.dim('--plan: preview only. Nothing was installed.')}\n`);
+      process.exit(0);
+    }
     console.log(c.dim('  (non-interactive — continuing)\n'));
     return;
   }
+
+  // INTERACTIVE CHECKLIST — decide each optional ONCE, here, instead of being re-asked one by one.
+  console.log(`  ${c.bold('Choose the optional pieces')} ${c.dim('— press Enter to accept the [default]; every one is reversible')}\n`);
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const a = await new Promise((r) => rl.question(`  ${c.cyan('?')} Continue? ${c.dim('[Y/n]')} `, r));
+  const askOne = (q, def) => new Promise((resolve) => {
+    const suffix = def ? c.dim('[Y/n]') : c.dim('[y/N]');
+    rl.question(`  ${def ? c.yellow('●') : c.dim('○')} ${c.bold(q)} ${suffix} `, (a) => {
+      const s = String(a).trim().toLowerCase();
+      resolve(s === '' ? def : (s === 'y' || s === 'yes'));
+    });
+  });
+  for (const s of optional) {
+    console.log(`      ${s.what}`);
+    console.log(`      ${c.dim('undo: ' + s.undo)}`);
+    // eslint-disable-next-line no-await-in-loop
+    PLAN_CHOICES[s.key] = await askOne(s.name + (s.rec ? c.dim(' (recommended)') : ''), s.def);
+    console.log('');
+  }
   rl.close();
-  if (/^n/i.test(String(a).trim())) {
-    console.log(`\n  Stopped. Nothing was changed.\n`);
+
+  const on = optional.filter((s) => PLAN_CHOICES[s.key]).map((s) => s.name);
+  console.log(`  ${c.green('✓')} Plan set — the core, plus: ${on.length ? c.bold(on.join(', ')) : c.dim('none of the optional pieces')}.`);
+  if (FLAG_PLAN) {
+    console.log(`  ${c.dim('--plan: preview only. Nothing was installed. Re-run without --plan to apply this.')}\n`);
     process.exit(0);
   }
-  console.log('');
+  console.log(`  ${c.dim('`npx ruvnet-brain --what-changed` lists everything it touched. Installing…')}\n`);
 }
 
-function ask(question, def = false, { blanketYes = true } = {}) {
+// THE CHECKLIST'S ANSWERS, collected ONCE up front in printPlanAndConfirm() and consumed by each
+// offer instead of a second serial prompt. The owner's complaint (2026-07-24): the plan screen
+// showed everything, then every offer asked again, one at a time. Now you decide once. Empty in the
+// non-interactive / --yes / CI paths (printPlanAndConfirm returns before populating it), so every
+// offer falls through to its existing flag/default behavior unchanged.
+export const PLAN_CHOICES = Object.create(null);
+/** The checklist's answer for `key`, or undefined if it wasn't collected (so the offer prompts as before). */
+export function plannedChoice(key) { return key in PLAN_CHOICES ? PLAN_CHOICES[key] : undefined; }
+
+export function ask(question, def = false, { blanketYes = true, planKey = null } = {}) {
+  if (planKey != null) { const p = plannedChoice(planKey); if (p !== undefined) return Promise.resolve(p); }
   if (FLAG_YES && blanketYes) return Promise.resolve(true);
   if (!process.stdin.isTTY) return Promise.resolve(def);
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -2116,12 +2296,79 @@ function detectEnvironment() {
   return env;
 }
 
+// ── issue #39: the ruvector MCP server's own native VectorDb defaults ITS storage to
+// "./ruvector.db" relative to whatever cwd it happens to be launched in — and Claude Code
+// always launches an MCP server with cwd = the current project, so every consumer project got
+// an empty ~1.5MB scaffold dropped in its own root. Traced live (2026-07-24) to
+// ruvector/dist/core/intelligence-engine.js `initVectorDb()`, which constructs the native
+// VectorDb with `{ dimensions, distanceMetric: 'Cosine' }` and NO storagePath at all — that
+// constructor runs unconditionally from a module-level `new Intelligence()` the instant
+// `ruvector mcp start` boots. `claude mcp add` has no --cwd flag, and `ruvector mcp start
+// --help` documents only `-h` (verified live) — no flag or env var lets us set the storage
+// path directly. So the fix has to live in the command we REGISTER: a tiny `node -e` launcher
+// that uses child_process's own `cwd` option (no shell, so it behaves the same on Windows) to
+// relocate into a fixed cache dir before delegating to the real `npx -y ruvector mcp start`.
+// Verified live: this reproduces the exact same empty scaffold, just under
+// ~/.cache/ruvnet-brain/ruvector-mcp instead of whatever project happens to be open.
+const RUVECTOR_MCP_CWD = path.join(os.homedir(), '.cache', 'ruvnet-brain', 'ruvector-mcp');
+function buildRuvectorMcpLauncher(cwd) {
+  return (
+    'const fs=require("fs"),os=require("os"),path=require("path"),cp=require("child_process");' +
+    `const d=${JSON.stringify(cwd)};` +
+    'fs.mkdirSync(d,{recursive:true});' +
+    'const r=cp.spawnSync("npx",["-y","ruvector","mcp","start"],{stdio:"inherit",cwd:d});' +
+    'process.exit(r.status==null?1:r.status);'
+  );
+}
+export function buildRuvectorMcpAddCommand(env, cwd = RUVECTOR_MCP_CWD) {
+  const launcher = buildRuvectorMcpLauncher(cwd);
+  return {
+    shell: env.claude ? ['claude', ['mcp', 'add', 'ruvector', '--scope', 'user', '--', 'node', '-e', launcher]] : null,
+    say: `claude mcp add ruvector --scope user -- node -e '${launcher}'`,
+  };
+}
+
+// ── issue #39 mitigation: clean up the empty ruvector.db this bug already left behind in
+// projects that installed before this fix landed. Matches ONLY the exact empty-scaffold
+// signature (dimensions 384, Cosine, storage_path "./ruvector.db" — literally the string the
+// buggy native default writes, verified live byte-for-byte) under a conservative size cap, so
+// a real store that just happens to share the filename is never at risk: a populated store
+// either exceeds the cap or lacks this exact header.
+const RUVECTOR_EMPTY_DB_SIGNATURE =
+  '{"dimensions":384,"distance_metric":"Cosine","storage_path":"./ruvector.db","hnsw_config":null,"quantization":null}';
+const RUVECTOR_EMPTY_DB_MAX_BYTES = 3 * 1024 * 1024; // observed empty scaffold: 1,589,248 bytes; headroom, still far below any real dataset
+export function cleanupStrayRuvectorDb(dir = process.cwd()) {
+  const p = path.join(dir, 'ruvector.db');
+  let st;
+  try {
+    st = fs.statSync(p);
+  } catch {
+    return false; // doesn't exist — nothing to do
+  }
+  if (!st.isFile() || st.size === 0 || st.size > RUVECTOR_EMPTY_DB_MAX_BYTES) return false;
+  let buf;
+  try {
+    buf = fs.readFileSync(p);
+  } catch {
+    return false; // unreadable — never guess, just leave it alone
+  }
+  if (!buf.includes(RUVECTOR_EMPTY_DB_SIGNATURE)) return false;
+  try {
+    fs.unlinkSync(p);
+  } catch {
+    return false;
+  }
+  warn(`removed ${p} — an empty container the ruvector MCP server left in this project before issue #39 was fixed (matched the known empty signature; nothing was stored in it)`);
+  return true;
+}
+
 // ── step: is the rUv toolkit here? the brain ANSWERS alone; it BUILDS best with Ruflo + RuVector ──
 async function offerStack(env) {
   step(
     'Checking your rUv toolkit',
     "the brain answers on its own with zero setup — but it can also BUILD, and that shines when the tools it recommends are here",
   );
+  cleanupStrayRuvectorDb(); // issue #39: sweep a leftover scaffold from before this fix, if one's here
   const mark = (ok) => (ok ? c.green('✓ present') : c.yellow('— not found'));
   info(`platform: ${c.bold(`${env.platform}/${env.arch}`)} · node ${c.bold(env.node)}`);
   info(`Ruflo (claude-flow · swarms / SPARC / orchestration): ${mark(env.ruflo)}`);
@@ -2147,9 +2394,9 @@ async function offerStack(env) {
       what: 'RuVector (vectors / RVF)',
       // --scope user: same reason the plugin itself installs at user scope — the brain is "one
       // toolkit, every project", and the default "local" scope ties the server to whatever
-      // directory happens to be the cwd when this runs.
-      shell: env.claude ? ['claude', ['mcp', 'add', 'ruvector', '--scope', 'user', '--', 'npx', '-y', 'ruvector', 'mcp', 'start']] : null,
-      say: 'claude mcp add ruvector --scope user -- npx -y ruvector mcp start',
+      // directory happens to be the cwd when this runs. The registered command itself also
+      // pins ITS OWN cwd (issue #39) — see buildRuvectorMcpAddCommand above.
+      ...buildRuvectorMcpAddCommand(env),
       plugin: null,
       verify: () => hasUserScopeMcpServer('ruvector'),
     });
@@ -2169,7 +2416,7 @@ async function offerStack(env) {
     return;
   }
 
-  const yes = FLAG_WITH_STACK || (await ask('Add the missing rUv tools now so the brain can build, not just answer?', false));
+  const yes = FLAG_WITH_STACK || (await ask('Add the missing rUv tools now so the brain can build, not just answer?', false, { planKey: 'stack' }));
   if (!yes) {
     info("No problem — nothing's missing for answers. To add the build tools any time:");
     printCmds();
@@ -2457,7 +2704,7 @@ export async function offerStatusline() {
     return 'not-asked';
   }
 
-  const yes = FLAG_STATUSLINE || (await ask('Add a RuvNet Brain version segment to your Claude Code status bar?', false, { blanketYes: false }));
+  const yes = FLAG_STATUSLINE || (await ask('Add a RuvNet Brain version segment to your Claude Code status bar?', false, { blanketYes: false, planKey: 'statusline' }));
 
   try {
     fs.mkdirSync(telemetryStateDir(), { recursive: true });
@@ -2768,6 +3015,9 @@ It is safe to re-run at any time. After installing, restart Claude Code so the g
 
   installReader(cacheDir);
   const plugin = wirePlugin();
+  // Codex hosts got nothing before this (issue #42): shipped, never registered. Non-fatal like every
+  // other wiring step — a second host we cannot reach must never break the one we can.
+  try { wireCodexHost(); } catch (e) { warn(`(Codex wiring skipped: ${e && e.message})`); }
   if (!FLAG_NO_VERIFY) {
     verifyInstall(cacheDir);
     await smokeQuery(cacheDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "3.9.68-dev",
+  "version": "3.9.72-dev",
   "description": "One-command installer for RuvNet Brain \u2014 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": {