context-vault 3.4.4 → 3.5.0

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);
@@ -241,12 +252,16 @@ const TOOLS = [
     name: 'Claude Code',
     detect: () => commandExistsAsync('claude'),
     configType: 'cli',
+    rulesPath: join(HOME, '.claude', 'rules', 'context-vault.md'),
+    rulesMethod: 'write',
   },
   {
     id: 'codex',
     name: 'Codex',
     detect: () => commandExistsAsync('codex'),
     configType: 'cli',
+    rulesPath: null,
+    rulesMethod: null,
   },
   {
     id: 'claude-desktop',
@@ -255,6 +270,8 @@ const TOOLS = [
     configType: 'json',
     configPath: join(appDataDir(), 'Claude', 'claude_desktop_config.json'),
     configKey: 'mcpServers',
+    rulesPath: null,
+    rulesMethod: null,
   },
   {
     id: 'cursor',
@@ -263,6 +280,8 @@ const TOOLS = [
     configType: 'json',
     configPath: join(HOME, '.cursor', 'mcp.json'),
     configKey: 'mcpServers',
+    rulesPath: join(HOME, '.cursor', 'rules', 'context-vault.mdc'),
+    rulesMethod: 'write',
   },
   {
     id: 'windsurf',
@@ -275,6 +294,8 @@ const TOOLS = [
         : join(HOME, '.codeium', 'windsurf', 'mcp_config.json');
     },
     configKey: 'mcpServers',
+    rulesPath: join(HOME, '.windsurfrules'),
+    rulesMethod: 'append',
   },
   {
     id: 'antigravity',
@@ -283,6 +304,8 @@ const TOOLS = [
     configType: 'json',
     configPath: join(HOME, '.gemini', 'antigravity', 'mcp_config.json'),
     configKey: 'mcpServers',
+    rulesPath: null,
+    rulesMethod: null,
   },
   {
     id: 'cline',
@@ -296,6 +319,8 @@ const TOOLS = [
       'cline_mcp_settings.json'
     ),
     configKey: 'mcpServers',
+    rulesPath: null,
+    rulesMethod: null,
   },
   {
     id: 'roo-code',
@@ -309,6 +334,8 @@ const TOOLS = [
       'cline_mcp_settings.json'
     ),
     configKey: 'mcpServers',
+    rulesPath: null,
+    rulesMethod: null,
   },
 ];
 
@@ -353,12 +380,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 +574,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 +590,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.'));
@@ -572,7 +635,7 @@ async function runSetup() {
   }
 
   // Detect tools
-  console.log(dim(`  [1/6]`) + bold(' Detecting tools...\n'));
+  console.log(dim(`  [1/7]`) + bold(' Detecting tools...\n'));
   verbose(userLevel, 'Scanning for AI tools on this machine.');
   if (userLevel === 'beginner') console.log();
   const { detected, results: detectionResults } = await detectAllTools();
@@ -643,8 +706,21 @@ async function runSetup() {
     }
   }
 
+  // Fast path for new users: recommended defaults
+  let useRecommendedDefaults = false;
+  const existingConfigForFastPath = join(HOME, '.context-mcp', 'config.json');
+  const isNewInstall = !existsSync(existingConfigForFastPath);
+  if (isNewInstall && !isNonInteractive) {
+    console.log(dim('  Install with recommended settings?'));
+    console.log(dim('  Vault in default location, all hooks, skills, and rules installed.'));
+    console.log();
+    const fastAnswer = await prompt('  Install with recommended settings? (Y/n):', 'Y');
+    useRecommendedDefaults = fastAnswer.toLowerCase() !== 'n';
+    if (useRecommendedDefaults) console.log();
+  }
+
   // Vault directory (content files)
-  console.log(dim(`  [2/6]`) + bold(' Configuring vault...\n'));
+  console.log(dim(`  [2/7]`) + bold(' Configuring vault...\n'));
   verbose(userLevel, 'Your vault is a folder of plain markdown files — you own it.');
   if (userLevel === 'beginner') console.log();
 
@@ -664,7 +740,7 @@ async function runSetup() {
     }
   }
 
