context-vault 3.4.3 → 3.4.5

package/bin/cli.js

@@ -1,5 +1,15 @@
 #!/usr/bin/env node
 
+// Suppress Node.js ExperimentalWarning for built-in SQLite (used by context-vault)
+const originalEmit = process.emit;
+process.emit = function (name, data, ...args) {
+  if (name === 'warning' && typeof data === 'object' && data?.name === 'ExperimentalWarning' &&
+      typeof data?.message === 'string' && data.message.includes('SQLite')) {
+    return false;
+  }
+  return originalEmit.call(process, name, data, ...args);
+};
+
 // Node.js version guard — must run before any ESM imports
 const nodeVersion = parseInt(process.versions.node.split('.')[0], 10);
 if (nodeVersion < 22) {
@@ -47,6 +57,7 @@ import { homedir, platform } from 'node:os';
 import { execSync, execFile, execFileSync, spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { APP_URL, API_URL, MARKETING_URL } from '@context-vault/core/constants';
+import { assertNotTestMode } from '@context-vault/core/config';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -353,12 +364,14 @@ ${bold('Commands:')}
   ${cyan('hooks')} install|uninstall    Install or remove Claude Code memory hook
   ${cyan('claude')} install|uninstall   Alias for hooks install|uninstall
   ${cyan('skills')} install             Install bundled Claude Code skills
+  ${cyan('rules')} install              Install agent rules for detected AI tools
   ${cyan('health')}                     Quick health check — vault, DB, entry count
   ${cyan('status')}                     Show vault diagnostics
   ${cyan('doctor')}                     Diagnose and repair common issues
   ${cyan('debug')}                      Generate AI-pasteable debug report
   ${cyan('daemon')} start|stop|status    Run vault as a shared HTTP daemon (one process, all sessions)
   ${cyan('restart')}                    Stop running MCP server processes (client auto-restarts)
+  ${cyan('reconnect')}                  Fix vault path, kill stale servers, re-register MCP, reindex
   ${cyan('search')}                     Search vault entries from CLI
   ${cyan('save')}                       Save an entry to the vault from CLI
   ${cyan('import')} <path>              Import entries from file, directory, or .zip archive
@@ -545,7 +558,7 @@ async function runSetup() {
         }
       } catch {}
 
-      console.log(`\n  ${dim('[2/2]')}${bold(' Configuring tools...\n')}`);
+      console.log(`\n  ${dim('[2/3]')}${bold(' Configuring tools...\n')}`);
       for (const tool of selected) {
         try {
           if (tool.configType === 'cli' && tool.id === 'codex') {
@@ -561,6 +574,40 @@ async function runSetup() {
         }
       }
 
+      // Offer rules installation for users who previously skipped or used an older version
+      console.log(`\n  ${dim('[3/3]')}${bold(' Agent rules...\n')}`);
+      const rulesContent = loadAgentRules();
+      if (rulesContent && !flags.has('--no-rules')) {
+        const missingRules = selected.filter((t) => {
+          const p = getRulesPathForTool(t);
+          return p && !existsSync(p);
+        });
+        if (missingRules.length > 0) {
+          console.log(dim('  Agent rules teach your AI when to save knowledge automatically.'));
+          console.log(dim('  No rules file detected for: ' + missingRules.map((t) => t.name).join(', ')));
+          console.log();
+          const rulesAnswer = await prompt('  Install agent rules? (Y/n):', 'Y');
+          if (rulesAnswer.toLowerCase() !== 'n') {
+            for (const tool of missingRules) {
+              try {
+                const ok = installAgentRulesForTool(tool, rulesContent);
+                const rulesPath = getRulesPathForTool(tool);
+                if (ok) {
+                  console.log(`  ${green('+')} ${tool.name} — agent rules installed`);
+                  if (rulesPath) console.log(`     ${dim(rulesPath)}`);
+                }
+              } catch (e) {
+                console.log(`  ${red('x')} ${tool.name} — ${e.message}`);
+              }
+            }
+          } else {
+            console.log(dim('  Skipped — install later: context-vault rules install'));
+          }
+        } else {
+          console.log(dim('  Agent rules already installed — skipping.'));
+        }
+      }
+
       console.log();
       console.log(green('  ✓ Tool configs updated.'));
       console.log(dim('  Restart your AI tools to apply the changes.'));
@@ -810,6 +857,7 @@ async function runSetup() {
     `  ${telemetryEnabled ? green('+') : dim('-')} Telemetry: ${telemetryEnabled ? 'enabled' : 'disabled'}`
   );
 
+  assertNotTestMode(configPath);
   writeFileSync(configPath, JSON.stringify(vaultConfig, null, 2) + '\n');
   console.log(`\n  ${green('+')} Wrote ${configPath}`);
 
@@ -902,12 +950,11 @@ async function runSetup() {
     } catch {}
   }
 
-  // Configure each tool — pass vault dir as arg if non-default
+  // Configure each tool — always pass vault dir explicitly to prevent config drift
   console.log(`\n  ${dim('[5/6]')}${bold(' Configuring tools...\n')}`);
   verbose(userLevel, 'Writing config so your AI tool can find your vault.\n');
   const results = [];
-  const defaultVDir = join(HOME, 'vault');
-  const customVaultDir = resolvedVaultDir !== resolve(defaultVDir) ? resolvedVaultDir : null;
+  const customVaultDir = resolvedVaultDir;
 
   for (const tool of selected) {
     try {
@@ -938,8 +985,8 @@ async function runSetup() {
       console.log(dim('  Searches your vault on every prompt and injects relevant entries'));
       console.log(dim("  as additional context alongside Claude's native memory."));
       console.log();
-      const answer = await prompt('  Install Claude Code memory hook? (y/N):', 'N');
-      installHook = answer.toLowerCase() === 'y';
+      const answer = await prompt('  Install Claude Code memory hook? (Y/n):', 'Y');
+      installHook = answer.toLowerCase() !== 'n';
     }
     if (installHook) {
       try {
@@ -1006,6 +1053,7 @@ async function runSetup() {
     console.log();
     console.log(dim('  Install Claude Code skills? (recommended)'));
     console.log(dim('  compile-context — compile vault entries into a project brief'));
+    console.log(dim('  vault-setup     — agent-assisted vault customization (/vault-setup)'));
     console.log();
     const skillAnswer = await prompt('  Install Claude Code skills? (Y/n):', 'Y');
     const installSkillsFlag = skillAnswer.toLowerCase() !== 'n';
@@ -1025,6 +1073,48 @@ async function runSetup() {
     }
   }
 
+  // Agent rules installation (opt-in per tool, skip if --no-rules)
+  const configuredTools = results.filter((r) => r.ok).map((r) => r.tool);
+  const installedRulesPaths = [];
+  if (configuredTools.length > 0 && !flags.has('--no-rules')) {
+    let installRules = isNonInteractive;
+    if (!isNonInteractive) {
+      console.log();
+      console.log(dim('  Install agent rules? (recommended)'));
+      console.log(dim('  Teaches your AI agent when and how to save knowledge to the vault'));
+      console.log(dim('  automatically — the key to building useful memory over time.'));
+      console.log();
+      const rulesAnswer = await prompt('  Install agent rules? (Y/n):', 'Y');
+      installRules = rulesAnswer.toLowerCase() !== 'n';
+    }
+    if (installRules) {
+      const rulesContent = loadAgentRules();
+      if (rulesContent) {
+        for (const tool of configuredTools) {
+          try {
+            const installed = installAgentRulesForTool(tool, rulesContent);
+            const rulesPath = getRulesPathForTool(tool);
+            if (installed) {
+              console.log(`  ${green('+')} ${tool.name} — agent rules installed`);
+              if (rulesPath) {
+                console.log(`     ${dim(rulesPath)}`);
+                installedRulesPaths.push({ tool: tool.name, path: rulesPath });
+              }
+            }
+          } catch (e) {
+            console.log(`  ${red('x')} ${tool.name} — ${e.message}`);
+          }
+        }
+      } else {
+        console.log(dim('  Agent rules file not found in package — skipping.'));
+      }
+    } else {
+      console.log(dim('  Skipped — install later: context-vault rules install'));
+    }
+  } else if (flags.has('--no-rules')) {
+    console.log(dim('  Agent rules skipped (--no-rules)'));
+  }
+
   // Seed entry
   const seeded = createSeedEntries(resolvedVaultDir);
   if (seeded > 0) {
@@ -1128,6 +1218,21 @@ async function runSetup() {
         : []),
     ];
   }
+  if (installedRulesPaths.length > 0) {
+    boxLines.push(``, `  ${bold('Agent rules installed:')}`);
+    for (const { path } of installedRulesPaths) {
+      boxLines.push(`  ${dim(path)}`);
+    }
+    boxLines.push(
+      ``,
+      `  ${dim(`View:   ${cli} rules show`)}`,
+      `  ${dim(`Remove: ${cli} uninstall`)}`,
+      `  ${dim(`Skip:   ${cli} setup --no-rules`)}`
+    );
+  }
+  if (claudeConfigured) {
+    boxLines.push(``, `  ${dim('Personalize: run /vault-setup in your next session')}`);
+  }
   const innerWidth = Math.max(...boxLines.map((l) => l.length)) + 2;
   const pad = (s) => s + ' '.repeat(Math.max(0, innerWidth - s.length));
   console.log();
@@ -1368,8 +1473,8 @@ function configureJsonTool(tool, vaultDir) {
 function createSeedEntries(vaultDir) {
   let created = 0;
 
-  // Entry 1: Getting started (improved)
-  const insightDir = join(vaultDir, 'knowledge', 'insights');
+  // Entry 1: Getting started
+  const insightDir = join(vaultDir, 'knowledge', 'insight');
   const insightPath = join(insightDir, 'getting-started.md');
   if (!existsSync(insightPath)) {
     mkdirSync(insightDir, { recursive: true });
@@ -1379,6 +1484,9 @@ function createSeedEntries(vaultDir) {
       insightPath,
       `---
 id: ${id1}
+title: Getting started with your context vault
+kind: insight
+tier: durable
 tags: ["getting-started", "vault"]
 source: context-vault-setup
 created: ${now}
@@ -1402,7 +1510,7 @@ ${insightPath}
   }
 
   // Entry 2: Example decision
-  const decisionDir = join(vaultDir, 'knowledge', 'decisions');
+  const decisionDir = join(vaultDir, 'knowledge', 'decision');
   const decisionPath = join(decisionDir, 'example-local-first-data.md');
   if (!existsSync(decisionPath)) {
     mkdirSync(decisionDir, { recursive: true });
@@ -1412,6 +1520,9 @@ ${insightPath}
       decisionPath,
       `---
 id: ${id2}
+title: Use local-first data storage over cloud databases
+kind: decision
+tier: durable
 tags: ["example", "architecture"]
 source: context-vault-setup
 created: ${now}
@@ -1584,6 +1695,7 @@ async function runConnect() {
   modeConfig.mode = 'hosted';
   modeConfig.hostedUrl = hostedUrl;
   mkdirSync(join(HOME, '.context-mcp'), { recursive: true });
+  assertNotTestMode(modeConfigPath);
   writeFileSync(modeConfigPath, JSON.stringify(modeConfig, null, 2) + '\n');
 
   console.log();
@@ -1696,6 +1808,7 @@ async function runSwitch() {
   if (target === 'local') {
     vaultConfig.mode = 'local';
     mkdirSync(dataDir, { recursive: true });
+    assertNotTestMode(configPath);
     writeFileSync(configPath, JSON.stringify(vaultConfig, null, 2) + '\n');
 
     console.log();
@@ -1756,6 +1869,7 @@ async function runSwitch() {
     vaultConfig.hostedUrl = hostedUrl;
     vaultConfig.apiKey = apiKey;
     mkdirSync(dataDir, { recursive: true });
+    assertNotTestMode(configPath);
     writeFileSync(configPath, JSON.stringify(vaultConfig, null, 2) + '\n');
 
     for (const tool of detected) {
@@ -2131,6 +2245,11 @@ async function runStatus() {
   }
 
   const status = gatherVaultStatus({ db, config });
+  let schemaVersion = 'unknown';
+  try {
+    const row = db.prepare('PRAGMA user_version').get();
+    schemaVersion = String(row?.user_version ?? 'unknown');
+  } catch {}
 
   db.close();
 
@@ -2148,7 +2267,7 @@ async function runStatus() {
     `  Config:    ${config.configPath} ${dim(`(${existsSync(config.configPath) ? 'exists' : 'missing'})`)}`
   );
   console.log(`  Resolved:  ${status.resolvedFrom}`);
-  console.log(`  Schema:    v7 (teams)`);
+  console.log(`  Schema:    v${schemaVersion}`);
 
   if (status.kindCounts.length) {
     const BAR_WIDTH = 20;
@@ -2159,7 +2278,8 @@ async function runStatus() {
       const filled = maxCount > 0 ? Math.round((c / maxCount) * BAR_WIDTH) : 0;
       const bar = '█'.repeat(filled) + '░'.repeat(BAR_WIDTH - filled);
       const countStr = String(c).padStart(4);
-      console.log(`    ${dim(bar)} ${countStr} ${kind}s`);
+      const plural = kind.endsWith('s') ? kind : kind + 's';
+      console.log(`    ${dim(bar)} ${countStr} ${plural}`);
     }
   } else {
     console.log(`\n  ${dim('(empty — no entries indexed)')}`);
@@ -2325,6 +2445,34 @@ async function runUninstall() {
     console.log(`  ${green('+')} Removed installed skills`);
   }
 
+  // Remove agent rules files
+  const claudeRulesPath = join(HOME, '.claude', 'rules', 'context-vault.md');
+  const cursorRulesPath = join(HOME, '.cursor', 'rules', 'context-vault.mdc');
+  const windsurfRulesPath = join(HOME, '.windsurfrules');
+
+  if (existsSync(claudeRulesPath)) {
+    unlinkSync(claudeRulesPath);
+    console.log(`  ${green('+')} Removed agent rules (Claude Code: ${claudeRulesPath})`);
+  }
+  if (existsSync(cursorRulesPath)) {
+    unlinkSync(cursorRulesPath);
+    console.log(`  ${green('+')} Removed agent rules (Cursor: ${cursorRulesPath})`);
+  }
+  if (existsSync(windsurfRulesPath)) {
+    const content = readFileSync(windsurfRulesPath, 'utf-8');
+    if (content.includes(RULES_DELIMITER_START)) {
+      const cleaned = content
+        .replace(new RegExp(`\n?${RULES_DELIMITER_START}[\\s\\S]*?${RULES_DELIMITER_END}\n?`, 'g'), '\n')
+        .trim();
+      if (cleaned) {
+        writeFileSync(windsurfRulesPath, cleaned + '\n');
+      } else {
+        unlinkSync(windsurfRulesPath);
+      }
+      console.log(`  ${green('+')} Removed agent rules section from ${windsurfRulesPath}`);
+    }
+  }
+
   // Optionally remove data directory
   const dataDir = join(HOME, '.context-mcp');
   if (existsSync(dataDir)) {
@@ -3936,6 +4084,77 @@ function installSkills() {
   return installed;
 }
 
+const RULES_DELIMITER_START = '<!-- context-vault agent rules -->';
+const RULES_DELIMITER_END = '<!-- /context-vault agent rules -->';
+
+/**
+ * Load agent-rules.md from the assets directory.
+ * Returns the file content or null if not found.
+ */
+function loadAgentRules() {
+  const rulesPath = join(ROOT, 'assets', 'agent-rules.md');
+  if (!existsSync(rulesPath)) return null;
+  return readFileSync(rulesPath, 'utf-8');
+}
+
+/**
+ * Return the path where agent rules are/would be installed for a given tool.
+ * Returns null for tools with no rules install path.
+ */
+function getRulesPathForTool(tool) {
+  if (tool.id === 'claude-code') return join(HOME, '.claude', 'rules', 'context-vault.md');
+  if (tool.id === 'cursor') return join(HOME, '.cursor', 'rules', 'context-vault.mdc');
+  if (tool.id === 'windsurf') return join(HOME, '.windsurfrules');
+  return null;
+}
+
+/**
+ * Install agent rules for a specific tool.
+ * - Claude Code: writes ~/.claude/rules/context-vault.md
+ * - Cursor: appends to .cursorrules in cwd (with delimiters)
+ * - Windsurf: appends to .windsurfrules in cwd (with delimiters)
+ * - Other tools: skipped
+ * Returns true if installed, false if skipped or already present.
+ */
+function installAgentRulesForTool(tool, rulesContent) {
+  if (tool.id === 'claude-code') {
+    const rulesDir = join(HOME, '.claude', 'rules');
+    const rulesPath = join(rulesDir, 'context-vault.md');
+    if (existsSync(rulesPath)) {
+      const existing = readFileSync(rulesPath, 'utf-8');
+      if (existing.trim() === rulesContent.trim()) return false;
+    }
+    mkdirSync(rulesDir, { recursive: true });
+    writeFileSync(rulesPath, rulesContent);
+    return true;
+  }
+
+  if (tool.id === 'cursor') {
+    const rulesPath = join(HOME, '.cursor', 'rules', 'context-vault.mdc');
+    // Cursor supports project rules in .cursor/rules/ directory
+    if (existsSync(rulesPath)) return false;
+    mkdirSync(join(HOME, '.cursor', 'rules'), { recursive: true });
+    writeFileSync(rulesPath, rulesContent);
+    return true;
+  }
+
+  if (tool.id === 'windsurf') {
+    const rulesPath = join(HOME, '.windsurfrules');
+    const delimited = `\n${RULES_DELIMITER_START}\n${rulesContent}\n${RULES_DELIMITER_END}\n`;
+    if (existsSync(rulesPath)) {
+      const existing = readFileSync(rulesPath, 'utf-8');
+      if (existing.includes(RULES_DELIMITER_START)) return false;
+      writeFileSync(rulesPath, existing + delimited);
+    } else {
+      writeFileSync(rulesPath, delimited.trimStart());
+    }
+    return true;
+  }
+
+  // Other tools: no rules installation path yet
+  return false;
+}
+
 /** Returns the path to Claude Code's global settings.json */
 function claudeSettingsPath() {
   return join(HOME, '.claude', 'settings.json');
@@ -4291,6 +4510,149 @@ ${bold('Commands:')}
 
 ${bold('Bundled skills:')}
   ${cyan('compile-context')}  Compile vault entries into a project brief using create_snapshot
+  ${cyan('vault-setup')}      Agent-assisted vault customization (run /vault-setup)
+`);
+  }
+}
+
+async function runRules() {
+  const sub = args[1];
+
+  if (sub === 'install') {
+    console.log();
+    const rulesContent = loadAgentRules();
+    if (!rulesContent) {
+      console.log(`  ${yellow('!')} Agent rules file not found in package.\n`);
+      process.exit(1);
+    }
+
+    const { detected } = await detectAllTools();
+    if (detected.length === 0) {
+      console.log(`  ${yellow('!')} No supported tools detected.\n`);
+      process.exit(1);
+    }
+
+    let installed = 0;
+    for (const tool of detected) {
+      try {
+        const ok = installAgentRulesForTool(tool, rulesContent);
+        const rulesPath = getRulesPathForTool(tool);
+        if (ok) {
+          console.log(`  ${green('+')} ${tool.name} — agent rules installed`);
+          if (rulesPath) console.log(`     ${dim(rulesPath)}`);
+          installed++;
+        } else {
+          const hasPath = !!rulesPath;
+          const alreadyExists = hasPath && existsSync(rulesPath);
+          if (alreadyExists) {
+            console.log(`  ${dim('-')} ${tool.name} — already installed`);
+          } else if (hasPath) {
+            console.log(`  ${dim('-')} ${tool.name} — skipped (up to date)`);
+          } else {
+            console.log(`  ${dim('-')} ${tool.name} — not supported`);
+          }
+        }
+      } catch (e) {
+        console.log(`  ${red('x')} ${tool.name} — ${e.message}`);
+      }
+    }
+
+    console.log();
+    if (installed > 0) {
+      console.log(dim('  Rules teach your AI agent when to save knowledge automatically.'));
+      console.log(dim('  Restart your AI tools to apply.'));
+      console.log(dim(`  View:   context-vault rules show`));
+      console.log(dim(`  Remove: context-vault uninstall`));
+    }
+    console.log();
+  } else if (sub === 'show') {
+    const { detected } = await detectAllTools();
+    const tool = detected.find((t) => getRulesPathForTool(t));
+    if (!tool) {
+      console.log(`\n  ${yellow('!')} No supported tool detected.\n`);
+      process.exit(1);
+    }
+    const rulesPath = getRulesPathForTool(tool);
+    if (!rulesPath || !existsSync(rulesPath)) {
+      console.log(`\n  ${yellow('!')} No rules file installed for ${tool.name}.`);
+      console.log(dim(`  Run: context-vault rules install\n`));
+      process.exit(1);
+    }
+    console.log(`\n  ${dim(`${tool.name}: ${rulesPath}`)}\n`);
+    console.log(readFileSync(rulesPath, 'utf-8'));
+  } else if (sub === 'path') {
+    const { detected } = await detectAllTools();
+    const supportedTools = detected.filter((t) => getRulesPathForTool(t));
+    if (supportedTools.length === 0) {
+      console.log(`\n  ${yellow('!')} No supported tool detected.\n`);
+      process.exit(1);
+    }
+    console.log();
+    for (const tool of supportedTools) {
+      const p = getRulesPathForTool(tool);
+      const installed = existsSync(p);
+      console.log(`  ${tool.name}: ${p} ${installed ? green('(installed)') : dim('(not installed)')}`);
+    }
+    console.log();
+  } else if (sub === 'diff') {
+    const bundled = loadAgentRules();
+    if (!bundled) {
+      console.log(`\n  ${yellow('!')} Agent rules file not found in package.\n`);
+      process.exit(1);
+    }
+    const { detected } = await detectAllTools();
+    const tool = detected.find((t) => getRulesPathForTool(t));
+    if (!tool) {
+      console.log(`\n  ${yellow('!')} No supported tool detected.\n`);
+      process.exit(1);
+    }
+    const rulesPath = getRulesPathForTool(tool);
+    if (!rulesPath || !existsSync(rulesPath)) {
+      console.log(`\n  ${yellow('!')} No rules file installed for ${tool.name}.`);
+      console.log(dim(`  Run: context-vault rules install\n`));
+      process.exit(1);
+    }
+    const installed = readFileSync(rulesPath, 'utf-8');
+    if (installed.trim() === bundled.trim()) {
+      console.log(`\n  ${green('✓')} Rules are up to date (${rulesPath})\n`);
+    } else {
+      console.log(`\n  ${yellow('!')} Installed rules differ from bundled version.`);
+      console.log(`  ${dim(rulesPath)}\n`);
+      const installedLines = installed.split('\n');
+      const bundledLines = bundled.split('\n');
+      const maxLines = Math.max(installedLines.length, bundledLines.length);
+      for (let i = 0; i < maxLines; i++) {
+        const a = installedLines[i];
+        const b = bundledLines[i];
+        if (a === undefined) {
+          console.log(`  ${green('+')} ${b}`);
+        } else if (b === undefined) {
+          console.log(`  ${red('-')} ${a}`);
+        } else if (a !== b) {
+          console.log(`  ${red('-')} ${a}`);
+          console.log(`  ${green('+')} ${b}`);
+        }
+      }
+      console.log();
+      console.log(dim('  To upgrade: context-vault rules install'));
+      console.log();
+    }
+  } else {
+    console.log(`
+  ${bold('context-vault rules')} <command>
+
+  Manage agent rules that teach AI tools when and how to use the vault.
+
+${bold('Commands:')}
+  ${cyan('rules install')}   Install agent rules for all detected AI tools
+  ${cyan('rules show')}      Print the currently installed rules file
+  ${cyan('rules diff')}      Show diff between installed rules and bundled version
+  ${cyan('rules path')}      Print the path where rules are/would be installed
+
+${bold('Installed to:')}
+  ${cyan('Claude Code')}     ~/.claude/rules/context-vault.md
+  ${cyan('Cursor')}          ~/.cursor/rules/context-vault.mdc
+  ${cyan('Windsurf')}        ~/.windsurfrules (appended with delimiters)
 `);
   }
 }
@@ -5105,6 +5467,160 @@ async function runRestart() {
   console.log();
 }
 
+async function runReconnect() {
+  console.log();
+  console.log(`  ${bold('◇ context-vault reconnect')}`);
+  console.log();
+
+  // 1. Read current config to get the correct vault dir
+  const { resolveConfig } = await import('@context-vault/core/config');
+  const config = resolveConfig();
+  const vaultDir = config.vaultDir;
+
+  console.log(`  Vault dir: ${cyan(vaultDir)}`);
+  if (!existsSync(vaultDir)) {
+    console.error(red(`  Vault directory does not exist: ${vaultDir}`));
+    console.error(dim(`  Run context-vault setup to configure.`));
+    process.exit(1);
+  }
+
+  // Count entries to confirm it's a real vault
+  const mdFiles = readdirSync(vaultDir, { recursive: true })
+    .filter(f => String(f).endsWith('.md'));
+  console.log(`  Found ${mdFiles.length} markdown files`);
+  console.log();
+
+  // 2. Kill all running context-vault serve processes (they have stale --vault-dir)
+  const isWin = platform() === 'win32';
+  let psOutput;
+  try {
+    const psCmd = isWin
+      ? 'wmic process where "CommandLine like \'%context-vault%\'" get ProcessId,CommandLine /format:list'
+      : 'ps aux';
+    psOutput = execSync(psCmd, { encoding: 'utf-8', timeout: 5000 });
+  } catch (e) {
+    console.error(red(`  Failed to list processes: ${e.message}`));
+    process.exit(1);
+  }
+
+  const currentPid = process.pid;
+  const serverPids = [];
+
+  if (isWin) {
+    const pidMatches = psOutput.matchAll(/ProcessId=(\d+)/g);
+    for (const m of pidMatches) {
+      const pid = parseInt(m[1], 10);
+      if (pid !== currentPid) serverPids.push(pid);
+    }
+  } else {
+    const lines = psOutput.split('\n');
+    for (const line of lines) {
+      const match = line.match(/^\S+\s+(\d+)\s/);
+      if (!match) continue;
+      const pid = parseInt(match[1], 10);
+      if (pid === currentPid) continue;
+      if (
+        /context-vault.*(serve|stdio|server\/index)/.test(line) ||
+        /server\/index\.js.*context-vault/.test(line)
+      ) {
+        serverPids.push(pid);
+      }
+    }
+  }
+
+  if (serverPids.length > 0) {
+    console.log(`  Stopping ${serverPids.length} stale server process${serverPids.length === 1 ? '' : 'es'}...`);
+    for (const pid of serverPids) {
+      try {
+        process.kill(pid, 'SIGTERM');
+        console.log(`  ${green('✓')} Stopped PID ${pid}`);
+      } catch (e) {
+        if (e.code !== 'ESRCH') {
+          console.log(`  ${yellow('!')} Could not stop PID ${pid}: ${e.message}`);
+        }
+      }
+    }
+    // Wait for graceful shutdown
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+    // Force-kill any survivors
+    for (const pid of serverPids) {
+      try { process.kill(pid, 0); process.kill(pid, 'SIGKILL'); } catch {}
+    }
+    console.log();
+  } else {
+    console.log(dim('  No running server processes found.'));
+    console.log();
+  }
+
+  // 3. Re-register MCP server with correct vault-dir for each detected tool
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+
+  const tools = [];
+  try { execSync('which claude', { stdio: 'pipe' }); tools.push('claude'); } catch {}
+  try { execSync('which codex', { stdio: 'pipe' }); tools.push('codex'); } catch {}
+
+  for (const tool of tools) {
+    try {
+      execFileSync(tool, ['mcp', 'remove', 'context-vault', '-s', 'user'], { stdio: 'pipe', env });
+    } catch {}
+
+    try {
+      if (isInstalledPackage()) {
+        execFileSync(
+          tool,
+          ['mcp', 'add', '-s', 'user', 'context-vault', '--', 'context-vault', 'serve', '--vault-dir', vaultDir],
+          { stdio: 'pipe', env }
+        );
+      } else if (isNpx()) {
+        execFileSync(
+          tool,
+          ['mcp', 'add', '-s', 'user', 'context-vault', '-e', 'NODE_OPTIONS=--no-warnings=ExperimentalWarning',
+           '--', 'npx', '-y', 'context-vault', 'serve', '--vault-dir', vaultDir],
+          { stdio: 'pipe', env }
+        );
+      } else {
+        execFileSync(
+          tool,
+          ['mcp', 'add', '-s', 'user', 'context-vault', '-e', 'NODE_OPTIONS=--no-warnings=ExperimentalWarning',
+           '--', process.execPath, SERVER_PATH, '--vault-dir', vaultDir],
+          { stdio: 'pipe', env }
+        );
+      }
+      console.log(`  ${green('✓')} ${tool} MCP re-registered with vault-dir: ${vaultDir}`);
+    } catch (e) {
+      console.log(`  ${red('✘')} Failed to register ${tool}: ${e.stderr?.toString().trim() || e.message}`);
+    }
+  }
+
+  // 4. Reindex to ensure DB matches vault dir
+  console.log();
+  console.log(`  Reindexing...`);
+  try {
+    const { initDatabase, prepareStatements, insertVec, deleteVec } =
+      await import('@context-vault/core/db');
+    const { embed } = await import('@context-vault/core/embed');
+    const { reindex } = await import('@context-vault/core/index');
+    const db = await initDatabase(config.dbPath);
+    const stmts = prepareStatements(db);
+    const ctx = {
+      db, config, stmts, embed,
+      insertVec: (r, e) => insertVec(stmts, r, e),
+      deleteVec: (r) => deleteVec(stmts, r),
+    };
+    const stats = await reindex(ctx, { fullSync: true });
+    db.close();
+    console.log(`  ${green('✓')} Reindex: +${stats.added} added, ~${stats.updated} updated, -${stats.removed} removed`);
+  } catch (e) {
+    console.log(`  ${yellow('!')} Reindex failed: ${e.message}`);
+    console.log(dim(`    Run 'context-vault reindex --vault-dir ${vaultDir}' manually.`));
+  }
+
+  console.log();
+  console.log(green('  Reconnected.') + dim(' Start a new Claude session to use the updated vault.'));
+  console.log();
+}
+
 async function runConsolidate() {
   const dryRun = flags.has('--dry-run');
   const tagArg = getFlag('--tag');
@@ -5657,6 +6173,9 @@ async function main() {
     case 'skills':
       await runSkills();
       break;
+    case 'rules':
+      await runRules();
+      break;
     case 'flush':
       await runFlush();
       break;
@@ -5726,6 +6245,9 @@ async function main() {
     case 'restart':
       await runRestart();
       break;
+    case 'reconnect':
+      await runReconnect();
+      break;
     case 'consolidate':
       await runConsolidate();
       break;