context-vault 3.4.5 → 3.5.1

package/bin/cli.js

@@ -188,6 +188,7 @@ const args = process.argv.slice(2);
 const command = args[0];
 const flags = new Set(args.filter((a) => a.startsWith('--')));
 const isNonInteractive = flags.has('--yes') || !process.stdin.isTTY;
+const isDryRun = flags.has('--dry-run');
 
 function getFlag(name) {
   const idx = args.indexOf(name);
@@ -252,12 +253,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',
@@ -266,6 +271,8 @@ const TOOLS = [
     configType: 'json',
     configPath: join(appDataDir(), 'Claude', 'claude_desktop_config.json'),
     configKey: 'mcpServers',
+    rulesPath: null,
+    rulesMethod: null,
   },
   {
     id: 'cursor',
@@ -274,6 +281,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',
@@ -286,6 +295,8 @@ const TOOLS = [
         : join(HOME, '.codeium', 'windsurf', 'mcp_config.json');
     },
     configKey: 'mcpServers',
+    rulesPath: join(HOME, '.windsurfrules'),
+    rulesMethod: 'append',
   },
   {
     id: 'antigravity',
@@ -294,6 +305,8 @@ const TOOLS = [
     configType: 'json',
     configPath: join(HOME, '.gemini', 'antigravity', 'mcp_config.json'),
     configKey: 'mcpServers',
+    rulesPath: null,
+    rulesMethod: null,
   },
   {
     id: 'cline',
@@ -307,6 +320,8 @@ const TOOLS = [
       'cline_mcp_settings.json'
     ),
     configKey: 'mcpServers',
+    rulesPath: null,
+    rulesMethod: null,
   },
   {
     id: 'roo-code',
@@ -320,6 +335,8 @@ const TOOLS = [
       'cline_mcp_settings.json'
     ),
     configKey: 'mcpServers',
+    rulesPath: null,
+    rulesMethod: null,
   },
 ];
 
@@ -410,6 +427,7 @@ ${bold('Commands:')}
   --yes                 Non-interactive mode (accept all defaults)
   --force               Overwrite existing config without confirmation
   --skip-embeddings     Skip embedding model download (FTS-only mode)
+  --dry-run             Show what setup would do without writing anything
 `);
 }
 
@@ -421,11 +439,15 @@ async function runSetup() {
   console.log();
   console.log(`  ${bold('◇ context-vault')} ${dim(`v${VERSION}`)}`);
   console.log(dim('  Persistent memory for AI agents'));
+  if (isDryRun) {
+    console.log();
+    console.log(yellow('  [dry-run] No files will be written. Showing what setup would do.'));
+  }
   console.log();
 
   // Check for existing installation
   const existingConfig = join(HOME, '.context-mcp', 'config.json');
-  if (existsSync(existingConfig) && !isNonInteractive) {
+  if (existsSync(existingConfig) && !isNonInteractive && !isDryRun) {
     let existingVault = '(unknown)';
     try {
       const cfg = JSON.parse(readFileSync(existingConfig, 'utf-8'));
@@ -619,7 +641,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();
@@ -656,9 +678,9 @@ async function runSetup() {
   ${dim('}')}\n`);
     }
 