-  if (!getFlag('--vault-dir') && !isNonInteractive) {
+  if (!getFlag('--vault-dir') && !isNonInteractive && !useRecommendedDefaults) {
     const existingVaults = scanForVaults();
     if (existingVaults.length === 1) {
       console.log(
@@ -696,9 +772,16 @@ async function runSetup() {
       }
       console.log();
     }
+  } else if (!getFlag('--vault-dir') && useRecommendedDefaults) {
+    // Fast path: still use detected vaults if found
+    const existingVaults = scanForVaults();
+    if (existingVaults.length >= 1) {
+      defaultVaultDir = existingVaults[0].path;
+      console.log(`  ${green('+')} Using existing vault at ${defaultVaultDir}`);
+    }
   }
 
-  const vaultDir = isNonInteractive
+  const vaultDir = (isNonInteractive || useRecommendedDefaults)
     ? defaultVaultDir
     : await prompt(`  Vault directory:`, defaultVaultDir);
   let resolvedVaultDir = resolve(vaultDir);
@@ -710,7 +793,7 @@ async function runSetup() {
       console.error(dim(`  Remove or rename the file, then run setup again.\n`));
       process.exit(1);
     }
-  } else if (isNonInteractive) {
+  } else if (isNonInteractive || useRecommendedDefaults) {
     mkdirSync(resolvedVaultDir, { recursive: true });
     console.log(`\n  ${green('+')} Created ${resolvedVaultDir}`);
   } else {
@@ -786,41 +869,18 @@ async function runSetup() {
   vaultConfig.devDir = join(HOME, 'dev');
   vaultConfig.mode = 'local';
 
-  // Telemetry opt-in
-  console.log(`\n  ${dim('[3/6]')}${bold(' Anonymous error reporting\n')}`);
-  verbose(userLevel, 'Entirely optional — works identically either way.\n');
-  console.log(dim('  When enabled, unhandled errors send a minimal event (type, tool name,'));
-  console.log(dim('  version, platform) to help diagnose issues. No vault content,'));
-  console.log(dim('  file paths, or personal data is ever sent. Off by default.'));
-  console.log(dim(`  Full schema: ${MARKETING_URL}/telemetry`));
-  console.log();
-
-  let telemetryEnabled = vaultConfig.telemetry === true;
-  if (!isNonInteractive) {
-    const defaultChoice = telemetryEnabled ? 'Y' : 'n';
-    const telemetryAnswer = await prompt(
-      `  Enable anonymous error reporting? (y/N):`,
-      defaultChoice
-    );
-    telemetryEnabled =
-      telemetryAnswer.toLowerCase() === 'y' || telemetryAnswer.toLowerCase() === 'yes';
-  }
-  vaultConfig.telemetry = telemetryEnabled;
-  console.log(
-    `  ${telemetryEnabled ? green('+') : dim('-')} Telemetry: ${telemetryEnabled ? 'enabled' : 'disabled'}`
-  );
-
+  assertNotTestMode(configPath);
   writeFileSync(configPath, JSON.stringify(vaultConfig, null, 2) + '\n');
   console.log(`\n  ${green('+')} Wrote ${configPath}`);
 
   // Pre-download embedding model with spinner (skip with --skip-embeddings)
   const skipEmbeddings = flags.has('--skip-embeddings');
   if (skipEmbeddings) {
-    console.log(`\n  ${dim('[4/6]')}${bold(' Embedding model')} ${dim('(skipped)')}`);
+    console.log(`\n  ${dim('[3/7]')}${bold(' Embedding model')} ${dim('(skipped)')}`);
     console.log(dim('  FTS-only mode — full-text search works, semantic search disabled.'));
     console.log(dim('  To enable later: context-vault setup (without --skip-embeddings)'));
   } else {
-    console.log(`\n  ${dim('[4/6]')}${bold(' Downloading embedding model...')}`);
+    console.log(`\n  ${dim('[3/7]')}${bold(' Downloading embedding model...')}`);
     verbose(userLevel, 'Enables meaning-based search. ~22MB download, runs fully offline.');
     console.log(dim('  all-MiniLM-L6-v2 (~22MB, one-time download)'));
     console.log(dim(`  Slow connection? Re-run with --skip-embeddings (enables FTS-only mode)\n`));
@@ -902,12 +962,11 @@ async function runSetup() {
     } catch {}
   }
 
-  // Configure each tool — pass vault dir as arg if non-default
-  console.log(`\n  ${dim('[5/6]')}${bold(' Configuring tools...\n')}`);
+  // Configure each tool — always pass vault dir explicitly to prevent config drift
+  console.log(`\n  ${dim('[4/7]')}${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 {
@@ -926,103 +985,107 @@ async function runSetup() {
     }
   }
 
-  // Claude Code hooks (opt-in)
+  // Claude Code extras: hooks, skills, rules (bundled into one step)
+  console.log(`\n  ${dim('[5/7]')}${bold(' Extras...\n')}`);
   const claudeConfigured = results.some((r) => r.ok && r.tool.id === 'claude-code');
   const hookFlag = flags.has('--hooks');
+  const configuredTools = results.filter((r) => r.ok).map((r) => r.tool);
+  const installedRulesPaths = [];
+
   if (claudeConfigured) {
-    // 1. Recall hook (UserPromptSubmit)
-    let installHook = hookFlag;
-    if (!hookFlag && !isNonInteractive) {
+    // Bundled hooks prompt: one Y/n for all three hooks
+    let installHooks = hookFlag || useRecommendedDefaults;
+    if (!hookFlag && !isNonInteractive && !useRecommendedDefaults) {
+      console.log(dim('  Install Claude Code hooks? (recommended)'));
+      console.log(dim('  Memory recall, session capture, and auto-capture.'));
       console.log();
-      console.log(dim('  Claude Code detected — install memory hook?'));
-      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 hooks? (Y/n):', 'Y');
+      installHooks = answer.toLowerCase() !== 'n';
     }
-    if (installHook) {
+    if (installHooks) {
       try {
-        const installed = installClaudeHook();
-        if (installed) {
-          console.log(`\n  ${green('+')} Memory hook installed`);
-        }
+        const hookInstalled = installClaudeHook();
+        if (hookInstalled) console.log(`  ${green('+')} Memory recall hook installed`);
       } catch (e) {
-        console.log(`\n  ${red('x')} Hook install failed: ${e.message}`);
+        console.log(`  ${red('x')} Memory hook failed: ${e.message}`);
       }
-
-      // 2. Session capture hook (SessionEnd) — only offer if recall hook was installed
-      if (!isNonInteractive) {
-        console.log();
-        console.log(dim('  Auto-save session summaries when Claude Code exits?'));
-        console.log(dim('  Captures files touched, tools used, and decisions made per session.'));
-        console.log();
-        const captureAnswer = await prompt('  Install session capture hook? (Y/n):', 'Y');
-        if (captureAnswer.toLowerCase() !== 'n') {
-          try {
-            const captureInstalled = installSessionCaptureHook();
-            if (captureInstalled) {
-              console.log(`  ${green('+')} Session capture hook installed`);
-            }
-          } catch (e) {
-            console.log(`  ${red('x')} Session capture hook failed: ${e.message}`);
-          }
-        }
-      } else if (hookFlag) {
-        try {
-          installSessionCaptureHook();
-        } catch {}
+      try {
+        const captureInstalled = installSessionCaptureHook();
+        if (captureInstalled) console.log(`  ${green('+')} Session capture hook installed`);
+      } catch (e) {
+        console.log(`  ${red('x')} Session capture hook failed: ${e.message}`);
       }
-
-      // 3. Auto-capture hook (PostToolCall) — only offer if recall hook was installed
-      if (!isNonInteractive) {
-        console.log();
-        console.log(dim('  Passively log tool calls for richer session summaries?'));
-        console.log(dim('  Records tool names and file paths after each tool call (lightweight).'));
-        console.log();
-        const autoCaptureAnswer = await prompt('  Install auto-capture hook? (Y/n):', 'Y');
-        if (autoCaptureAnswer.toLowerCase() !== 'n') {
-          try {
-            const acInstalled = installPostToolCallHook();
-            if (acInstalled) {
-              console.log(`  ${green('+')} Auto-capture hook installed`);
-            }
-          } catch (e) {
-            console.log(`  ${red('x')} Auto-capture hook failed: ${e.message}`);
-          }
-        }
-      } else if (hookFlag) {
-        try {
-          installPostToolCallHook();
-        } catch {}
+      try {
+        const acInstalled = installPostToolCallHook();
+        if (acInstalled) console.log(`  ${green('+')} Auto-capture hook installed`);
+      } catch (e) {
+        console.log(`  ${red('x')} Auto-capture hook failed: ${e.message}`);
       }
-    } else if (!isNonInteractive && !hookFlag) {
-      console.log(dim(`  Skipped — install later: context-vault hooks install`));
+    } else {
+      console.log(dim(`  Hooks skipped. Install later: context-vault hooks install`));
     }
-  }
 
-  // Claude Code skills (opt-in)
-  if (claudeConfigured && !isNonInteractive) {
-    console.log();
-    console.log(dim('  Install Claude Code skills? (recommended)'));
-    console.log(dim('  compile-context — compile vault entries into a project brief'));
-    console.log();
-    const skillAnswer = await prompt('  Install Claude Code skills? (Y/n):', 'Y');
-    const installSkillsFlag = skillAnswer.toLowerCase() !== 'n';
+    // Skills (bundled, no separate prompt unless not using fast path)
+    let installSkillsFlag = useRecommendedDefaults || isNonInteractive;
+    if (!isNonInteractive && !useRecommendedDefaults) {
+      console.log();
+      console.log(dim('  Install Claude Code skills? (recommended)'));
+      console.log(dim('  compile-context, vault-setup'));
+      console.log();
+      const skillAnswer = await prompt('  Install Claude Code skills? (Y/n):', 'Y');
+      installSkillsFlag = skillAnswer.toLowerCase() !== 'n';
+    }
     if (installSkillsFlag) {
       try {
         const names = installSkills();
-        if (names.length > 0) {
-          for (const name of names) {
-            console.log(`\n  ${green('+')} ${name} skill installed`);
-          }
+        for (const name of names) {
+          console.log(`  ${green('+')} ${name} skill installed`);
         }
       } catch (e) {
-        console.log(`\n  ${red('x')} Skills install failed: ${e.message}`);
+        console.log(`  ${red('x')} Skills install failed: ${e.message}`);
+      }
+    } else {
+      console.log(dim(`  Skills skipped. Install later: context-vault skills install`));
+    }
+  }
+
+  // Agent rules installation
+  if (configuredTools.length > 0 && !flags.has('--no-rules')) {
+    let installRules = isNonInteractive || useRecommendedDefaults;
+    if (!isNonInteractive && !useRecommendedDefaults) {
+      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();
+      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} rules: ${e.message}`);
+          }
+        }
+      } else {
+        console.log(dim('  Agent rules file not found in package.'));
       }
     } else {
-      console.log(dim(`  Skipped — install later: context-vault skills install`));
+      console.log(dim('  Rules skipped. Install later: context-vault rules install'));
     }
