context-vault 3.0.2 → 3.1.0

package/bin/cli.js

@@ -2,9 +2,9 @@
 
 // Node.js version guard — must run before any ESM imports
 const nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
-if (nodeVersion < 20) {
+if (nodeVersion < 22) {
   process.stderr.write(
-    `\ncontext-vault requires Node.js >= 20 (you have ${process.versions.node}).\n` +
+    `\ncontext-vault requires Node.js >= 22 (you have ${process.versions.node}).\n` +
       `Install a newer version: https://nodejs.org/\n\n`,
   );
   process.exit(1);
@@ -303,6 +303,7 @@ ${bold("Commands:")}
   ${cyan("health")}                     Quick health check — vault, DB, entry count
   ${cyan("status")}                     Show vault diagnostics
   ${cyan("doctor")}                     Diagnose and repair common issues
+  ${cyan("debug")}                      Generate AI-pasteable debug report
   ${cyan("restart")}                    Stop running MCP server processes (client auto-restarts)
   ${cyan("search")}                     Search vault entries from CLI
   ${cyan("save")}                       Save an entry to the vault from CLI
@@ -3598,6 +3599,8 @@ async function runSave() {
   const tier = getFlag("--tier");
   const filePath = getFlag("--file");
   const bodyFlag = getFlag("--body");
+  const identityKey = getFlag("--identity-key");
+  const metaRaw = getFlag("--meta");
 
   if (!kind) {
     console.error(red("Error: --kind is required"));
@@ -3608,6 +3611,16 @@ async function runSave() {
     process.exit(1);
   }
 
+  let meta;
+  if (metaRaw) {
+    try {
+      meta = JSON.parse(metaRaw);
+    } catch {
+      console.error(red("Error: --meta must be valid JSON"));
+      process.exit(1);
+    }
+  }
+
   let body;
   if (bodyFlag) {
     body = bodyFlag;
@@ -3665,6 +3678,8 @@ async function runSave() {
       tags: parsedTags,
       source,
       ...(tier ? { tier } : {}),
+      ...(identityKey ? { identity_key: identityKey } : {}),
+      ...(meta !== undefined ? { meta } : {}),
     });
     console.log(`${green("✓")} Saved ${kind} — id: ${entry.id}`);
   } catch (e) {
@@ -5265,6 +5280,86 @@ async function runConsolidate() {
   console.log();
 }
 
+async function runDebug() {
+  const { resolveConfig } = await import("@context-vault/core/config");
+  const { errorLogPath, errorLogCount } = await import("../src/error-log.js");
+
+  let config;
+  try {
+    config = resolveConfig();
+  } catch {
+    config = null;
+  }
+
+  const dataDir = config?.dataDir || join(HOME, ".context-mcp");
+  const vaultDir = config?.vaultDir || join(HOME, "vault");
+  const dbPath = config?.dbPath || join(dataDir, "vault.db");
+  const configPath = config?.configPath || join(dataDir, "config.json");
+
+  const vaultExists = existsSync(vaultDir);
+  let vaultWritable = false;
+  if (vaultExists) {
+    try {
+      const probe = join(vaultDir, ".write-probe");
+      writeFileSync(probe, "");
+      unlinkSync(probe);
+      vaultWritable = true;
+    } catch {}
+  }
+
+  let dbAccessible = false;
+  let dbEntryCount = "n/a";
+  try {
+    const { initDatabase } = await import("@context-vault/core/db");
+    const db = await initDatabase(dbPath);
+    dbEntryCount = db.prepare("SELECT COUNT(*) as c FROM vault").get().c;
+    db.close();
+    dbAccessible = true;
+  } catch {}
+
+  const logCount = errorLogCount(dataDir);
+  const logPath = errorLogPath(dataDir);
+  let lastLogLines = [];
+  if (logCount > 0) {
+    try {
+      const lines = readFileSync(logPath, "utf-8")
+        .split("\n")
+        .filter((l) => l.trim());
+      lastLogLines = lines.slice(-5);
+    } catch {}
+  }
+
+  const lines = [
+    "```",
+    `context-vault debug report`,
+    `Generated: ${new Date().toISOString()}`,
+    ``,
+    `Node.js:    ${process.versions.node} (${process.execPath})`,
+    `Platform:   ${process.platform} ${process.arch}`,
+    `cv version: ${VERSION}`,
+    ``,
+    `Config:     ${configPath} (${existsSync(configPath) ? "found" : "missing"})`,
+    `Vault dir:  ${vaultDir} (${vaultExists ? "exists" : "missing"}${vaultExists ? `, writable: ${vaultWritable}` : ""})`,
+    `DB path:    ${dbPath} (${existsSync(dbPath) ? "exists" : "missing"})`,
+    `DB access:  ${dbAccessible ? `ok (${dbEntryCount} entries)` : "failed"}`,
+    ``,
+    `Error log:  ${logPath} (${logCount} entries)`,
+  ];
+
+  if (lastLogLines.length) {
+    lines.push(``, `Last 5 error log entries:`);
+    for (const l of lastLogLines) lines.push(`  ${l}`);
+  }
+
+  lines.push("```");
+  lines.push(
+    ``,
+    `Paste the above into Claude Code or your AI assistant to diagnose issues.`,
+  );
+
+  console.log(lines.join("\n"));
+}
+
 async function runServe() {
   await import("../src/server.js");
 }
@@ -5384,6 +5479,9 @@ async function main() {
     case "consolidate":
       await runConsolidate();
       break;
+    case "debug":
+      await runDebug();
+      break;
     default:
       console.error(red(`Unknown command: ${command}`));
       console.error(`Run ${cyan("context-vault --help")} for usage.`);
@@ -5392,6 +5490,15 @@ async function main() {
 }
 
 main().catch((e) => {
-  console.error(red(e.message));
+  const dataDir = join(HOME, ".context-mcp");
+  const logPath = join(dataDir, "error.log");
+  console.error(red(`Error: ${e.message}`));
+  console.error(dim(`Error log: ${logPath}`));
+  console.error(dim(`Run: context-vault doctor`));
+  console.error(
+    dim(
+      `Debug with AI: "context-vault exited with: ${e.message} — how do I fix this?"`,
+    ),
+  );
   process.exit(1);
 });

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

@@ -1,6 +1,6 @@
 {
   "name": "@context-vault/core",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "type": "module",
   "description": "Pure local engine: capture, index, search, and utilities for context-vault",
   "main": "dist/main.js",

package/node_modules/@context-vault/core/src/capture.ts

@@ -266,7 +266,7 @@ export function updateEntryFile(
   };
 }
 
-export async function captureAndIndex(ctx: BaseCtx, data: CaptureInput): Promise<CaptureResult> {
+export async function captureAndIndex(ctx: BaseCtx, data: CaptureInput, precomputedEmbedding?: Float32Array | null): Promise<CaptureResult> {
   let previousContent: string | null = null;
   if (categoryFor(data.kind) === "entity" && data.identity_key) {
     const identitySlug = slugify(data.identity_key);
@@ -279,7 +279,7 @@ export async function captureAndIndex(ctx: BaseCtx, data: CaptureInput): Promise
 
   const entry = writeEntry(ctx, data);
   try {
-    await indexEntry(ctx, entry);
+    await indexEntry(ctx, entry, precomputedEmbedding);
     if (entry.supersedes?.length && ctx.stmts.updateSupersededBy) {
       for (const supersededId of entry.supersedes) {
         if (typeof supersededId === "string" && supersededId.trim()) {

package/node_modules/@context-vault/core/src/db.ts

@@ -107,6 +107,7 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
     const db = new DatabaseSync(path, { allowExtension: true });
     db.exec("PRAGMA journal_mode = WAL");
     db.exec("PRAGMA foreign_keys = ON");
+    db.exec("PRAGMA busy_timeout = 3000");
     try {
       sqliteVec.load(db);
     } catch (e) {
@@ -124,6 +125,7 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
     );
 
     const backupPath = `${dbPath}.v${version}.backup`;
+    let backupSucceeded = false;
     try {
       db.close();
       if (existsSync(dbPath)) {
@@ -131,6 +133,9 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
         console.error(
           `[context-vault] Backed up old database to: ${backupPath}`,
         );
+        backupSucceeded = true;
+      } else {
+        backupSucceeded = true;
       }
     } catch (backupErr) {
       console.error(
@@ -138,6 +143,13 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
       );
     }
 
+    if (!backupSucceeded) {
+      throw new Error(
+        `[context-vault] Aborting schema migration: backup failed for ${dbPath}. ` +
+        `Fix the backup issue or manually back up the file before upgrading.`,
+      );
+    }
+
     unlinkSync(dbPath);
     try { unlinkSync(dbPath + "-wal"); } catch {}
     try { unlinkSync(dbPath + "-shm"); } catch {}

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

@@ -13,6 +13,7 @@ const EMBED_BATCH_SIZE = 32;
 export async function indexEntry(
   ctx: BaseCtx,
   entry: IndexEntryInput & { supersedes?: string[] | null; related_to?: string[] | null },
+  precomputedEmbedding?: Float32Array | null,
 ): Promise<void> {
   const {
     id, kind, category, title, body, meta, tags, source,
@@ -92,8 +93,16 @@ export async function indexEntry(
   }
 
   if (cat !== "event") {
-    const embeddingText = [title, body].filter(Boolean).join(" ");
-    const embedding = await ctx.embed(embeddingText);
+    let embedding: Float32Array | null = null;
+    if (precomputedEmbedding !== undefined) {
+      embedding = precomputedEmbedding;
+    } else {
+      try {
+        embedding = await ctx.embed([title, body].filter(Boolean).join(" "));
+      } catch (embedErr) {
+        console.warn(`[context-vault] embed() failed for entry ${id} — skipping vec insert: ${(embedErr as Error).message}`);
+      }
+    }
 
     if (embedding) {
       try { ctx.deleteVec(rowid); } catch { /* no-op */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-vault",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "type": "module",
   "description": "Persistent memory for AI agents — saves and searches knowledge across sessions",
   "bin": {
@@ -57,7 +57,7 @@
     "@context-vault/core"
   ],
   "dependencies": {
-    "@context-vault/core": "^3.0.0",
+    "@context-vault/core": "^3.1.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "adm-zip": "^0.5.16",
     "sqlite-vec": "^0.1.0"

package/src/helpers.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(
-  readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"),
+  readFileSync(join(__dirname, "..", "package.json"), "utf-8"),
 );
 
 export function ok(text) {
@@ -26,11 +26,19 @@ export function err(text, code = "UNKNOWN", meta = {}) {
   };
 }
 
+export function errWithHint(text, code, hint) {
+  const prompt = hint
+    ? `\n\n**Debug with AI:** Paste this into Claude Code or your AI assistant:\n> "${hint}"`
+    : "";
+  return err(text + prompt, code);
+}
+
 export function ensureVaultExists(config) {
   if (!config.vaultDirExists) {
-    return err(
+    return errWithHint(
       `Vault directory not found: ${config.vaultDir}. Run context-status for diagnostics.`,
       "VAULT_NOT_FOUND",
+      "My context-vault can't find the vault directory. Run `context-vault doctor` and help me fix it.",
     );
   }
   return null;

package/src/register-tools.js

@@ -109,7 +109,7 @@ export function registerTools(server, ctx) {
             },
           });
         } catch {}
-        throw e;
+        return err(e.message, "INTERNAL_ERROR");
       } finally {
         clearTimeout(timer);
         if (ctx.activeOps) ctx.activeOps.count--;
@@ -170,4 +170,6 @@ export function registerTools(server, ctx) {
       tracked((args) => mod.handler(args, ctx, shared), mod.name),
     );
   }
+
+  ensureIndexed().catch(() => {});
 }

package/src/server.js

@@ -221,6 +221,13 @@ async function main() {
       phase,
     };
     appendErrorLog(dataDir, logEntry);
+    try {
+      mkdirSync(dataDir, { recursive: true });
+      writeFileSync(
+        join(dataDir, ".last-error"),
+        `${logEntry.timestamp} [${phase}] ${err.message}`,
+      );
+    } catch {}
 
     sendTelemetryEvent(config, {
       event: "startup_error",

package/src/tools/context-status.js

@@ -1,6 +1,8 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { gatherVaultStatus, computeGrowthWarnings } from "../status.js";
 import { errorLogPath, errorLogCount } from "../error-log.js";
-import { ok } from "../helpers.js";
+import { ok, err } from "../helpers.js";
 
 function relativeTime(ts) {
   const secs = Math.floor((Date.now() - ts) / 1000);
@@ -23,6 +25,7 @@ export const inputSchema = {};
  * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
  */
 export function handler(_args, ctx) {
+  try {
   const { config } = ctx;
 
   const status = gatherVaultStatus(ctx);
@@ -120,6 +123,18 @@ export function handler(_args, ctx) {
     lines.push(`- Entries: ${logCount} (share this file for support)`);
   }
 
+  // Last startup error
+  const lastErrorPath = join(config.dataDir, ".last-error");
+  if (existsSync(lastErrorPath)) {
+    try {
+      const lastError = readFileSync(lastErrorPath, "utf-8").trim();
+      lines.push(``, `### Last Startup Error`);
+      lines.push(`\`\`\``);
+      lines.push(lastError);
+      lines.push(`\`\`\``);
+    } catch {}
+  }
+
   // Health: session-level tool call stats
   const ts = ctx.toolStats;
   if (ts) {
@@ -178,4 +193,7 @@ export function handler(_args, ctx) {
   }
 
   return ok(lines.join("\n"));
+  } catch (e) {
+    return err(e.message, "STATUS_FAILED");
+  }
 }

package/src/tools/create-snapshot.js

@@ -105,28 +105,32 @@ export async function handler(
 
   let candidates = [];
 
-  if (normalizedKinds.length > 0) {
-    for (const kindFilter of normalizedKinds) {
-      const rows = await hybridSearch(ctx, topic, {
-        kindFilter,
-        limit: Math.ceil(MAX_ENTRIES_FOR_GATHER / normalizedKinds.length),
-        
+  try {
+    if (normalizedKinds.length > 0) {
+      for (const kindFilter of normalizedKinds) {
+        const rows = await hybridSearch(ctx, topic, {
+          kindFilter,
+          limit: Math.ceil(MAX_ENTRIES_FOR_GATHER / normalizedKinds.length),
+
+          includeSuperseeded: false,
+        });
+        candidates.push(...rows);
+      }
+      const seen = new Set();
+      candidates = candidates.filter((r) => {
+        if (seen.has(r.id)) return false;
+        seen.add(r.id);
+        return true;
+      });
+    } else {
+      candidates = await hybridSearch(ctx, topic, {
+        limit: MAX_ENTRIES_FOR_GATHER,
+
         includeSuperseeded: false,
       });
-      candidates.push(...rows);
     }
-    const seen = new Set();
-    candidates = candidates.filter((r) => {
-      if (seen.has(r.id)) return false;
-      seen.add(r.id);
-      return true;
-    });
-  } else {
-    candidates = await hybridSearch(ctx, topic, {
-      limit: MAX_ENTRIES_FOR_GATHER,
-      
-      includeSuperseeded: false,
-    });
+  } catch (e) {
+    return err(e.message, "SEARCH_FAILED");
   }
 
   if (effectiveTags.length) {
@@ -162,22 +166,27 @@ export async function handler(
 
   const supersedes = noiseIds.length > 0 ? noiseIds : undefined;
 
-  const entry = await captureAndIndex(ctx, {
-    kind: "brief",
-    title: `${topic} — Context Brief`,
-    body: briefBody,
-    tags: briefTags,
-    source: "create_snapshot",
-    identity_key: effectiveIdentityKey,
-    supersedes,
-    
-    meta: {
-      topic,
-      entry_count: gatherEntries.length,
-      noise_superseded: noiseIds.length,
-      synthesized_from: gatherEntries.map((e) => e.id),
-    },
-  });
+  let entry;
+  try {
+    entry = await captureAndIndex(ctx, {
+      kind: "brief",
+      title: `${topic} — Context Brief`,
+      body: briefBody,
+      tags: briefTags,
+      source: "create_snapshot",
+      identity_key: effectiveIdentityKey,
+      supersedes,
+
+      meta: {
+        topic,
+        entry_count: gatherEntries.length,
+        noise_superseded: noiseIds.length,
+        synthesized_from: gatherEntries.map((e) => e.id),
+      },
+    });
+  } catch (e) {
+    return err(e.message, "SAVE_FAILED");
+  }
 
   const parts = [
     `✓ Snapshot created → id: ${entry.id}`,

package/src/tools/delete-context.js

@@ -17,7 +17,6 @@ export const inputSchema = {
  * @param {import('../types.js').ToolShared} shared
  */
 export async function handler({ id }, ctx, { ensureIndexed }) {
-
   if (!id?.trim())
     return err("Required: id (non-empty string)", "INVALID_INPUT");
   await ensureIndexed();
@@ -25,34 +24,31 @@ export async function handler({ id }, ctx, { ensureIndexed }) {
   const entry = ctx.stmts.getEntryById.get(id);
   if (!entry) return err(`Entry not found: ${id}`, "NOT_FOUND");
 
-  // Ownership check: don't leak existence across users
-    return err(`Entry not found: ${id}`, "NOT_FOUND");
-  }
-
-  // Delete file from disk first (source of truth)
-  let fileWarning = null;
-  if (entry.file_path) {
-    try {
-      unlinkSync(entry.file_path);
-    } catch (e) {
-      // ENOENT = already gone — not an error worth surfacing
-      if (e.code !== "ENOENT") {
-        fileWarning = `file could not be removed from disk (${e.code}): ${entry.file_path}`;
+  try {
+    // Delete DB record first — if this fails, the file stays and no orphan is created
+    const rowidResult = ctx.stmts.getRowid.get(id);
+    if (rowidResult?.rowid) {
+      try {
+        ctx.deleteVec(Number(rowidResult.rowid));
+      } catch {}
+    }
+    ctx.stmts.deleteEntry.run(id);
+
+    // Delete file from disk after successful DB delete
+    let fileWarning = null;
+    if (entry.file_path) {
+      try {
+        unlinkSync(entry.file_path);
+      } catch (e) {
+        if (e.code !== "ENOENT") {
+          fileWarning = `file could not be removed from disk (${e.code}): ${entry.file_path}`;
+        }
       }
     }
-  }
 
-  // Delete vector embedding
-  const rowidResult = ctx.stmts.getRowid.get(id);
-  if (rowidResult?.rowid) {
-    try {
-      ctx.deleteVec(Number(rowidResult.rowid));
-    } catch {}
+    const msg = `Deleted ${entry.kind}: ${entry.title || "(untitled)"} [${id}]`;
+    return ok(fileWarning ? `${msg}\nWarning: ${fileWarning}` : msg);
+  } catch (e) {
+    return err(e.message, "DELETE_FAILED");
   }
-
-  // Delete DB row (FTS trigger handles FTS cleanup)
-  ctx.stmts.deleteEntry.run(id);
-
-  const msg = `Deleted ${entry.kind}: ${entry.title || "(untitled)"} [${id}]`;
-  return ok(fileWarning ? `${msg}\nWarning: ${fileWarning}` : msg);
 }

package/src/tools/get-context.js

@@ -7,7 +7,7 @@ import { categoryFor } from "@context-vault/core/categories";
 import { normalizeKind } from "@context-vault/core/files";
 import { resolveTemporalParams } from "../temporal.js";
 import { collectLinkedEntries } from "../linking.js";
-import { ok, err } from "../helpers.js";
+import { ok, err, errWithHint } from "../helpers.js";
 import { isEmbedAvailable } from "@context-vault/core/embed";
 
 const STALE_DUPLICATE_DAYS = 7;
@@ -290,7 +290,7 @@ export const inputSchema = {
     .describe(
       "Return entries created before this date. Accepts ISO date strings or the same natural shortcuts as `since`. When `since` is 'yesterday' and `until` is omitted, `until` is automatically set to the end of yesterday.",
     ),
-  limit: z.number().optional().describe("Max results to return (default 10)"),
+  limit: z.number().max(500).optional().describe("Max results to return (default 10)"),
   include_superseded: z
     .boolean()
     .optional()
@@ -305,6 +305,7 @@ export const inputSchema = {
     ),
   max_tokens: z
     .number()
+    .max(100000)
     .optional()
     .describe(
       "Limit output to entries that fit within this token budget (rough estimate: 1 token ≈ 4 chars). Entries are packed greedily by relevance rank. At least 1 result is always returned. Response metadata includes tokens_used and tokens_budget.",
@@ -415,16 +416,7 @@ export async function handler(
   if (identity_key) {
     if (!kindFilter)
       return err("identity_key requires kind to be specified", "INVALID_INPUT");
-    // Local mode: getByIdentityKey takes 2 params (no user_id).
-    // Hosted mode: 3 params — (kind, identity_key).
-    const match =
-      ctx.stmts._mode === "local"
-        ? ctx.stmts.getByIdentityKey.get(kindFilter, identity_key)
-        : ctx.stmts.getByIdentityKey.get(
-            kindFilter,
-            identity_key,
-            null,
-          );
+    const match = ctx.stmts.getByIdentityKey.get(kindFilter, identity_key);
     if (match) {
       const entryTags = match.tags ? JSON.parse(match.tags) : [];
       const tagStr = entryTags.length ? entryTags.join(", ") : "none";
@@ -514,9 +506,18 @@ export async function handler(
     }
     const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
     params.push(fetchLimit);
-    const rows = ctx.db
-      .prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT ?`)
-      .all(...params);
+    let rows;
+    try {
+      rows = ctx.db
+        .prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT ?`)
+        .all(...params);
+    } catch (e) {
+      return errWithHint(
+        e.message,
+        "DB_ERROR",
+        "context-vault get_context DB_ERROR. Check `cat ~/.context-mcp/error.log | tail -5` and help me debug.",
+      );
+    }
 
     // Post-filter by tags if provided, then apply requested limit
     filtered = effectiveTags.length

package/src/tools/list-context.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { normalizeKind } from "@context-vault/core/files";
 import { categoryFor } from "@context-vault/core/categories";
-import { ok } from "../helpers.js";
+import { ok, err, errWithHint } from "../helpers.js";
+import { resolveTemporalParams } from "../temporal.js";
 
 export const name = "list_context";
 
@@ -50,6 +51,10 @@ export async function handler(
 
   await ensureIndexed();
 
+  const resolved = resolveTemporalParams({ since, until });
+  since = resolved.since;
+  until = resolved.until;
+
   const kindFilter = kind ? normalizeKind(kind) : null;
   const effectiveCategory =
     category || (kindFilter ? categoryFor(kindFilter) : null);
@@ -64,8 +69,6 @@ export async function handler(
   const clauses = [];
   const params = [];
 
-  if (false) {
-  }
   if (kindFilter) {
     clauses.push("kind = ?");
     params.push(kindFilter);
@@ -91,16 +94,26 @@ export async function handler(
   const fetchLimit = tags?.length ? effectiveLimit * 10 : effectiveLimit;
 
   const countParams = [...params];
-  const total = ctx.db
-    .prepare(`SELECT COUNT(*) as c FROM vault ${where}`)
-    .get(...countParams).c;
-
-  params.push(fetchLimit, effectiveOffset);
-  const rows = ctx.db
-    .prepare(
-      `SELECT id, title, kind, category, tags, created_at, updated_at, SUBSTR(body, 1, 120) as preview FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
-    )
-    .all(...params);
+  let total;
+  let rows;
+  try {
+    total = ctx.db
+      .prepare(`SELECT COUNT(*) as c FROM vault ${where}`)
+      .get(...countParams).c;
+
+    params.push(fetchLimit, effectiveOffset);
+    rows = ctx.db
+      .prepare(
+        `SELECT id, title, kind, category, tags, created_at, updated_at, SUBSTR(body, 1, 120) as preview FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+      )
+      .all(...params);
+  } catch (e) {
+    return errWithHint(
+      e.message,
+      "DB_ERROR",
+      "context-vault list_context DB_ERROR. Check `cat ~/.context-mcp/error.log | tail -5` and help me debug.",
+    );
+  }
 
   // Post-filter by tags if provided, then apply requested limit
   const filtered = tags?.length

package/src/tools/save-context.js

@@ -3,7 +3,7 @@ import { captureAndIndex, updateEntryFile } from "@context-vault/core/capture";
 import { indexEntry } from "@context-vault/core/index";
 import { categoryFor, defaultTierFor } from "@context-vault/core/categories";
 import { normalizeKind } from "@context-vault/core/files";
-import { ok, err, ensureVaultExists, ensureValidKind } from "../helpers.js";
+import { ok, err, errWithHint, ensureVaultExists, ensureValidKind } from "../helpers.js";
 import { maybeShowFeedbackPrompt } from "../telemetry.js";
 import { validateRelatedTo } from "../linking.js";
 import {
@@ -319,12 +319,6 @@ export const inputSchema = {
     .describe(
       "Source code files this entry is derived from. When these files change (hash mismatch), the entry will be flagged as stale in get_context results.",
     ),
-  tier: z
-    .enum(["ephemeral", "working", "durable"])
-    .optional()
-    .describe(
-      "Memory tier for lifecycle management. 'ephemeral': short-lived session data. 'working': active context (default). 'durable': long-term reference material. Defaults based on kind when not specified.",
-    ),
   dry_run: z
     .boolean()
     .optional()
@@ -409,10 +403,6 @@ export async function handler(
     const existing = ctx.stmts.getEntryById.get(id);
     if (!existing) return err(`Entry not found: ${id}`, "NOT_FOUND");
 
-    // Ownership check: don't leak existence across users
-      return err(`Entry not found: ${id}`, "NOT_FOUND");
-    }
-
     if (kind && normalizeKind(kind) !== existing.kind) {
       return err(
         `Cannot change kind (current: "${existing.kind}"). Delete and re-create instead.`,
@@ -434,18 +424,27 @@ export async function handler(
       if (decrypted.meta) existing.meta = JSON.stringify(decrypted.meta);
     }
 
-    const entry = updateEntryFile(ctx, existing, {
-      title,
-      body,
-      tags,
-      meta,
-      source,
-      expires_at,
-      supersedes,
-      related_to,
-      source_files,
-    });
-    await indexEntry(ctx, entry);
+    let entry;
+    try {
+      entry = updateEntryFile(ctx, existing, {
+        title,
+        body,
+        tags,
+        meta,
+        source,
+        expires_at,
+        supersedes,
+        related_to,
+        source_files,
+      });
+      await indexEntry(ctx, entry);
+    } catch (e) {
+      return errWithHint(
+        e.message,
+        "UPDATE_FAILED",
+        "context-vault save_context update is failing. Check `cat ~/.context-mcp/error.log | tail -5` and help me debug.",
+      );
+    }
     if (entry.related_to?.length && ctx.stmts.updateRelatedTo) {
       ctx.stmts.updateRelatedTo.run(JSON.stringify(entry.related_to), entry.id);
     } else if (entry.related_to === null && ctx.stmts.updateRelatedTo) {
@@ -484,17 +483,22 @@ export async function handler(
   // ── Similarity check (knowledge + event only) ────────────────────────────
   const category = categoryFor(normalizedKind);
   let similarEntries = [];
+  let queryEmbedding = null;
 
   if (category === "knowledge" || category === "event") {
     const threshold = similarity_threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
     const embeddingText = [title, body].filter(Boolean).join(" ");
-    const queryEmbedding = await ctx.embed(embeddingText);
+    try {
+      queryEmbedding = await ctx.embed(embeddingText);
+    } catch {
+      queryEmbedding = null;
+    }
     if (queryEmbedding) {
       similarEntries = await findSimilar(
         ctx,
         queryEmbedding,
         threshold,
-        
+
         { hydrate: suggestMode },
       );
     }
@@ -540,22 +544,29 @@ export async function handler(
 
   const effectiveTier = tier ?? defaultTierFor(normalizedKind);
 
-  const entry = await captureAndIndex(ctx, {
-    kind: normalizedKind,
-    title,
-    body,
-    meta: finalMeta,
-    tags,
-    source,
-    folder,
-    identity_key,
-    expires_at,
-    supersedes,
-    related_to,
-    source_files,
-    
-    tier: effectiveTier,
-  });
+  const embeddingToReuse = category === "knowledge" ? queryEmbedding : null;
+
+  let entry;
+  try {
+    entry = await captureAndIndex(ctx, {
+      kind: normalizedKind,
+      title,
+      body,
+      meta: finalMeta,
+      tags,
+      source,
+      folder,
+      identity_key,
+      expires_at,
+      supersedes,
+      related_to,
+      source_files,
+
+      tier: effectiveTier,
+    }, embeddingToReuse);
+  } catch (e) {
+    return errWithHint(e.message, "SAVE_FAILED", "context-vault save_context is failing. Check `cat ~/.context-mcp/error.log | tail -5` and help me debug.");
+  }
 
   if (ctx.config?.dataDir) {
     maybeShowFeedbackPrompt(ctx.config.dataDir);
@@ -610,12 +621,8 @@ export async function handler(
   if (criticalLimit != null) {
     try {
       const countRow = ctx.db
-        .prepare(
-          false
-            
-            : "SELECT COUNT(*) as c FROM vault",
-        )
-        .get(...([]));
+        .prepare("SELECT COUNT(*) as c FROM vault")
+        .get();
       if (countRow.c >= criticalLimit) {
         parts.push(
           ``,