context-vault 2.15.0 → 2.17.0

package/bin/cli.js

@@ -64,6 +64,7 @@ function writeMarkerFile(vaultDir) {
 
 function scanForVaults() {
   const candidates = [
+    join(HOME, ".vault"),
     join(HOME, "vault"),
     join(HOME, "omni", "vault"),
     process.cwd(),
@@ -304,6 +305,8 @@ ${bold("Commands:")}
   ${cyan("flush")}                 Check vault health and confirm DB is accessible
   ${cyan("recall")}                Search vault from a Claude Code hook (reads stdin)
   ${cyan("session-capture")}       Save a session summary entry (reads JSON from stdin)
+  ${cyan("session-end")}           Run session-end hook (parse transcript + capture)
+  ${cyan("post-tool-call")}        Run post-tool-call hook (log tool usage)
   ${cyan("save")}                  Save an entry to the vault from CLI
   ${cyan("search")}                Search vault entries from CLI
   ${cyan("reindex")}               Rebuild search index from knowledge files
@@ -324,6 +327,7 @@ ${bold("Options:")}
   --version             Show version
   --vault-dir <path>    Set vault directory (setup/serve)
   --yes                 Non-interactive mode (accept all defaults)
+  --force               Overwrite existing config without confirmation
   --skip-embeddings     Skip embedding model download (FTS-only mode)
 `);
 }
@@ -538,7 +542,21 @@ async function runSetup() {
   console.log(dim(`  [2/6]`) + bold(" Configuring vault...\n"));
 
   // Scan for existing vaults via marker file
-  let defaultVaultDir = getFlag("--vault-dir") || join(HOME, "vault");
+  let defaultVaultDir = getFlag("--vault-dir") || join(HOME, ".vault");
+
+  // Prefer existing config vaultDir over default (prevents accidental overwrite)
+  if (!getFlag("--vault-dir")) {
+    const existingCfgPath = join(HOME, ".context-mcp", "config.json");
+    if (existsSync(existingCfgPath)) {
+      try {
+        const cfg = JSON.parse(readFileSync(existingCfgPath, "utf-8"));
+        if (cfg.vaultDir && existsSync(resolve(cfg.vaultDir))) {
+          defaultVaultDir = cfg.vaultDir;
+        }
+      } catch {}
+    }
+  }
+
   if (!getFlag("--vault-dir") && !isNonInteractive) {
     const existingVaults = scanForVaults();
     if (existingVaults.length === 1) {
@@ -576,7 +594,7 @@ async function runSetup() {
   const vaultDir = isNonInteractive
     ? defaultVaultDir
     : await prompt(`  Vault directory:`, defaultVaultDir);
-  const resolvedVaultDir = resolve(vaultDir);
+  let resolvedVaultDir = resolve(vaultDir);
 
   // Guard: vault dir path must not be an existing file
   if (existsSync(resolvedVaultDir)) {
@@ -626,6 +644,57 @@ async function runSetup() {
       Object.assign(vaultConfig, JSON.parse(readFileSync(configPath, "utf-8")));
     } catch {}
   }
+
+  const existingVaultDir = vaultConfig.vaultDir;
+  if (
+    existingVaultDir &&
+    resolve(existingVaultDir) !== resolvedVaultDir &&
+    !flags.has("--force")
+  ) {
+    let entryCount = 0;
+    try {
+      const knowledgeDir = join(resolve(existingVaultDir), "knowledge");
+      if (existsSync(knowledgeDir)) {
+        const countMd = (d) => {
+          let n = 0;
+          for (const e of readdirSync(d, { withFileTypes: true })) {
+            if (e.isDirectory()) n += countMd(join(d, e.name));
+            else if (e.name.endsWith(".md")) n++;
+          }
+          return n;
+        };
+        entryCount = countMd(knowledgeDir);
+      }
+    } catch {}
+
+    console.log();
+    console.log(
+      yellow(`  ⚠ Existing config points to: ${resolve(existingVaultDir)}`) +
+        (entryCount > 0 ? dim(` (${entryCount} entries)`) : ""),
+    );
+    console.log(`  Setup would change vaultDir to: ${resolvedVaultDir}`);
+
+    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);
+    }
+  }
+
   vaultConfig.vaultDir = resolvedVaultDir;
   vaultConfig.dataDir = dataDir;
   vaultConfig.dbPath = join(dataDir, "vault.db");
@@ -1716,7 +1785,18 @@ async function runStatus() {
     } catch {}
   }
 
-  const db = await initDatabase(config.dbPath);
+  let db;
+  try {
+    db = await initDatabase(config.dbPath);
+  } catch (e) {
+    console.log();
+    console.log(`  ${bold("◇ context-vault")} ${dim(`v${VERSION}`)}`);
+    console.log();
+    console.log(`  ${red("✘")} Database not accessible: ${e.message}`);
+    console.log(dim(`  Run ${cyan("context-vault doctor")} for diagnostics`));
+    console.log();
+    process.exit(1);
+  }
 
   const status = gatherVaultStatus({ db, config });
 
@@ -1889,6 +1969,25 @@ async function runUninstall() {
     }
   }
 
+  // Remove Claude Code hooks
+  const recallRemoved = removeClaudeHook();
+  const captureRemoved = removeSessionCaptureHook();
+  const flushRemoved = removeSessionEndHook();
+  const autoCaptureRemoved = removePostToolCallHook();
+  if (recallRemoved || captureRemoved || flushRemoved || autoCaptureRemoved) {
+    console.log(`  ${green("+")} Removed Claude Code hooks`);
+  } else {
+    console.log(`  ${dim("-")} No Claude Code hooks to remove`);
+  }
+
+  // Remove installed skills
+  const skillsDir = join(HOME, ".claude", "skills", "compile-context");
+  if (existsSync(skillsDir)) {
+    const { rmSync } = await import("node:fs");
+    rmSync(skillsDir, { recursive: true, force: true });
+    console.log(`  ${green("+")} Removed installed skills`);
+  }
+
   // Optionally remove data directory
   const dataDir = join(HOME, ".context-mcp");
   if (existsSync(dataDir)) {
@@ -2678,6 +2777,16 @@ async function runSessionCapture() {
   }
 }
 
+async function runSessionEnd() {
+  const { main } = await import("../src/hooks/session-end.mjs");
+  await main();
+}
+
+async function runPostToolCall() {
+  const { main } = await import("../src/hooks/post-tool-call.mjs");
+  await main();
+}
+
 async function runSave() {
   const kind = getFlag("--kind");
   const title = getFlag("--title");
@@ -3093,14 +3202,6 @@ function removeClaudeHook() {
   return true;
 }
 
-function sessionEndHookPath() {
-  return resolve(ROOT, "src", "hooks", "session-end.mjs");
-}
-
-function postToolCallHookPath() {
-  return resolve(ROOT, "src", "hooks", "post-tool-call.mjs");
-}
-
 /**
  * Writes a SessionEnd hook entry for session capture to ~/.claude/settings.json.
  * Returns true if installed, false if already present.
@@ -3123,17 +3224,29 @@ function installSessionCaptureHook() {
   if (!settings.hooks) settings.hooks = {};
   if (!settings.hooks.SessionEnd) settings.hooks.SessionEnd = [];
 
+  const newCommand = "context-vault session-end";
+
+  // Check if already installed with new CLI-based command
   const alreadyInstalled = settings.hooks.SessionEnd.some((h) =>
-    h.hooks?.some((hh) => hh.command?.includes("session-end.mjs")),
+    h.hooks?.some((hh) => hh.command?.includes(newCommand)),
   );
   if (alreadyInstalled) return false;
 
-  const hookScript = sessionEndHookPath();
+  // Migrate: remove stale absolute-path hooks (node <path>/session-end.mjs)
+  const hadStale = settings.hooks.SessionEnd.some((h) =>
+    h.hooks?.some((hh) => hh.command?.includes("session-end.mjs")),
+  );
+  if (hadStale) {
+    settings.hooks.SessionEnd = settings.hooks.SessionEnd.filter(
+      (h) => !h.hooks?.some((hh) => hh.command?.includes("session-end.mjs")),
+    );
+  }
+
   settings.hooks.SessionEnd.push({
     hooks: [
       {
         type: "command",
-        command: `node ${hookScript}`,
+        command: newCommand,
         timeout: 30,
       },
     ],
@@ -3163,7 +3276,12 @@ function removeSessionCaptureHook() {
 
   const before = settings.hooks.SessionEnd.length;
   settings.hooks.SessionEnd = settings.hooks.SessionEnd.filter(
-    (h) => !h.hooks?.some((hh) => hh.command?.includes("session-end.mjs")),
+    (h) =>
+      !h.hooks?.some(
+        (hh) =>
+          hh.command?.includes("session-end.mjs") ||
+          hh.command?.includes("context-vault session-end"),
+      ),
   );
 
   if (settings.hooks.SessionEnd.length === before) return false;
@@ -3194,17 +3312,29 @@ function installPostToolCallHook() {
   if (!settings.hooks) settings.hooks = {};
   if (!settings.hooks.PostToolCall) settings.hooks.PostToolCall = [];
 
+  const newCommand = "context-vault post-tool-call";
+
+  // Check if already installed with new CLI-based command
   const alreadyInstalled = settings.hooks.PostToolCall.some((h) =>
-    h.hooks?.some((hh) => hh.command?.includes("post-tool-call.mjs")),
+    h.hooks?.some((hh) => hh.command?.includes(newCommand)),
   );
   if (alreadyInstalled) return false;
 
-  const hookScript = postToolCallHookPath();
+  // Migrate: remove stale absolute-path hooks (node <path>/post-tool-call.mjs)
+  const hadStale = settings.hooks.PostToolCall.some((h) =>
+    h.hooks?.some((hh) => hh.command?.includes("post-tool-call.mjs")),
+  );
+  if (hadStale) {
+    settings.hooks.PostToolCall = settings.hooks.PostToolCall.filter(
+      (h) => !h.hooks?.some((hh) => hh.command?.includes("post-tool-call.mjs")),
+    );
+  }
+
   settings.hooks.PostToolCall.push({
     hooks: [
       {
         type: "command",
-        command: `node ${hookScript}`,
+        command: newCommand,
         timeout: 5,
       },
     ],
@@ -3234,7 +3364,12 @@ function removePostToolCallHook() {
 
   const before = settings.hooks.PostToolCall.length;
   settings.hooks.PostToolCall = settings.hooks.PostToolCall.filter(
-    (h) => !h.hooks?.some((hh) => hh.command?.includes("post-tool-call.mjs")),
+    (h) =>
+      !h.hooks?.some(
+        (hh) =>
+          hh.command?.includes("post-tool-call.mjs") ||
+          hh.command?.includes("context-vault post-tool-call"),
+      ),
   );
 
   if (settings.hooks.PostToolCall.length === before) return false;
@@ -3600,16 +3735,20 @@ async function runDoctor() {
     }
 
     // ── Database ──────────────────────────────────────────────────────────
+    let db;
     if (existsSync(config.dbPath)) {
       try {
         const { initDatabase } = await import("@context-vault/core/index/db");
-        const db = await initDatabase(config.dbPath);
-        db.close();
-        console.log(`  ${green("✓")} Database ${dim(config.dbPath)}`);
+        db = await initDatabase(config.dbPath);
+        const schemaRow = db.prepare("PRAGMA user_version").get();
+        const schemaVersion = schemaRow?.user_version ?? "unknown";
+        console.log(
+          `  ${green("✓")} Database ${dim(`${config.dbPath} (schema v${schemaVersion})`)}`,
+        );
       } catch (e) {
         console.log(`  ${red("✘")} Database error: ${e.message}`);
         console.log(
-          `    ${dim(`Fix: rm "${config.dbPath}" (data will be lost)`)}`,
+          `    ${dim(`Fix: rm "${config.dbPath}" and restart (will rebuild from vault files)`)}`,
         );
         allOk = false;
       }
@@ -3619,6 +3758,101 @@ async function runDoctor() {
       );
     }
 
+    // ── Embedding model ──────────────────────────────────────────────────
+    try {
+      const { embed } = await import("@context-vault/core/index/embed");
+      const vec = await embed("doctor check");
+      if (vec && vec.length > 0) {
+        console.log(
+          `  ${green("✓")} Embedding model ${dim(`(${vec.length} dimensions)`)}`,
+        );
+      } else {
+        console.log(
+          `  ${yellow("!")} Embedding model unavailable — semantic search disabled (FTS-only)`,
+        );
+        console.log(
+          `    ${dim("Fix: run context-vault setup to download the model")}`,
+        );
+      }
+    } catch {
+      console.log(
+        `  ${yellow("!")} Embedding model unavailable — semantic search disabled (FTS-only)`,
+      );
+      console.log(
+        `    ${dim("Fix: run context-vault setup to download the model")}`,
+      );
+    }
+
+    // ── DB/filesystem consistency ─────────────────────────────────────────
+    if (db && existsSync(config.vaultDir)) {
+      try {
+        const totalRow = db.prepare("SELECT COUNT(*) as c FROM vault").get();
+        const total = totalRow?.c ?? 0;
+        if (total > 0) {
+          const sampleRows = db
+            .prepare("SELECT file_path FROM vault LIMIT 50")
+            .all();
+          let staleCount = 0;
+          for (const row of sampleRows) {
+            if (row.file_path && !existsSync(row.file_path)) {
+              staleCount++;
+            }
+          }
+          if (staleCount > 0) {
+            const pct = Math.round((staleCount / sampleRows.length) * 100);
+            console.log(
+              `  ${yellow("!")} ${staleCount}/${sampleRows.length} sampled DB entries point to missing files (${pct}%)`,
+            );
+            console.log(
+              `    ${dim("Fix: run context-vault reindex to rebuild from vault files")}`,
+            );
+            allOk = false;
+          } else {
+            console.log(
+              `  ${green("✓")} DB/filesystem consistency ${dim(`(${total} entries, sample OK)`)}`,
+            );
+          }
+        }
+      } catch {
+        // non-critical — skip silently
+      }
+    }
+
+    // ── Auto-captured feedback entries ─────────────────────────────────────
+    if (db) {
+      try {
+        const feedbackRow = db
+          .prepare(
+            `SELECT COUNT(*) as c FROM vault WHERE kind = 'feedback' AND tags LIKE '%"auto-captured"%'`,
+          )
+          .get();
+        const feedbackCount = feedbackRow?.c ?? 0;
+        if (feedbackCount > 0) {
+          const recentRows = db
+            .prepare(
+              `SELECT title, created_at FROM vault WHERE kind = 'feedback' AND tags LIKE '%"auto-captured"%' ORDER BY created_at DESC LIMIT 3`,
+            )
+            .all();
+          console.log(
+            `  ${yellow("!")} ${feedbackCount} auto-captured error${feedbackCount === 1 ? "" : "s"} in vault`,
+          );
+          for (const row of recentRows) {
+            console.log(`    ${dim(`${row.created_at} — ${row.title}`)}`);
+          }
+          console.log(
+            `    ${dim('Review: context-vault search --kind feedback --tag auto-captured')}`,
+          );
+        }
+      } catch {
+        // non-critical — skip silently
+      }
+    }
+
+    // Close DB if opened
+    try {
+      db?.close();
+    } catch {}
+
     // ── Launcher (server.mjs) ─────────────────────────────────────────────
     const launcherPath = join(HOME, ".context-mcp", "server.mjs");
     if (existsSync(launcherPath)) {
@@ -3676,6 +3910,9 @@ async function runDoctor() {
   // ── MCP tool configs ──────────────────────────────────────────────────────
   console.log();
   console.log(bold("  Tool Configurations"));
+  let anyToolConfigured = false;
+
+  // Check Claude Code
   const claudeConfigPath = join(HOME, ".claude.json");
   if (existsSync(claudeConfigPath)) {
     try {
@@ -3685,9 +3922,9 @@ async function runDoctor() {
         const srv = servers["context-vault"];
         const cmd = [srv.command, ...(srv.args || [])].join(" ");
         console.log(`  ${green("+")} Claude Code: ${dim(cmd)}`);
+        anyToolConfigured = true;
       } else {
-        console.log(`  ${dim("-")} Claude Code: context-vault not configured`);
-        console.log(`    ${dim("Fix: run context-vault setup")}`);
+        console.log(`  ${dim("-")} Claude Code: not configured`);
       }
     } catch {
       console.log(
@@ -3698,21 +3935,199 @@ async function runDoctor() {
     console.log(`  ${dim("-")} Claude Code: ~/.claude.json not found`);
   }
 
+  // Check all JSON-configured tools
+  for (const tool of TOOLS.filter((t) => t.configType === "json")) {
+    const cfgPath = tool.configPath;
+    if (!cfgPath || !existsSync(cfgPath)) {
+      continue; // tool not installed — skip silently
+    }
+    try {
+      const toolConfig = JSON.parse(readFileSync(cfgPath, "utf-8"));
+      const servers = toolConfig?.[tool.configKey] || {};
+      if (servers["context-vault"]) {
+        const srv = servers["context-vault"];
+        const cmd = [srv.command, ...(srv.args || [])].join(" ");
+        console.log(`  ${green("+")} ${tool.name}: ${dim(cmd)}`);
+        anyToolConfigured = true;
+      } else if (servers["context-mcp"]) {
+        console.log(
+          `  ${yellow("!")} ${tool.name}: using old name "context-mcp"`,
+        );
+        console.log(
+          `    ${dim("Fix: run context-vault setup to update")}`,
+        );
+        anyToolConfigured = true;
+      }
+    } catch {
+      // config exists but unreadable — skip
+    }
+  }
+
+  // Check Codex
+  try {
+    const codexCheck = execSync("codex mcp list 2>/dev/null", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5000,
+    });
+    if (codexCheck.includes("context-vault")) {
+      console.log(`  ${green("+")} Codex: ${dim("configured")}`);
+      anyToolConfigured = true;
+    }
+  } catch {
+    // codex not installed or not configured — skip
+  }
+
+  if (!anyToolConfigured) {
+    console.log(
+      `  ${yellow("!")} No AI tools have context-vault configured`,
+    );
+    console.log(`    ${dim("Fix: run context-vault setup")}`);
+    allOk = false;
+  }
+
+  // ── Claude Code hooks ──────────────────────────────────────────────────────
+  console.log();
+  console.log(bold("  Claude Code Hooks"));
+  const settingsPath = claudeSettingsPath();
+  if (existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      const hooks = settings.hooks || {};
+      let hookCount = 0;
+      let staleHookCount = 0;
+
+      // Check recall hook
+      const recallHooks = (hooks.UserPromptSubmit || []).filter((h) =>
+        h.hooks?.some((hh) => hh.command?.includes("context-vault recall")),
+      );
+      if (recallHooks.length > 0) {
+        console.log(`  ${green("+")} Recall hook (UserPromptSubmit)`);
+        hookCount++;
+      }
+
+      // Check session-end hooks
+      const sessionHooks = (hooks.SessionEnd || []).filter((h) =>
+        h.hooks?.some(
+          (hh) =>
+            hh.command?.includes("session-end.mjs") ||
+            hh.command?.includes("context-vault session-end"),
+        ),
+      );
+      if (sessionHooks.length > 0) {
+        // Check if using stale absolute path
+        const hasStale = sessionHooks.some((h) =>
+          h.hooks?.some(
+            (hh) =>
+              hh.command?.includes("session-end.mjs") &&
+              !hh.command?.includes("context-vault session-end"),
+          ),
+        );
+        if (hasStale) {
+          const cmd = sessionHooks[0]?.hooks?.[0]?.command || "";
+          const pathMatch = cmd.match(/node\s+(.+session-end\.mjs)/);
+          const hookPath = pathMatch ? pathMatch[1] : "";
+          const pathExists = hookPath && existsSync(hookPath);
+          if (!pathExists) {
+            console.log(
+              `  ${red("✘")} Session capture hook: stale path ${dim(hookPath || "(unknown)")}`,
+            );
+            console.log(
+              `    ${dim("Fix: run context-vault hooks install to update")}`,
+            );
+            staleHookCount++;
+            allOk = false;
+          } else {
+            console.log(
+              `  ${yellow("!")} Session capture hook: uses absolute path (fragile)`,
+            );
+            console.log(
+              `    ${dim("Fix: run context-vault hooks install to update to CLI command")}`,
+            );
+          }
+        } else {
+          console.log(`  ${green("+")} Session capture hook (SessionEnd)`);
+        }
+        hookCount++;
+      }
+
+      // Check flush hook
+      const flushHooks = (hooks.SessionEnd || []).filter((h) =>
+        h.hooks?.some((hh) => hh.command?.includes("context-vault flush")),
+      );
+      if (flushHooks.length > 0) {
+        console.log(`  ${green("+")} Flush hook (SessionEnd)`);
+        hookCount++;
+      }
+
+      // Check post-tool-call hooks
+      const ptcHooks = (hooks.PostToolCall || []).filter((h) =>
+        h.hooks?.some(
+          (hh) =>
+            hh.command?.includes("post-tool-call.mjs") ||
+            hh.command?.includes("context-vault post-tool-call"),
+        ),
+      );
+      if (ptcHooks.length > 0) {
+        const hasStale = ptcHooks.some((h) =>
+          h.hooks?.some(
+            (hh) =>
+              hh.command?.includes("post-tool-call.mjs") &&
+              !hh.command?.includes("context-vault post-tool-call"),
+          ),
+        );
+        if (hasStale) {
+          const cmd = ptcHooks[0]?.hooks?.[0]?.command || "";
+          const pathMatch = cmd.match(/node\s+(.+post-tool-call\.mjs)/);
+          const hookPath = pathMatch ? pathMatch[1] : "";
+          const pathExists = hookPath && existsSync(hookPath);
+          if (!pathExists) {
+            console.log(
+              `  ${red("✘")} Auto-capture hook: stale path ${dim(hookPath || "(unknown)")}`,
+            );
+            console.log(
+              `    ${dim("Fix: run context-vault hooks install to update")}`,
+            );
+            staleHookCount++;
+            allOk = false;
+          } else {
+            console.log(
+              `  ${yellow("!")} Auto-capture hook: uses absolute path (fragile)`,
+            );
+            console.log(
+              `    ${dim("Fix: run context-vault hooks install to update to CLI command")}`,
+            );
+          }
+        } else {
+          console.log(`  ${green("+")} Auto-capture hook (PostToolCall)`);
+        }
+        hookCount++;
+      }
+
+      if (hookCount === 0) {
+        console.log(`  ${dim("-")} No context-vault hooks installed`);
+        console.log(
+          `    ${dim("Optional: run context-vault hooks install")}`,
+        );
+      }
+    } catch {
+      console.log(
+        `  ${yellow("!")} Could not read ${settingsPath}`,
+      );
+    }
+  } else {
+    console.log(`  ${dim("-")} No Claude Code settings found`);
+  }
+
   // ── Summary ───────────────────────────────────────────────────────────────
   console.log();
   if (allOk) {
     console.log(
-      `  ${green("✓ All checks passed.")} If the MCP server still fails, try:`,
-    );
-    console.log(
-      `    ${dim("context-vault setup")}  — reconfigure tool integrations`,
+      `  ${green("All checks passed.")} If the MCP server still fails, try restarting your AI tool.`,
     );
   } else {
     console.log(
-      `  ${yellow("Some issues found.")} Address the items above, then restart your AI tool.`,
-    );
-    console.log(
-      `    ${dim("context-vault setup")}  — reconfigure and repair installation`,
+      `  ${yellow("Some issues found.")} Address the items marked with ${red("✘")} above.`,
     );
   }
   console.log();
@@ -4095,6 +4510,12 @@ async function main() {
     case "session-capture":
       await runSessionCapture();
       break;
+    case "session-end":
+      await runSessionEnd();
+      break;
+    case "post-tool-call":
+      await runPostToolCall();
+      break;
     case "save":
       await runSave();
       break;

package/node_modules/@context-vault/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-vault/core",
-  "version": "2.15.0",
+  "version": "2.17.0",
   "type": "module",
   "description": "Shared core: capture, index, retrieve, tools, and utilities for context-vault",
   "main": "src/index.js",

package/node_modules/@context-vault/core/src/constants.js

@@ -14,8 +14,13 @@ export const MAX_SOURCE_LENGTH = 200;
 export const MAX_IDENTITY_KEY_LENGTH = 200;
 
 export const DEFAULT_GROWTH_THRESHOLDS = {
-  totalEntries: { warn: 1000, critical: 5000 },
-  eventEntries: { warn: 500, critical: 2000 },
+  totalEntries: { warn: 2000, critical: 5000 },
+  eventEntries: { warn: 1000, critical: 3000 },
   vaultSizeBytes: { warn: 50 * 1024 * 1024, critical: 200 * 1024 * 1024 },
   eventsWithoutTtl: { warn: 200 },
 };
+
+export const DEFAULT_LIFECYCLE = {
+  event: { archiveAfterDays: 90 },
+  ephemeral: { archiveAfterDays: 30 },
+};

package/node_modules/@context-vault/core/src/core/config.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
-import { DEFAULT_GROWTH_THRESHOLDS } from "../constants.js";
+import { DEFAULT_GROWTH_THRESHOLDS, DEFAULT_LIFECYCLE } from "../constants.js";
 
 export function parseArgs(argv) {
   const args = {};
@@ -27,7 +27,7 @@ export function resolveConfig() {
       join(HOME, ".context-mcp"),
   );
   const config = {
-    vaultDir: join(HOME, "vault"),
+    vaultDir: join(HOME, ".vault"),
     dataDir,
     dbPath: join(dataDir, "vault.db"),
     devDir: join(HOME, "dev"),
@@ -48,6 +48,7 @@ export function resolveConfig() {
       maxAgeDays: 7,
       autoConsolidate: false,
     },
+    lifecycle: structuredClone(DEFAULT_LIFECYCLE),
   };
 
   const configPath = join(dataDir, "config.json");
@@ -62,6 +63,12 @@ export function resolveConfig() {
       if (fc.dbPath) config.dbPath = fc.dbPath;
       if (fc.devDir) config.devDir = fc.devDir;
       if (fc.eventDecayDays != null) config.eventDecayDays = fc.eventDecayDays;
+      if (fc.growthWarningThreshold != null) {
+        config.thresholds.totalEntries = {
+          ...config.thresholds.totalEntries,
+          warn: Number(fc.growthWarningThreshold),
+        };
+      }
       if (fc.thresholds) {
         const t = fc.thresholds;
         if (t.totalEntries)

package/node_modules/@context-vault/core/src/core/status.js

@@ -212,7 +212,7 @@ export function gatherVaultStatus(ctx, opts = {}) {
  *
  * @param {object} status — result of gatherVaultStatus()
  * @param {object} thresholds — from config.thresholds
- * @returns {{ warnings: Array, hasCritical: boolean, hasWarnings: boolean, actions: string[] }}
+ * @returns {{ warnings: Array, hasCritical: boolean, hasWarnings: boolean, actions: string[], kindBreakdown: Array }}
  */
 export function computeGrowthWarnings(status, thresholds) {
   if (!thresholds)
@@ -221,6 +221,7 @@ export function computeGrowthWarnings(status, thresholds) {
       hasCritical: false,
       hasWarnings: false,
       actions: [],
+      kindBreakdown: [],
     };
 
   const t = thresholds;
@@ -235,12 +236,16 @@ export function computeGrowthWarnings(status, thresholds) {
     dbSizeBytes = 0,
   } = status;
 
+  let totalExceeded = false;
+
   if (t.totalEntries?.critical != null && total >= t.totalEntries.critical) {
+    totalExceeded = true;
     warnings.push({
       level: "critical",
       message: `Total entries: ${total.toLocaleString()} (exceeds critical limit of ${t.totalEntries.critical.toLocaleString()})`,
     });
   } else if (t.totalEntries?.warn != null && total >= t.totalEntries.warn) {
+    totalExceeded = true;
     warnings.push({
       level: "warn",
       message: `Total entries: ${total.toLocaleString()} (exceeds recommended ${t.totalEntries.warn.toLocaleString()})`,
@@ -320,5 +325,26 @@ export function computeGrowthWarnings(status, thresholds) {
     actions.push("Consider archiving events older than 90 days");
   }
 
-  return { warnings, hasCritical, hasWarnings: warnings.length > 0, actions };
+  const kindBreakdown = totalExceeded
+    ? buildKindBreakdown(status.kindCounts, total)
+    : [];
+
+  return {
+    warnings,
+    hasCritical,
+    hasWarnings: warnings.length > 0,
+    actions,
+    kindBreakdown,
+  };
+}
+
+function buildKindBreakdown(kindCounts, total) {
+  if (!kindCounts?.length || total === 0) return [];
+  return [...kindCounts]
+    .sort((a, b) => b.c - a.c)
+    .map(({ kind, c }) => ({
+      kind,
+      count: c,
+      pct: Math.round((c / total) * 100),
+    }));
 }

package/node_modules/@context-vault/core/src/index/index.js

@@ -196,18 +196,20 @@ export async function indexEntry(
     );
   }
 
-  // Embeddings are always generated from plaintext (before encryption)
-  const embeddingText = [title, body].filter(Boolean).join(" ");
-  const embedding = await ctx.embed(embeddingText);
+  // Skip embedding generation for event entries — they are excluded from
+  // default semantic search and don't need vector representations
+  if (cat !== "event") {
+    const embeddingText = [title, body].filter(Boolean).join(" ");
+    const embedding = await ctx.embed(embeddingText);
 
-  // Upsert vec: delete old if exists, then insert new (skip if embedding unavailable)
-  if (embedding) {
-    try {
-      ctx.deleteVec(rowid);
-    } catch {
-      /* no-op if not found */
+    if (embedding) {
+      try {
+        ctx.deleteVec(rowid);
+      } catch {
+        /* no-op if not found */
+      }
+      ctx.insertVec(rowid, embedding);
     }
-    ctx.insertVec(rowid, embedding);
   }
 }
 
@@ -370,15 +372,17 @@ export async function reindex(ctx, opts = {}) {
             fmMeta.updated || created,
           );
           if (result.changes > 0) {
-            const rowidResult = ctx.stmts.getRowid.get(id);
-            if (rowidResult?.rowid) {
-              const embeddingText = [parsed.title, parsed.body]
-                .filter(Boolean)
-                .join(" ");
-              pendingEmbeds.push({
-                rowid: rowidResult.rowid,
-                text: embeddingText,
-              });
+            if (category !== "event") {
+              const rowidResult = ctx.stmts.getRowid.get(id);
+              if (rowidResult?.rowid) {
+                const embeddingText = [parsed.title, parsed.body]
+                  .filter(Boolean)
+                  .join(" ");
+                pendingEmbeds.push({
+                  rowid: rowidResult.rowid,
+                  text: embeddingText,
+                });
+              }
             }
             stats.added++;
           } else {
@@ -407,7 +411,7 @@ export async function reindex(ctx, opts = {}) {
             );
 
             // Queue re-embed if title or body changed (vector ops deferred to Phase 2)
-            if (bodyChanged || titleChanged) {
+            if ((bodyChanged || titleChanged) && category !== "event") {
               const rowid = ctx.stmts.getRowid.get(existing.id)?.rowid;
               if (rowid) {
                 const embeddingText = [parsed.title, parsed.body]

package/node_modules/@context-vault/core/src/retrieve/index.js

@@ -74,6 +74,7 @@ export function recencyBoost(createdAt, category, decayDays = 30) {
  */
 export function buildFilterClauses({
   categoryFilter,
+  excludeEvents = false,
   since,
   until,
   userIdFilter,
@@ -94,6 +95,9 @@ export function buildFilterClauses({
     clauses.push("e.category = ?");
     params.push(categoryFilter);
   }
+  if (excludeEvents && !categoryFilter) {
+    clauses.push("e.category != 'event'");
+  }
   if (since) {
     clauses.push("e.created_at >= ?");
     params.push(since);
@@ -242,6 +246,7 @@ export async function hybridSearch(
   {
     kindFilter = null,
     categoryFilter = null,
+    excludeEvents = false,
     since = null,
     until = null,
     limit = 20,
@@ -258,6 +263,7 @@ export async function hybridSearch(
 
   const extraFilters = buildFilterClauses({
     categoryFilter,
+    excludeEvents,
     since,
     until,
     userIdFilter,
@@ -340,6 +346,7 @@ export async function hybridSearch(
             if (teamIdFilter && row.team_id !== teamIdFilter) continue;
             if (kindFilter && row.kind !== kindFilter) continue;
             if (categoryFilter && row.category !== categoryFilter) continue;
+            if (excludeEvents && row.category === "event") continue;
             if (since && row.created_at < since) continue;
             if (until && row.created_at > until) continue;
             if (row.expires_at && new Date(row.expires_at) <= new Date())

package/node_modules/@context-vault/core/src/server/tools/context-status.js

@@ -146,6 +146,13 @@ export function handler(_args, ctx) {
     for (const w of growth.warnings) {
       lines.push(`  ${w.message}`);
     }
+    if (growth.kindBreakdown.length) {
+      lines.push("");
+      lines.push("  Breakdown by kind:");
+      for (const { kind, count, pct } of growth.kindBreakdown) {
+        lines.push(`    ${kind}: ${count.toLocaleString()} (${pct}%)`);
+      }
+    }
     if (growth.actions.length) {
       lines.push("", "Suggested growth actions:");
       for (const a of growth.actions) {

package/node_modules/@context-vault/core/src/server/tools/get-context.js

@@ -316,6 +316,12 @@ export const inputSchema = {
     .describe(
       "If true, include ephemeral tier entries in results. Default: false — only working and durable tiers are returned.",
     ),
+  include_events: z
+    .boolean()
+    .optional()
+    .describe(
+      "If true, include event category entries in semantic search results. Default: false — events are excluded from query-based search but remain accessible via category/tag filters.",
+    ),
 };
 
 /**
@@ -339,6 +345,7 @@ export async function handler(
     max_tokens,
     pivot_count,
     include_ephemeral,
+    include_events,
   },
   ctx,
   { ensureIndexed, reindexFailed },
@@ -347,6 +354,7 @@ export async function handler(
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
   const hasQuery = query?.trim();
+  const shouldExcludeEvents = hasQuery && !include_events && !category;
   // Expand buckets to bucket: prefixed tags and merge with explicit tags
   const bucketTags = buckets?.length ? buckets.map((b) => `bucket:${b}`) : [];
   const effectiveTags = [...(tags ?? []), ...bucketTags];
@@ -413,6 +421,7 @@ export async function handler(
     const sorted = await hybridSearch(ctx, query, {
       kindFilter,
       categoryFilter: category || null,
+      excludeEvents: shouldExcludeEvents,
       since: effectiveSince,
       until: effectiveUntil,
       limit: fetchLimit,
@@ -490,6 +499,11 @@ export async function handler(
     filtered = filtered.filter((r) => r.tier !== "ephemeral");
   }
 
+  // Event category filter: exclude events from semantic search by default
+  if (shouldExcludeEvents) {
+    filtered = filtered.filter((r) => r.category !== "event");
+  }
+
   if (!filtered.length) {
     if (autoWindowed) {
       const days = config.eventDecayDays || 30;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-vault",
-  "version": "2.15.0",
+  "version": "2.17.0",
   "type": "module",
   "description": "Persistent memory for AI agents — saves and searches knowledge across sessions",
   "bin": {
@@ -56,7 +56,7 @@
     "@context-vault/core"
   ],
   "dependencies": {
-    "@context-vault/core": "^2.15.0",
+    "@context-vault/core": "^2.17.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "sqlite-vec": "^0.1.0"
   }

package/src/hooks/post-tool-call.mjs

@@ -28,7 +28,7 @@ function extractRelevantInput(toolName, input) {
   return relevant;
 }
 
-async function main() {
+export async function main() {
   try {
     const raw = await readStdin();
     if (!raw.trim()) process.exit(0);

package/src/hooks/session-end.mjs

@@ -428,7 +428,7 @@ export function buildSummary({
   return sections.join("\n");
 }
 
-async function main() {
+export async function main() {
   try {
     const raw = await readStdin();
     if (!raw.trim()) process.exit(0);

package/src/server/index.js

@@ -138,6 +138,25 @@ async function main() {
       { capabilities: { tools: {} } },
     );
 
+    // Hot-reload config.json on every tool call (Option C from #144).
+    // resolveConfig() re-reads the small file each time — negligible I/O
+    // compared to DB queries and embedding operations that follow.
+    let lastVaultDir = config.vaultDir;
+    Object.defineProperty(ctx, "config", {
+      get() {
+        const fresh = resolveConfig();
+        if (fresh.vaultDir !== lastVaultDir) {
+          console.error(
+            `[context-vault] Config reloaded: vaultDir changed to ${fresh.vaultDir}`,
+          );
+          lastVaultDir = fresh.vaultDir;
+          fresh.vaultDirExists = existsSync(fresh.vaultDir);
+        }
+        return fresh;
+      },
+      configurable: true,
+    });
+
     registerTools(server, ctx);
 
     // ── Graceful Shutdown ────────────────────────────────────────────────────