+  } else if (flags.has('--no-rules')) {
+    console.log(dim('  Agent rules skipped (--no-rules)'));
   }
 
   // Seed entry
@@ -1033,8 +1096,36 @@ async function runSetup() {
     );
   }
 
+  // Telemetry opt-in (moved to end, after user has seen value)
+  console.log(`\n  ${dim('[6/7]')}${bold(' Anonymous error reporting\n')}`);
+  verbose(userLevel, 'Entirely optional. Works identically either way.\n');
+  console.log(dim('  When enabled, unhandled errors send a minimal event (type, tool name,'));
+  console.log(dim('  version, platform) to help diagnose issues. No vault content,'));
+  console.log(dim('  file paths, or personal data is ever sent. Off by default.'));
+  console.log(dim(`  Full schema: ${MARKETING_URL}/telemetry`));
+  console.log();
+
+  let telemetryEnabled = vaultConfig.telemetry === true;
+  if (!isNonInteractive && !useRecommendedDefaults) {
+    const defaultChoice = telemetryEnabled ? 'Y' : 'n';
+    const telemetryAnswer = await prompt(
+      `  Enable anonymous error reporting? (y/N):`,
+      defaultChoice
+    );
+    telemetryEnabled =
+      telemetryAnswer.toLowerCase() === 'y' || telemetryAnswer.toLowerCase() === 'yes';
+  }
+  vaultConfig.telemetry = telemetryEnabled;
+  console.log(
+    `  ${telemetryEnabled ? green('+') : dim('-')} Telemetry: ${telemetryEnabled ? 'enabled' : 'disabled'}`
+  );
+
+  // Re-write config with telemetry setting
+  assertNotTestMode(configPath);
+  writeFileSync(configPath, JSON.stringify(vaultConfig, null, 2) + '\n');
+
   // Health check
