context-vault 2.8.19 → 2.10.0

package/bin/cli.js

@@ -699,6 +699,8 @@ async function configureClaude(tool, vaultDir) {
           "add",
           "-s",
           "user",
+          "-e",
+          "NODE_OPTIONS=--no-warnings=ExperimentalWarning",
           "context-vault",
           "--",
           "npx",
@@ -719,6 +721,8 @@ async function configureClaude(tool, vaultDir) {
           "add",
           "-s",
           "user",
+          "-e",
+          "NODE_OPTIONS=--no-warnings=ExperimentalWarning",
           "context-vault",
           "--",
           process.execPath,
@@ -801,6 +805,7 @@ function configureJsonTool(tool, vaultDir) {
     config[tool.configKey]["context-vault"] = {
       command: "npx",
       args: ["-y", "context-vault", "serve", ...serverArgs],
+      env: { NODE_OPTIONS: "--no-warnings=ExperimentalWarning" },
     };
   } else if (isInstalledPackage()) {
     const launcherPath = join(HOME, ".context-mcp", "server.mjs");
@@ -809,6 +814,7 @@ function configureJsonTool(tool, vaultDir) {
     config[tool.configKey]["context-vault"] = {
       command: process.execPath,
       args: [launcherPath, ...serverArgs],
+      env: { NODE_OPTIONS: "--no-warnings=ExperimentalWarning" },
     };
   } else {
     const serverArgs = [SERVER_PATH];
@@ -816,6 +822,7 @@ function configureJsonTool(tool, vaultDir) {
     config[tool.configKey]["context-vault"] = {
       command: process.execPath,
       args: serverArgs,
+      env: { NODE_OPTIONS: "--no-warnings=ExperimentalWarning" },
     };
   }
 

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

@@ -1,6 +1,6 @@
 {
   "name": "@context-vault/core",
-  "version": "2.8.19",
+  "version": "2.10.0",
   "type": "module",
   "description": "Shared core: capture, index, retrieve, tools, and utilities for context-vault",
   "main": "src/index.js",
@@ -31,7 +31,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   },
   "author": "Felix Hellstrom",
   "repository": {

package/node_modules/@context-vault/core/src/core/error-log.js

@@ -0,0 +1,54 @@
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+const MAX_LOG_SIZE = 1024 * 1024; // 1MB
+
+export function errorLogPath(dataDir) {
+  return join(dataDir, "error.log");
+}
+
+/**
+ * Append a structured JSON entry to the startup error log.
+ * Rotates the file if it exceeds MAX_LOG_SIZE.
+ * Never throws — logging failures must not mask the original error.
+ *
+ * @param {string} dataDir
+ * @param {object} entry
+ */
+export function appendErrorLog(dataDir, entry) {
+  try {
+    mkdirSync(dataDir, { recursive: true });
+    const logPath = errorLogPath(dataDir);
+    if (existsSync(logPath) && statSync(logPath).size >= MAX_LOG_SIZE) {
+      writeFileSync(logPath, "");
+    }
+    appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  } catch {
+    // intentionally swallowed
+  }
+}
+
+/**
+ * Return number of log lines in the error log, or 0 if absent.
+ *
+ * @param {string} dataDir
+ * @returns {number}
+ */
+export function errorLogCount(dataDir) {
+  try {
+    const logPath = errorLogPath(dataDir);
+    if (!existsSync(logPath)) return 0;
+    return readFileSync(logPath, "utf-8")
+      .split("\n")
+      .filter((l) => l.trim()).length;
+  } catch {
+    return 0;
+  }
+}

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

@@ -128,6 +128,18 @@ export function gatherVaultStatus(ctx, opts = {}) {
   // Embedding model availability
   const embedModelAvailable = isEmbedAvailable();
 
+  // Count auto-captured feedback entries (written by tracked() on unhandled errors)
+  let autoCapturedFeedbackCount = 0;
+  try {
+    autoCapturedFeedbackCount = db
+      .prepare(
+        `SELECT COUNT(*) as c FROM vault WHERE kind = 'feedback' AND tags LIKE '%"auto-captured"%' ${userAnd}`,
+      )
+      .get(...userParams).c;
+  } catch (e) {
+    errors.push(`Auto-captured feedback count failed: ${e.message}`);
+  }
+
   return {
     fileCount,
     subdirs,
@@ -140,6 +152,7 @@ export function gatherVaultStatus(ctx, opts = {}) {
     expiredCount,
     embeddingStatus,
     embedModelAvailable,
+    autoCapturedFeedbackCount,
     resolvedFrom: config.resolvedFrom,
     errors,
   };

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

@@ -1,4 +1,5 @@
 import { unlinkSync, copyFileSync, existsSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
 
 export class NativeModuleError extends Error {
   constructor(originalError) {
@@ -11,55 +12,34 @@ export class NativeModuleError extends Error {
 
 function formatNativeModuleError(err) {
   const msg = err.message || "";
-  const versionMatch = msg.match(
-    /was compiled against a different Node\.js version using\s+NODE_MODULE_VERSION (\d+)\. This version of Node\.js requires\s+NODE_MODULE_VERSION (\d+)/,
-  );
-
-  const lines = [
-    `Native module failed to load: ${msg}`,
+  return [
+    `sqlite-vec extension failed to load: ${msg}`,
     "",
     `  Running Node.js: ${process.version} (${process.execPath})`,
-  ];
-
-  if (versionMatch) {
-    lines.push(`  Module compiled for: NODE_MODULE_VERSION ${versionMatch[1]}`);
-    lines.push(`  Current runtime:     NODE_MODULE_VERSION ${versionMatch[2]}`);
-  }
-
-  lines.push(
-    "",
-    "  Fix: Rebuild native modules for your current Node.js:",
-    "    npm rebuild better-sqlite3 sqlite-vec",
     "",
-    "  Or reinstall:",
+    "  Fix: Reinstall context-vault:",
     "    npx -y context-vault@latest setup",
-  );
-
-  return lines.join("\n");
+  ].join("\n");
 }
 
-let _Database = null;
 let _sqliteVec = null;
 
-async function loadNativeModules() {
-  if (_Database && _sqliteVec)
-    return { Database: _Database, sqliteVec: _sqliteVec };
-
-  try {
-    const dbMod = await import("better-sqlite3");
-    _Database = dbMod.default;
-  } catch (e) {
-    throw new NativeModuleError(e);
-  }
+async function loadSqliteVec() {
+  if (_sqliteVec) return _sqliteVec;
+  const vecMod = await import("sqlite-vec");
+  _sqliteVec = vecMod;
+  return _sqliteVec;
+}
 
+function runTransaction(db, fn) {
+  db.exec("BEGIN");
   try {
-    const vecMod = await import("sqlite-vec");
-    _sqliteVec = vecMod;
+    fn();
+    db.exec("COMMIT");
   } catch (e) {
-    throw new NativeModuleError(e);
+    db.exec("ROLLBACK");
+    throw e;
   }
-
-  return { Database: _Database, sqliteVec: _sqliteVec };
 }
 
 export const SCHEMA_DDL = `
@@ -118,12 +98,12 @@ export const SCHEMA_DDL = `
 `;
 
 export async function initDatabase(dbPath) {
-  const { Database, sqliteVec } = await loadNativeModules();
+  const sqliteVec = await loadSqliteVec();
 
   function createDb(path) {
-    const db = new Database(path);
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
+    const db = new DatabaseSync(path, { allowExtension: true });
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
     try {
       sqliteVec.load(db);
     } catch (e) {
@@ -133,7 +113,7 @@ export async function initDatabase(dbPath) {
   }
 
   const db = createDb(dbPath);
-  const version = db.pragma("user_version", { simple: true });
+  const version = db.prepare("PRAGMA user_version").get().user_version;
 
   // Enforce fresh-DB-only — old schemas get a full rebuild (with backup)
   if (version > 0 && version < 5) {
@@ -167,17 +147,17 @@ export async function initDatabase(dbPath) {
 
     const freshDb = createDb(dbPath);
     freshDb.exec(SCHEMA_DDL);
-    freshDb.pragma("user_version = 7");
+    freshDb.exec("PRAGMA user_version = 7");
     return freshDb;
   }
 
   if (version < 5) {
     db.exec(SCHEMA_DDL);
-    db.pragma("user_version = 7");
+    db.exec("PRAGMA user_version = 7");
   } else if (version === 5) {
     // v5 -> v6 migration: add multi-tenancy + encryption columns
     // Wrapped in transaction with duplicate-column guards for idempotent retry
-    const migrate = db.transaction(() => {
+    runTransaction(db, () => {
       const addColumnSafe = (sql) => {
         try {
           db.exec(sql);
@@ -197,21 +177,19 @@ export async function initDatabase(dbPath) {
       db.exec(
         `CREATE UNIQUE INDEX IF NOT EXISTS idx_vault_identity ON vault(user_id, kind, identity_key) WHERE identity_key IS NOT NULL`,
       );
-      db.pragma("user_version = 7");
+      db.exec("PRAGMA user_version = 7");
     });
-    migrate();
   } else if (version === 6) {
     // v6 -> v7 migration: add team_id column
-    const migrate = db.transaction(() => {
+    runTransaction(db, () => {
       try {
         db.exec(`ALTER TABLE vault ADD COLUMN team_id TEXT`);
       } catch (e) {
         if (!e.message.includes("duplicate column")) throw e;
       }
       db.exec(`CREATE INDEX IF NOT EXISTS idx_vault_team ON vault(team_id)`);
-      db.pragma("user_version = 7");
+      db.exec("PRAGMA user_version = 7");
     });
-    migrate();
   }
 
   return db;
@@ -247,15 +225,15 @@ export function prepareStatements(db) {
   } catch (e) {
     throw new Error(
       `Failed to prepare database statements. The database may be corrupted.\n` +
-        `Try deleting and rebuilding: rm "${db.name}" && context-vault reindex\n` +
+        `Try deleting and rebuilding: context-vault reindex\n` +
         `Original error: ${e.message}`,
     );
   }
 }
 
 export function insertVec(stmts, rowid, embedding) {
-  // sqlite-vec requires BigInt for primary key — better-sqlite3 binds Number as REAL,
-  // but vec0 virtual tables only accept INTEGER rowids
+  // sqlite-vec requires BigInt for primary key — node:sqlite may bind Number as REAL
+  // for vec0 virtual tables which only accept INTEGER rowids
   const safeRowid = BigInt(rowid);
   if (safeRowid < 1n) throw new Error(`Invalid rowid: ${rowid}`);
   stmts.insertVecStmt.run(safeRowid, embedding);

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

@@ -2,12 +2,25 @@
  * helpers.js — Shared MCP response helpers and validation
  */
 
+import pkg from "../../package.json" with { type: "json" };
+
 export function ok(text) {
   return { content: [{ type: "text", text }] };
 }
 
-export function err(text, code = "UNKNOWN") {
-  return { content: [{ type: "text", text }], isError: true, code };
+export function err(text, code = "UNKNOWN", meta = {}) {
+  return {
+    content: [{ type: "text", text }],
+    isError: true,
+    code,
+    _meta: {
+      cv_version: pkg.version,
+      node_version: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      ...meta,
+    },
+  };
 }
 
 export function ensureVaultExists(config) {

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

@@ -1,6 +1,16 @@
 import { gatherVaultStatus } from "../../core/status.js";
+import { errorLogPath, errorLogCount } from "../../core/error-log.js";
 import { ok } from "../helpers.js";
 
+function relativeTime(ts) {
+  const secs = Math.floor((Date.now() - ts) / 1000);
+  if (secs < 60) return `${secs}s ago`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins} minute${mins === 1 ? "" : "s"} ago`;
+  const hrs = Math.floor(mins / 60);
+  return `${hrs} hour${hrs === 1 ? "" : "s"} ago`;
+}
+
 export const name = "context_status";
 
 export const description =
@@ -83,6 +93,33 @@ export function handler(_args, ctx) {
     lines.push(`Auto-reindex will fix this on next search or save.`);
   }
 
+  // Error log
+  const logPath = errorLogPath(config.dataDir);
+  const logCount = errorLogCount(config.dataDir);
+  if (logCount > 0) {
+    lines.push(``, `### Startup Error Log`);
+    lines.push(`- Path: ${logPath}`);
+    lines.push(`- Entries: ${logCount} (share this file for support)`);
+  }
+
+  // Health: session-level tool call stats
+  const ts = ctx.toolStats;
+  if (ts) {
+    lines.push(``, `### Health`);
+    lines.push(`- Tool calls (session): ${ts.ok} ok, ${ts.errors} errors`);
+    if (ts.lastError) {
+      const { tool, code, timestamp } = ts.lastError;
+      lines.push(
+        `- Last error: ${tool ?? "unknown"} — ${code} (${relativeTime(timestamp)})`,
+      );
+    }
+    if (status.autoCapturedFeedbackCount > 0) {
+      lines.push(
+        `- Auto-captured feedback entries: ${status.autoCapturedFeedbackCount} (run get_context with kind:feedback tags:auto-captured)`,
+      );
+    }
+  }
+
   // Suggested actions
   const actions = [];
   if (status.stalePaths)

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

@@ -182,12 +182,21 @@ export async function handler(
     for (const r of filtered) r.score = 0;
   }
 
-  if (!filtered.length)
+  if (!filtered.length) {
+    if (autoWindowed) {
+      const days = config.eventDecayDays || 30;
+      return ok(
+        hasQuery
+          ? `No results found for "${query}" in events (last ${days} days).\nTry with \`since: "YYYY-MM-DD"\` to search older events.`
+          : `No entries found matching the given filters in events (last ${days} days).\nTry with \`since: "YYYY-MM-DD"\` to search older events.`,
+      );
+    }
     return ok(
       hasQuery
         ? "No results found for: " + query
         : "No entries found matching the given filters.",
     );
+  }
 
   // Decrypt encrypted entries if ctx.decrypt is available
   if (ctx.decrypt) {
@@ -212,6 +221,12 @@ export async function handler(
     );
   const heading = hasQuery ? `Results for "${query}"` : "Filtered entries";
   lines.push(`## ${heading} (${filtered.length} matches)\n`);
+  if (autoWindowed) {
+    const days = config.eventDecayDays || 30;
+    lines.push(
+      `> ℹ Event search limited to last ${days} days. Use \`since\` parameter for older results.\n`,
+    );
+  }
   for (let i = 0; i < filtered.length; i++) {
     const r = filtered[i];
     const entryTags = r.tags ? JSON.parse(r.tags) : [];
@@ -229,10 +244,5 @@ export async function handler(
     lines.push(r.body?.slice(0, 300) + (r.body?.length > 300 ? "..." : ""));
     lines.push("");
   }
-  if (autoWindowed) {
-    lines.push(
-      `_Showing events from last ${config.eventDecayDays || 30} days. Use since/until for custom range._`,
-    );
-  }
   return ok(lines.join("\n"));
 }

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { normalizeKind } from "../../core/files.js";
+import { categoryFor } from "../../core/categories.js";
 import { ok } from "../helpers.js";
 
 export const name = "list_context";
@@ -50,6 +51,17 @@ export async function handler(
 
   await ensureIndexed();
 
+  const kindFilter = kind ? normalizeKind(kind) : null;
+  const effectiveCategory =
+    category || (kindFilter ? categoryFor(kindFilter) : null);
+  let effectiveSince = since || null;
+  let autoWindowed = false;
+  if (effectiveCategory === "event" && !since && !until) {
+    const decayMs = (config.eventDecayDays || 30) * 86400000;
+    effectiveSince = new Date(Date.now() - decayMs).toISOString();
+    autoWindowed = true;
+  }
+
   const clauses = [];
   const params = [];
 
@@ -57,17 +69,17 @@ export async function handler(
     clauses.push("user_id = ?");
     params.push(userId);
   }
-  if (kind) {
+  if (kindFilter) {
     clauses.push("kind = ?");
-    params.push(normalizeKind(kind));
+    params.push(kindFilter);
   }
   if (category) {
     clauses.push("category = ?");
     params.push(category);
   }
-  if (since) {
+  if (effectiveSince) {
     clauses.push("created_at >= ?");
-    params.push(since);
+    params.push(effectiveSince);
   }
   if (until) {
     clauses.push("created_at <= ?");
@@ -103,8 +115,15 @@ export async function handler(
         .slice(0, effectiveLimit)
     : rows;
 
-  if (!filtered.length)
+  if (!filtered.length) {
+    if (autoWindowed) {
+      const days = config.eventDecayDays || 30;
+      return ok(
+        `No entries found matching the given filters in events (last ${days} days).\nTry with \`since: "YYYY-MM-DD"\` to search older events.`,
+      );
+    }
     return ok("No entries found matching the given filters.");
+  }
 
   const lines = [];
   if (reindexFailed)
@@ -112,6 +131,12 @@ export async function handler(
       `> **Warning:** Auto-reindex failed. Results may be stale. Run \`context-vault reindex\` to fix.\n`,
     );
   lines.push(`## Vault Entries (${filtered.length} shown, ${total} total)\n`);
+  if (autoWindowed) {
+    const days = config.eventDecayDays || 30;
+    lines.push(
+      `> ℹ Event search limited to last ${days} days. Use \`since\` parameter for older results.\n`,
+    );
+  }
   for (const r of filtered) {
     const entryTags = r.tags ? JSON.parse(r.tags) : [];
     const tagStr = entryTags.length ? entryTags.join(", ") : "none";

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

@@ -1,5 +1,7 @@
 import { reindex } from "../index/index.js";
+import { captureAndIndex } from "../capture/index.js";
 import { err } from "./helpers.js";
+import pkg from "../../package.json" with { type: "json" };
 
 import * as getContext from "./tools/get-context.js";
 import * as saveContext from "./tools/save-context.js";
@@ -24,14 +26,14 @@ const TOOL_TIMEOUT_MS = 60_000;
 export function registerTools(server, ctx) {
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
-  function tracked(handler) {
+  function tracked(handler, toolName) {
     return async (...args) => {
       if (ctx.activeOps) ctx.activeOps.count++;
       let timer;
       let handlerPromise;
       try {
         handlerPromise = Promise.resolve(handler(...args));
-        return await Promise.race([
+        const result = await Promise.race([
           handlerPromise,
           new Promise((_, reject) => {
             timer = setTimeout(
@@ -40,16 +42,49 @@ export function registerTools(server, ctx) {
             );
           }),
         ]);
+        if (ctx.toolStats) ctx.toolStats.ok++;
+        return result;
       } catch (e) {
         if (e.message === "TOOL_TIMEOUT") {
           // Suppress any late rejection from the still-running handler to
           // prevent unhandled promise rejection warnings in the host process.
           handlerPromise?.catch(() => {});
+          if (ctx.toolStats) {
+            ctx.toolStats.errors++;
+            ctx.toolStats.lastError = {
+              tool: toolName,
+              code: "TIMEOUT",
+              timestamp: Date.now(),
+            };
+          }
           return err(
             "Tool timed out after 60s. Try a simpler query or run `context-vault reindex` first.",
             "TIMEOUT",
           );
         }
+        if (ctx.toolStats) {
+          ctx.toolStats.errors++;
+          ctx.toolStats.lastError = {
+            tool: toolName,
+            code: "UNKNOWN",
+            timestamp: Date.now(),
+          };
+        }
+        try {
+          await captureAndIndex(ctx, {
+            kind: "feedback",
+            title: `Unhandled error in ${toolName ?? "tool"} call`,
+            body: `${e.message}\n\n${e.stack ?? ""}`,
+            tags: ["bug", "auto-captured"],
+            source: "auto-capture",
+            meta: {
+              tool: toolName,
+              error_type: e.constructor?.name,
+              cv_version: pkg.version,
+              auto: true,
+            },
+          });
+        } catch {} // never block on feedback capture
         throw e;
       } finally {
         clearTimeout(timer);
@@ -110,7 +145,7 @@ export function registerTools(server, ctx) {
       mod.name,
       mod.description,
       mod.inputSchema,
-      tracked((args) => mod.handler(args, ctx, shared)),
+      tracked((args) => mod.handler(args, ctx, shared), mod.name),
     );
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-vault",
-  "version": "2.8.19",
+  "version": "2.10.0",
   "type": "module",
   "description": "Persistent memory for AI agents — saves and searches knowledge across sessions",
   "bin": {
@@ -25,7 +25,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   },
   "author": "Felix Hellstrom",
   "repository": {
@@ -55,9 +55,8 @@
     "@context-vault/core"
   ],
   "dependencies": {
-    "@context-vault/core": "^2.8.19",
+    "@context-vault/core": "^2.10.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "better-sqlite3": "^12.6.2",
     "sqlite-vec": "^0.1.0"
   }
 }

package/scripts/postinstall.js

@@ -3,10 +3,10 @@
 /**
  * postinstall.js — Post-install setup for context-vault
  *
- * 1. Detects NODE_MODULE_VERSION mismatches for native modules and rebuilds.
- * 2. Installs @huggingface/transformers with --ignore-scripts to avoid sharp's
+ * 1. Installs @huggingface/transformers with --ignore-scripts to avoid sharp's
  *    broken install lifecycle in global contexts.  Semantic search degrades
  *    gracefully if this step fails.
+ * 2. Writes local server launcher (global installs only).
  */
 
 import { execSync } from "node:child_process";
@@ -20,46 +20,7 @@ const PKG_ROOT = join(__dirname, "..");
 const NODE_MODULES = join(PKG_ROOT, "node_modules");
 
 async function main() {
-  // ── 1. Native-module rebuild ──────────────────────────────────────────
-  let needsRebuild = false;
-
-  try {
-    await import("better-sqlite3");
-  } catch (e) {
-    if (e.message?.includes("NODE_MODULE_VERSION")) {
-      needsRebuild = true;
-    }
-  }
-
-  try {
-    await import("sqlite-vec");
-  } catch (e) {
-    if (e.message?.includes("NODE_MODULE_VERSION")) {
-      needsRebuild = true;
-    }
-  }
-
-  if (needsRebuild) {
-    console.log(
-      "[context-vault] Rebuilding native modules for Node.js " +
-        process.version +
-        "...",
-    );
-    try {
-      execSync("npm rebuild better-sqlite3 sqlite-vec", {
-        stdio: "inherit",
-        timeout: 60000,
-      });
-      console.log("[context-vault] Native modules rebuilt successfully.");
-    } catch {
-      console.error("[context-vault] Warning: native module rebuild failed.");
-      console.error(
-        "[context-vault] Try manually: npm rebuild better-sqlite3 sqlite-vec",
-      );
-    }
-  }
-
-  // ── 2. Install @huggingface/transformers (optional) ───────────────────
+  // ── 1. Install @huggingface/transformers (optional) ───────────────────
   // The transformers package depends on `sharp`, whose install script fails
   // in global npm contexts.  We install with --ignore-scripts to skip it —
   // context-vault only uses text embeddings, not image processing.
@@ -90,7 +51,7 @@ async function main() {
     }
   }
 
-  // ── 3. Write local server launcher (global installs only) ────────────
+  // ── 2. Write local server launcher (global installs only) ────────────
   // Under npx the path would be stale after cache eviction — configs use
   // `npx context-vault serve` instead, so skip writing the launcher.
   const isNpx = PKG_ROOT.includes("/_npx/") || PKG_ROOT.includes("\\_npx\\");

package/scripts/prepack.js

@@ -30,7 +30,7 @@ cpSync(CORE_SRC, CORE_DEST, { recursive: true, dereference: true });
 rmSync(join(CORE_DEST, "node_modules"), { recursive: true, force: true });
 
 // Strip all dependencies from the bundled core's package.json.
-// Core's deps (better-sqlite3, sqlite-vec, MCP SDK) are hoisted to
+// Core's deps (sqlite-vec, MCP SDK) are hoisted to
 // context-vault's own dependencies.  @huggingface/transformers is
 // dynamically imported and installed via postinstall.  Leaving them
 // in the bundled core causes duplicate resolution that breaks native

package/src/server/index.js

@@ -10,6 +10,7 @@ import {
   unlinkSync,
 } from "node:fs";
 import { join, dirname } from "node:path";
+import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -18,6 +19,7 @@ const pkg = JSON.parse(
 );
 
 import { resolveConfig } from "@context-vault/core/core/config";
+import { appendErrorLog } from "@context-vault/core/core/error-log";
 import { embed } from "@context-vault/core/index/embed";
 import {
   initDatabase,
@@ -106,6 +108,7 @@ async function main() {
       insertVec: (rowid, embedding) => insertVec(stmts, rowid, embedding),
       deleteVec: (rowid) => deleteVec(stmts, rowid),
       activeOps: { count: 0 },
+      toolStats: { ok: 0, errors: 0, lastError: null },
     };
 
     // ── Phase: SERVER ────────────────────────────────────────────────────────
@@ -186,6 +189,20 @@ async function main() {
         .catch(() => {});
     }, 3000);
   } catch (err) {
+    const dataDir = config?.dataDir || join(homedir(), ".context-mcp");
+
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      error_type: err.constructor?.name || "Error",
+      message: err.message,
+      node_version: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      cv_version: pkg.version,
+      phase,
+    };
+    appendErrorLog(dataDir, logEntry);
+
     if (err instanceof NativeModuleError) {
       // Boxed diagnostic for native module mismatch
       console.error("");
@@ -203,6 +220,7 @@ async function main() {
       console.error("");
       console.error(`  Node.js path:    ${process.execPath}`);
       console.error(`  Node.js version: ${process.version}`);
+      console.error(`  Error log:       ${join(dataDir, "error.log")}`);
       console.error("");
       process.exit(78); // EX_CONFIG
     }
@@ -210,6 +228,7 @@ async function main() {
     console.error(
       `[context-vault] Fatal error during ${phase} phase: ${err.message}`,
     );
+    console.error(`[context-vault] Error log: ${join(dataDir, "error.log")}`);
     if (phase === "DB") {
       console.error(
         `[context-vault] Try deleting the DB file and restarting: rm "${config?.dbPath || "vault.db"}"`,