-    // In non-interactive mode, continue setup without tools (vault, config, etc.)
-    if (isNonInteractive) {
-      console.log(dim('  Continuing setup without tool configuration (--yes mode).\n'));
+    // In non-interactive/dry-run mode, continue setup without tools (vault, config, etc.)
+    if (isDryRun || isNonInteractive) {
+      console.log(dim(`  Continuing setup without tool configuration (${isDryRun ? '--dry-run' : '--yes'} mode).\n`));
     } else {
       return;
     }
@@ -666,7 +688,7 @@ async function runSetup() {
 
   // Select tools
   let selected;
-  if (isNonInteractive || detected.length === 1) {
+  if (isDryRun || isNonInteractive || detected.length === 1) {
     selected = detected;
     if (detected.length === 1) {
       console.log(`  ${dim('→')} Auto-selected ${detected[0].name}\n`);
@@ -690,8 +712,23 @@ 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 (isDryRun) {
+    useRecommendedDefaults = true;
+  } else 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();
 
@@ -711,7 +748,7 @@ async function runSetup() {
     }
   }
 
-  if (!getFlag('--vault-dir') && !isNonInteractive) {
+  if (!getFlag('--vault-dir') && !isNonInteractive && !useRecommendedDefaults) {
     const existingVaults = scanForVaults();
     if (existingVaults.length === 1) {
       console.log(
@@ -743,9 +780,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 || isDryRun)
     ? defaultVaultDir
     : await prompt(`  Vault directory:`, defaultVaultDir);
   let resolvedVaultDir = resolve(vaultDir);
@@ -757,7 +801,9 @@ async function runSetup() {
       console.error(dim(`  Remove or rename the file, then run setup again.\n`));
       process.exit(1);
     }
-  } else if (isNonInteractive) {
+  } else if (isDryRun) {
+    console.log(`\n  ${yellow('[dry-run]')} Would create directory: ${resolvedVaultDir}`);
+  } else if (isNonInteractive || useRecommendedDefaults) {
     mkdirSync(resolvedVaultDir, { recursive: true });
     console.log(`\n  ${green('+')} Created ${resolvedVaultDir}`);
   } else {
@@ -772,11 +818,19 @@ async function runSetup() {
   }
 
   // Write marker file for vault auto-detection
-  writeMarkerFile(resolvedVaultDir);
+  if (isDryRun) {
+    console.log(`  ${yellow('[dry-run]')} Would write marker file: ${join(resolvedVaultDir, MARKER_FILE)}`);
+  } else {
+    writeMarkerFile(resolvedVaultDir);
+  }
 
   // Ensure data dir exists for DB storage
   const dataDir = join(HOME, '.context-mcp');
-  mkdirSync(dataDir, { recursive: true });
+  if (isDryRun) {
+    console.log(`  ${yellow('[dry-run]')} Would create directory: ${dataDir}`);
+  } else {
+    mkdirSync(dataDir, { recursive: true });
+  }
 
   // Write config.json to data dir (persistent, survives reinstalls)
   const configPath = join(dataDir, 'config.json');
@@ -812,18 +866,21 @@ async function runSetup() {
     );
     console.log(`  Setup would change vaultDir to: ${resolvedVaultDir}`);
 
-    if (isNonInteractive) {
+    if (isDryRun) {
+      console.log(`  ${yellow('[dry-run]')} Would change vaultDir from ${resolve(existingVaultDir)} to ${resolvedVaultDir}`);
+      resolvedVaultDir = resolve(existingVaultDir);
+    } else if (isNonInteractive) {
       console.log();
       console.log(red('  Refusing to overwrite vaultDir in non-interactive mode.'));
       console.log(dim('  Use --force to override, or --vault-dir to set explicitly.'));
       process.exit(1);
-    }
-
-    console.log();
-    const overwrite = await prompt('  Overwrite? (y/N):', 'N');
-    if (overwrite.toLowerCase() !== 'y' && overwrite.toLowerCase() !== 'yes') {
-      console.log(dim(`  Keeping existing vaultDir: ${resolve(existingVaultDir)}`));
-      resolvedVaultDir = resolve(existingVaultDir);
+    } else {
+      console.log();
+      const overwrite = await prompt('  Overwrite? (y/N):', 'N');
+      if (overwrite.toLowerCase() !== 'y' && overwrite.toLowerCase() !== 'yes') {
+        console.log(dim(`  Keeping existing vaultDir: ${resolve(existingVaultDir)}`));
+        resolvedVaultDir = resolve(existingVaultDir);
+      }
     }
   }
 
@@ -833,42 +890,26 @@ 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';
+  if (isDryRun) {
+    console.log(`\n  ${yellow('[dry-run]')} Would write config: ${configPath}`);
+    console.log(dim(`  ${JSON.stringify(vaultConfig, null, 2)}`));
+  } else {
+    assertNotTestMode(configPath);
+    writeFileSync(configPath, JSON.stringify(vaultConfig, null, 2) + '\n');
+    console.log(`\n  ${green('+')} Wrote ${configPath}`);
   }
-  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)')}`);
+  const skipEmbeddings = flags.has('--skip-embeddings') || isDryRun;
+  if (isDryRun) {
+    console.log(`\n  ${dim('[3/7]')}${bold(' Embedding model')} ${yellow('(dry-run, skipped)')}`);
+    console.log(`  ${yellow('[dry-run]')} Would download embedding model (~22MB)`);
+  } else if (skipEmbeddings) {
+    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`));
@@ -944,236 +985,264 @@ async function runSetup() {
   // Clean up legacy project-root config.json if it exists
   const legacyConfigPath = join(ROOT, 'config.json');
   if (existsSync(legacyConfigPath)) {
-    try {
-      unlinkSync(legacyConfigPath);
-      console.log(`  ${dim('Removed legacy config at ' + legacyConfigPath)}`);
-    } catch {}
+    if (isDryRun) {
+      console.log(`  ${yellow('[dry-run]')} Would remove legacy config: ${legacyConfigPath}`);
+    } else {
+      try {
+        unlinkSync(legacyConfigPath);
+        console.log(`  ${dim('Removed legacy config at ' + legacyConfigPath)}`);
+      } catch {}
+    }
   }
 
   // Configure each tool — always pass vault dir explicitly to prevent config drift
-  console.log(`\n  ${dim('[5/6]')}${bold(' Configuring tools...\n')}`);
+  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 customVaultDir = resolvedVaultDir;
 
   for (const tool of selected) {
-    try {
-      if (tool.configType === 'cli' && tool.id === 'codex') {
-        await configureCodex(tool, customVaultDir);
-      } else if (tool.configType === 'cli') {
-        await configureClaude(tool, customVaultDir);
-      } else {
-        configureJsonTool(tool, customVaultDir);
-      }
+    if (isDryRun) {
+      console.log(`  ${yellow('[dry-run]')} Would configure: ${tool.name} (${tool.configPath || tool.id})`);
       results.push({ tool, ok: true });
-      console.log(`  ${green('+')} ${tool.name} — configured`);
-    } catch (e) {
-      results.push({ tool, ok: false, error: e.message });
-      console.log(`  ${red('x')} ${tool.name} — ${e.message}`);
+    } else {
+      try {
+        if (tool.configType === 'cli' && tool.id === 'codex') {
+          await configureCodex(tool, customVaultDir);
+        } else if (tool.configType === 'cli') {
+          await configureClaude(tool, customVaultDir);
+        } else {
+          configureJsonTool(tool, customVaultDir);
+        }
+        results.push({ tool, ok: true });
+        console.log(`  ${green('+')} ${tool.name} — configured`);
+      } catch (e) {
+        results.push({ tool, ok: false, error: e.message });
+        console.log(`  ${red('x')} ${tool.name} — ${e.message}`);
+      }
     }
   }
 
-  // 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');
-  if (claudeConfigured) {
-    // 1. Recall hook (UserPromptSubmit)
-    let installHook = hookFlag;
-    if (!hookFlag && !isNonInteractive) {
-      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):', 'Y');
-      installHook = answer.toLowerCase() !== 'n';
-    }
-    if (installHook) {
-      try {
-        const installed = installClaudeHook();
-        if (installed) {
-          console.log(`\n  ${green('+')} Memory hook installed`);
-        }
-      } catch (e) {
-        console.log(`\n  ${red('x')} Hook install failed: ${e.message}`);
-      }
+  const configuredTools = results.filter((r) => r.ok).map((r) => r.tool);
+  const installedRulesPaths = [];
 
-      // 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.'));
+  if (claudeConfigured) {
+    if (isDryRun) {
+      console.log(`  ${yellow('[dry-run]')} Would install Claude Code hooks (memory recall, session capture, auto-capture)`);
+      console.log(`  ${yellow('[dry-run]')} Would install Claude Code skills (compile-context, vault-setup)`);
+    } else {
+      // 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();
-        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}`);
-          }
+        const answer = await prompt('  Install Claude Code hooks? (Y/n):', 'Y');
+        installHooks = answer.toLowerCase() !== 'n';
+      }
+      if (installHooks) {
+        try {
+          const hookInstalled = installClaudeHook();
+          if (hookInstalled) console.log(`  ${green('+')} Memory recall hook installed`);
+        } catch (e) {
+          console.log(`  ${red('x')} Memory hook failed: ${e.message}`);
         }
-      } else if (hookFlag) {
         try {
-          installSessionCaptureHook();
-        } catch {}
+          const captureInstalled = installSessionCaptureHook();
+          if (captureInstalled) console.log(`  ${green('+')} Session capture hook installed`);
+        } catch (e) {
+          console.log(`  ${red('x')} Session capture hook failed: ${e.message}`);
+        }
+        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 {
+        console.log(dim(`  Hooks skipped. Install later: context-vault hooks install`));
       }
 
-      // 3. Auto-capture hook (PostToolCall) — only offer if recall hook was installed
-      if (!isNonInteractive) {
+      // Skills (bundled, no separate prompt unless not using fast path)
+      let installSkillsFlag = useRecommendedDefaults || isNonInteractive;
+      if (!isNonInteractive && !useRecommendedDefaults) {
         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(dim('  Install Claude Code skills? (recommended)'));
+        console.log(dim('  compile-context, vault-setup'));
         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 {}
+        const skillAnswer = await prompt('  Install Claude Code skills? (Y/n):', 'Y');
+        installSkillsFlag = skillAnswer.toLowerCase() !== 'n';
       }
-    } else if (!isNonInteractive && !hookFlag) {
-      console.log(dim(`  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(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';
-    if (installSkillsFlag) {
-      try {
-        const names = installSkills();
-        if (names.length > 0) {
+      if (installSkillsFlag) {
+        try {
+          const names = installSkills();
           for (const name of names) {
-            console.log(`\n  ${green('+')} ${name} skill installed`);
+            console.log(`  ${green('+')} ${name} skill installed`);
           }
+        } catch (e) {
+          console.log(`  ${red('x')} Skills install failed: ${e.message}`);
         }
-      } catch (e) {
-        console.log(`\n  ${red('x')} Skills install failed: ${e.message}`);
+      } else {
+        console.log(dim(`  Skills skipped. Install later: context-vault skills install`));
       }
-    } else {
-      console.log(dim(`  Skipped — install later: context-vault skills install`));
     }
   }
 
-  // Agent rules installation (opt-in per tool, skip if --no-rules)
-  const configuredTools = results.filter((r) => r.ok).map((r) => r.tool);
-  const installedRulesPaths = [];
+  // Agent rules installation
   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 });
+    if (isDryRun) {
+      for (const tool of configuredTools) {
+        const rulesPath = getRulesPathForTool(tool);
+        console.log(`  ${yellow('[dry-run]')} Would install agent rules for ${tool.name}${rulesPath ? ': ' + rulesPath : ''}`);
+      }
+    } else {
+      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}`);
             }
-          } catch (e) {
-            console.log(`  ${red('x')} ${tool.name} — ${e.message}`);
           }
+        } else {
+          console.log(dim('  Agent rules file not found in package.'));
         }
       } else {
-        console.log(dim('  Agent rules file not found in package — skipping.'));
+        console.log(dim('  Rules skipped. Install later: context-vault rules install'));
       }
-    } 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) {
+  if (isDryRun) {
+    console.log(`\n  ${yellow('[dry-run]')} Would create seed entries in ${resolvedVaultDir}`);
+  } else {
+    const seeded = createSeedEntries(resolvedVaultDir);
+    if (seeded > 0) {
+      console.log(
+        `\n  ${green('+')} Created ${seeded} starter ${seeded === 1 ? 'entry' : 'entries'} in vault`
+      );
+    }
+  }
+
+  // Telemetry opt-in (moved to end, after user has seen value)
+  console.log(`\n  ${dim('[6/7]')}${bold(' Anonymous error reporting\n')}`);
+  if (isDryRun) {
+    console.log(`  ${yellow('[dry-run]')} Would prompt for telemetry preference`);
+    console.log(`  ${yellow('[dry-run]')} Would update config: ${configPath}`);
+  } else {
+    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(
-      `\n  ${green('+')} Created ${seeded} starter ${seeded === 1 ? 'entry' : 'entries'} in vault`
+      `  ${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`);
-  verbose(userLevel, 'Verifying vault, config, and database are accessible.\n');
+  console.log(`\n  ${dim('[7/7]')}${bold(' Health check...')}\n`);
   const okResults = results.filter((r) => r.ok);
+  let passed = 0;
+  let checksTotal = 0;
 
-  // Verify DB is accessible
-  let dbAccessible = false;
-  let dbError = null;
-  try {
-    const { initDatabase } = await import('@context-vault/core/db');
-    const db = await initDatabase(vaultConfig.dbPath);
-    db.prepare('SELECT 1').get();
-    db.close();
-    dbAccessible = true;
-  } catch (e) {
-    dbError = e;
-  }
+  if (isDryRun) {
+    console.log(`  ${yellow('[dry-run]')} Skipping health check (no files were written)`);
+    console.log(`  ${yellow('[dry-run]')} Skipping smoke test`);
+  } else {
+    verbose(userLevel, 'Verifying vault, config, and database are accessible.\n');
 
-  const checks = [
-    { label: 'Vault directory exists', pass: existsSync(resolvedVaultDir) },
-    { label: 'Config file written', pass: existsSync(configPath) },
-    { label: 'Database accessible', pass: dbAccessible, error: dbError },
-    { label: 'At least one tool configured', pass: okResults.length > 0 },
-  ];
-  const passed = checks.filter((c) => c.pass).length;
-  for (const c of checks) {
-    console.log(`  ${c.pass ? green('✓') : red('✗')} ${c.label}`);
-    if (!c.pass && c.error) {
-      console.log(`    ${dim(c.error.message)}`);
-      if (c.error.message.includes('EACCES') || c.error.message.includes('permission')) {
-        console.log(`    ${dim('Fix: check file permissions on ' + vaultConfig.dbPath)}`);
+    // Verify DB is accessible
+    let dbAccessible = false;
+    let dbError = null;
+    try {
+      const { initDatabase } = await import('@context-vault/core/db');
+      const db = await initDatabase(vaultConfig.dbPath);
+      db.prepare('SELECT 1').get();
+      db.close();
+      dbAccessible = true;
+    } catch (e) {
+      dbError = e;
+    }
+
+    const checks = [
+      { label: 'Vault directory exists', pass: existsSync(resolvedVaultDir) },
+      { label: 'Config file written', pass: existsSync(configPath) },
+      { label: 'Database accessible', pass: dbAccessible, error: dbError },
+      { label: 'At least one tool configured', pass: okResults.length > 0 },
+    ];
+    passed = checks.filter((c) => c.pass).length;
+    checksTotal = checks.length;
+    for (const c of checks) {
+      console.log(`  ${c.pass ? green('✓') : red('✗')} ${c.label}`);
+      if (!c.pass && c.error) {
+        console.log(`    ${dim(c.error.message)}`);
+        if (c.error.message.includes('EACCES') || c.error.message.includes('permission')) {
+          console.log(`    ${dim('Fix: check file permissions on ' + vaultConfig.dbPath)}`);
+        }
       }
     }
-  }
 
-  // Smoke test — write and read a test file to verify vault I/O
-  {
-    const testFile = join(resolvedVaultDir, '.smoke-test-' + Date.now() + '.md');
-    try {
-      writeFileSync(testFile, '# Smoke test\n');
-      const content = readFileSync(testFile, 'utf-8');
-      unlinkSync(testFile);
-      if (content.includes('Smoke test')) {
-        console.log(`  ${green('✓')} Smoke test: vault read/write verified`);
-      } else {
-        console.log(`  ${red('✗')} Smoke test: file written but content mismatch`);
+    // Smoke test — write and read a test file to verify vault I/O
+    {
+      const testFile = join(resolvedVaultDir, '.smoke-test-' + Date.now() + '.md');
+      try {
+        writeFileSync(testFile, '# Smoke test\n');
+        const content = readFileSync(testFile, 'utf-8');
+        unlinkSync(testFile);
+        if (content.includes('Smoke test')) {
+          console.log(`  ${green('✓')} Smoke test: vault read/write verified`);
+        } else {
+          console.log(`  ${red('✗')} Smoke test: file written but content mismatch`);
+        }
+      } catch (e) {
+        try { unlinkSync(testFile); } catch {}
+        console.log(`  ${red('✗')} Smoke test failed: ${e.message}`);
+        console.log(`    ${dim('Check permissions on ' + resolvedVaultDir)}`);
       }
-    } catch (e) {
-      try { unlinkSync(testFile); } catch {}
-      console.log(`  ${red('✗')} Smoke test failed: ${e.message}`);
-      console.log(`    ${dim('Check permissions on ' + resolvedVaultDir)}`);
     }
   }
 
@@ -1183,9 +1252,26 @@ async function runSetup() {
   const cli = isNpx() ? 'npx context-vault' : 'context-vault';
 
   let boxLines;
+  if (isDryRun) {
+    boxLines = [
+      `  ${yellow('Dry run complete')} (${elapsed}s)`,
+      ``,
+      `  No files were written. Run without --dry-run to apply.`,
+    ];
+    const innerWidth = Math.max(...boxLines.map((l) => l.length)) + 2;
+    const pad = (s) => s + ' '.repeat(Math.max(0, innerWidth - s.length));
+    console.log();
+    console.log(`  ${dim('┌' + '─'.repeat(innerWidth) + '┐')}`);
+    for (const line of boxLines) {
+      console.log(`  ${dim('│')}${pad(line)}${dim('│')}`);
+    }
+    console.log(`  ${dim('└' + '─'.repeat(innerWidth) + '┘')}`);
+    console.log();
+    return;
+  }
   if (userLevel === 'beginner') {
     boxLines = [
-      `  ✓ Setup complete — ${passed}/${checks.length} checks passed (${elapsed}s)`,
+      `  ✓ Setup complete — ${passed}/${checksTotal} checks passed (${elapsed}s)`,
       ``,
       `  ${bold('What to do next:')}`,
       ``,
@@ -1203,7 +1289,7 @@ async function runSetup() {
     ];
   } else {
     boxLines = [
-      `  ✓ Setup complete — ${passed}/${checks.length} checks passed (${elapsed}s)`,
+      `  ✓ Setup complete — ${passed}/${checksTotal} checks passed (${elapsed}s)`,
       ``,
       `  ${bold('Next:')} restart ${toolName} to activate the vault`,
       ``,
@@ -1894,7 +1980,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 } =
@@ -1920,14 +2010,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() {
@@ -2278,7 +2388,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);
-      const plural = kind.endsWith('s') ? kind : 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 {
@@ -3796,6 +3907,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 {
@@ -4102,48 +4285,45 @@ function loadAgentRules() {
  * 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;
+  return tool.rulesPath || 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.
+ * 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) {
-  if (tool.id === 'claude-code') {
-    const rulesDir = join(HOME, '.claude', 'rules');
-    const rulesPath = join(rulesDir, 'context-vault.md');
+  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(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 });
+    mkdirSync(dirname(rulesPath), { recursive: true });
     writeFileSync(rulesPath, rulesContent);
     return true;
   }
 
-  if (tool.id === 'windsurf') {
-    const rulesPath = join(HOME, '.windsurfrules');
+  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)) return false;
+      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());
@@ -4151,7 +4331,6 @@ function installAgentRulesForTool(tool, rulesContent) {
     return true;
   }
 
-  // Other tools: no rules installation path yet
   return false;
 }
 
@@ -4567,19 +4746,28 @@ async function runRules() {
     console.log();
   } else if (sub === 'show') {
     const { detected } = await detectAllTools();
-    const tool = detected.find((t) => getRulesPathForTool(t));
-    if (!tool) {
+    const toolsWithRules = detected.filter((t) => getRulesPathForTool(t));
+    if (toolsWithRules.length === 0) {
       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`));
+    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);
     }
-    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));
@@ -4601,42 +4789,44 @@ async function runRules() {
       process.exit(1);
     }
     const { detected } = await detectAllTools();
-    const tool = detected.find((t) => getRulesPathForTool(t));
-    if (!tool) {
+    const toolsWithRules = detected.filter((t) => getRulesPathForTool(t));
+    if (toolsWithRules.length === 0) {
       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}`);
+    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();
-      console.log(dim('  To upgrade: context-vault rules install'));
-      console.log();
     }
+    console.log();
   } else {
     console.log(`
   ${bold('context-vault rules')} <command>