-  console.log(`\n  ${dim('[6/6]')}${bold(' Health check...')}\n`);
+  console.log(`\n  ${dim('[7/7]')}${bold(' Health check...')}\n`);
   verbose(userLevel, 'Verifying vault, config, and database are accessible.\n');
   const okResults = results.filter((r) => r.ok);
 
@@ -1128,6 +1219,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 +1474,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 +1485,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 +1511,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 +1521,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 +1696,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 +1809,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 +1870,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) {
@@ -1780,7 +1895,11 @@ async function runSwitch() {
 }
 
 async function runReindex() {
-  console.log(dim('Loading vault...'));
+  const dryRun = flags.has('--dry-run');
+  const kindIdx = args.indexOf('--kind');
+  const kindFilter = kindIdx !== -1 && args[kindIdx + 1] ? args[kindIdx + 1] : null;
+
+  console.log(dim(dryRun ? 'Analyzing vault (dry run)...' : 'Loading vault...'));
 
   const { resolveConfig } = await import('@context-vault/core/config');
   const { initDatabase, prepareStatements, insertVec, deleteVec } =
@@ -1806,14 +1925,34 @@ async function runReindex() {
     deleteVec: (r) => deleteVec(stmts, r),
   };
 
-  const stats = await reindex(ctx, { fullSync: true });
+  const reindexOpts = {
+    fullSync: true,
+    indexingConfig: config.indexing,
+    dryRun,
+    kindFilter,
+  };
+
+  const stats = await reindex(ctx, reindexOpts);
 
   db.close();
-  console.log(green('✓ Reindex complete'));
-  console.log(`  ${green('+')} ${stats.added} added`);
-  console.log(`  ${yellow('~')} ${stats.updated} updated`);
-  console.log(`  ${red('-')} ${stats.removed} removed`);
-  console.log(`  ${dim('·')} ${stats.unchanged} unchanged`);
+
+  if (dryRun) {
+    console.log(yellow('Dry run results (no changes made):'));
+    console.log(`  Would index:  ${stats.added}`);
+    console.log(`  Would skip:   ${stats.skippedIndexing ?? 0}`);
+  } else {
+    console.log(green('✓ Reindex complete'));
+    console.log(`  ${green('+')} ${stats.added} added`);
+    console.log(`  ${yellow('~')} ${stats.updated} updated`);
+    console.log(`  ${red('-')} ${stats.removed} removed`);
+    console.log(`  ${dim('·')} ${stats.unchanged} unchanged`);
+    if (stats.skippedIndexing) {
+      console.log(`  ${dim('○')} ${stats.skippedIndexing} skipped indexing`);
+    }
+    if (stats.embeddingsCleared) {
+      console.log(`  ${dim('⊘')} ${stats.embeddingsCleared} embeddings cleared`);
+    }
+  }
 }
 
 async function runMigrateDirs() {
@@ -2131,6 +2270,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 +2292,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 +2303,9 @@ 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 IRREGULAR_PLURALS = { activity: 'activities', inbox: 'inboxes', index: 'indexes', match: 'matches' };
+      const plural = IRREGULAR_PLURALS[kind] || (kind.endsWith('s') ? kind : kind + 's');
+      console.log(`    ${dim(bar)} ${countStr} ${plural}`);
     }
   } else {
     console.log(`\n  ${dim('(empty — no entries indexed)')}`);
@@ -2325,6 +2471,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)) {
@@ -3648,6 +3822,78 @@ async function runSessionEnd() {
       meta: { session_id: session_id ?? null, cwd, message_count },
     });
     console.log(`context-vault session captured — id: ${entry.id}`);
+
+    // ── Auto-insight extraction ──────────────────────────────────────────────
+    const aiConfig = config.autoInsights ?? { enabled: true, patterns: ['★ Insight'], minChars: 50, maxPerSession: 5, tier: 'working' };
+    if (aiConfig.enabled !== false) {
+      try {
+        const patterns = aiConfig.patterns ?? ['★ Insight'];
+        const minChars = aiConfig.minChars ?? 50;
+        const maxInsights = aiConfig.maxPerSession ?? 5;
+        const defaultTier = aiConfig.tier ?? 'working';
+
+        // Build regex for all configured patterns
+        const escapedPatterns = patterns.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+        const patternRe = new RegExp(
+          `(?:${escapedPatterns.join('|')})[─\\s]*\`?\\n([\\s\\S]*?)\\n\`?─{10,}`,
+          'g'
+        );
+
+        const insightBlocks = [];
+        for (const turn of turns) {
+          if (turn.role !== 'assistant') continue;
+          const text = extractText(turn);
+          if (!text) continue;
+          for (const m of text.matchAll(patternRe)) {
+            const insightBody = m[1].trim();
+            if (insightBody.length >= minChars && insightBlocks.length < maxInsights) {
+              insightBlocks.push(insightBody);
+            }
+          }
+        }
+
+        if (insightBlocks.length > 0) {
+          // Check existing auto-insight entries for dedup (by title, lightweight)
+          const existingTitles = new Set();
+          try {
+            const rows = db.prepare(
+              `SELECT title FROM entries WHERE tags LIKE '%auto-insight%' ORDER BY created_at DESC LIMIT 100`
+            ).all();
+            for (const r of rows) {
+              if (r.title) existingTitles.add(r.title.toLowerCase());
+            }
+          } catch {}
+
+          let savedCount = 0;
+          for (const insightBody of insightBlocks) {
+            const boldMatch = insightBody.match(/\*\*(.+?)\*\*/);
+            const firstLine = insightBody.split('\n')[0].replace(/\*\*/g, '').trim();
+            const insightTitle = boldMatch ? boldMatch[1].slice(0, 80) : firstLine.slice(0, 80);
+
+            // Skip near-duplicates by title
+            if (existingTitles.has(insightTitle.toLowerCase())) continue;
+
+            const insightTags = ['auto-insight', 'session-insight', `bucket:${project}`];
+            await captureAndIndex(ctx, {
+              kind: 'insight',
+              title: insightTitle,
+              body: insightBody,
+              tags: insightTags,
+              source: `claude-code session ${new Date().toISOString().slice(0, 10)}`,
+              tier: defaultTier,
+              meta: { auto_extracted: true, session_id: session_id ?? null },
+            });
+            existingTitles.add(insightTitle.toLowerCase());
+            savedCount++;
+          }
+          if (savedCount > 0) {
+            console.log(`context-vault auto-insights — ${savedCount} insight${savedCount === 1 ? '' : 's'} saved`);
+          }
+        }
+      } catch {
+        // Auto-insight extraction is best-effort
+      }
+    }
   } catch {
     // fail silently — never block session end
   } finally {
@@ -3936,6 +4182,73 @@ 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) {
+  return tool.rulesPath || null;
+}
+
+/**
+ * Install agent rules for a specific tool.
+ * Uses tool.rulesPath and tool.rulesMethod from the TOOLS array.
+ * - 'write' method: writes the file directly (Claude Code, Cursor)
+ * - 'append' method: appends with delimiter markers (Windsurf)
+ * Returns true if installed/updated, false if already up to date or skipped.
+ */
+function installAgentRulesForTool(tool, rulesContent) {
+  const rulesPath = tool.rulesPath;
+  if (!rulesPath) return false;
+
+  if (tool.rulesMethod === 'write') {
+    if (existsSync(rulesPath)) {
+      const existing = readFileSync(rulesPath, 'utf-8');
+      if (existing.trim() === rulesContent.trim()) return false;
+    }
+    mkdirSync(dirname(rulesPath), { recursive: true });
+    writeFileSync(rulesPath, rulesContent);
+    return true;
+  }
+
+  if (tool.rulesMethod === 'append') {
+    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)) {
+        const delimiterRegex = new RegExp(
+          `\n?${RULES_DELIMITER_START}[\\s\\S]*?${RULES_DELIMITER_END}\n?`,
+          'g'
+        );
+        const existingSection = existing.match(delimiterRegex)?.[0] || '';
+        if (existingSection.includes(rulesContent.trim())) return false;
+        const cleaned = existing.replace(delimiterRegex, '');
+        writeFileSync(rulesPath, cleaned + delimited);
+        return true;
+      }
+      writeFileSync(rulesPath, existing + delimited);
+    } else {
+      writeFileSync(rulesPath, delimited.trimStart());
+    }
+    return true;
+  }
+
+  return false;
+}
+
 /** Returns the path to Claude Code's global settings.json */
 function claudeSettingsPath() {
   return join(HOME, '.claude', 'settings.json');
@@ -4291,6 +4604,160 @@ ${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 toolsWithRules = detected.filter((t) => getRulesPathForTool(t));
+    if (toolsWithRules.length === 0) {
+      console.log(`\n  ${yellow('!')} No supported tool detected.\n`);
+      process.exit(1);
+    }
+    let anyShown = false;
+    for (const tool of toolsWithRules) {
+      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`));
+        continue;
+      }
+      if (anyShown) console.log(dim('  ' + '─'.repeat(40)));
+      console.log(`\n  ${dim(`${tool.name}: ${rulesPath}`)}\n`);
+      console.log(readFileSync(rulesPath, 'utf-8'));
+      anyShown = true;
+    }
+    if (!anyShown) {
+      console.log(dim(`\n  Run: context-vault rules install\n`));
+      process.exit(1);
+    }
+  } 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 toolsWithRules = detected.filter((t) => getRulesPathForTool(t));
+    if (toolsWithRules.length === 0) {
+      console.log(`\n  ${yellow('!')} No supported tool detected.\n`);
+      process.exit(1);
+    }
+    for (const tool of toolsWithRules) {
+      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`));
+        continue;
+      }
+      const installed = readFileSync(rulesPath, 'utf-8');
+      if (installed.trim() === bundled.trim()) {
+        console.log(`\n  ${green('✓')} ${tool.name}: rules are up to date (${rulesPath})`);
+      } else {
+        console.log(`\n  ${yellow('!')} ${tool.name}: 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 +5572,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 +6278,9 @@ async function main() {
     case 'skills':
       await runSkills();
       break;
+    case 'rules':
+      await runRules();
+      break;
     case 'flush':
       await runFlush();
       break;
@@ -5726,6 +6350,9 @@ async function main() {
     case 'restart':
       await runRestart();
       break;
+    case 'reconnect':
+      await runReconnect();
+      break;
     case 'consolidate':
       await runConsolidate();
       break;