context-vault 2.2.0 → 2.4.0

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

@@ -28,19 +28,23 @@ function buildFtsQuery(query) {
  *   knowledge + entity: no decay (enduring)
  *   event: steeper decay (~0.5 at 30 days)
  */
-function recencyBoost(createdAt, category) {
+function recencyBoost(createdAt, category, decayDays = 30) {
   if (category !== "event") return 1.0;
   const ageDays = (Date.now() - new Date(createdAt).getTime()) / 86400000;
-  return 1 / (1 + ageDays / 30);
+  return 1 / (1 + ageDays / decayDays);
 }
 
 /**
  * Build additional WHERE clauses for category/time filtering.
  * Returns { clauses: string[], params: any[] }
  */
-function buildFilterClauses({ categoryFilter, since, until }) {
+function buildFilterClauses({ categoryFilter, since, until, userIdFilter }) {
   const clauses = [];
   const params = [];
+  if (userIdFilter !== undefined) {
+    clauses.push("e.user_id = ?");
+    params.push(userIdFilter);
+  }
   if (categoryFilter) {
     clauses.push("e.category = ?");
     params.push(categoryFilter);
@@ -68,10 +72,10 @@ function buildFilterClauses({ categoryFilter, since, until }) {
 export async function hybridSearch(
   ctx,
   query,
-  { kindFilter = null, categoryFilter = null, since = null, until = null, limit = 20, offset = 0 } = {}
+  { kindFilter = null, categoryFilter = null, since = null, until = null, limit = 20, offset = 0, decayDays = 30, userIdFilter } = {}
 ) {
   const results = new Map();
-  const extraFilters = buildFilterClauses({ categoryFilter, since, until });
+  const extraFilters = buildFilterClauses({ categoryFilter, since, until, userIdFilter });
 
   // FTS5 search
   const ftsQuery = buildFtsQuery(query);
@@ -108,49 +112,54 @@ export async function hybridSearch(
     }
   }
 
-  // Vector similarity search
+  // Vector similarity search (skipped if embedding unavailable)
   try {
     const vecCount = ctx.db
       .prepare("SELECT COUNT(*) as c FROM vault_vec")
       .get().c;
     if (vecCount > 0) {
       const queryVec = await ctx.embed(query);
-      const vecLimit = kindFilter ? 30 : 15;
-      const vecRows = ctx.db
-        .prepare(
-          `SELECT v.rowid, v.distance FROM vault_vec v WHERE embedding MATCH ? ORDER BY distance LIMIT ${vecLimit}`
-        )
-        .all(queryVec);
-
-      if (vecRows.length) {
-        // Batch hydration: single query instead of N+1
-        const rowids = vecRows.map((vr) => vr.rowid);
-        const placeholders = rowids.map(() => "?").join(",");
-        const hydrated = ctx.db
-          .prepare(`SELECT rowid, * FROM vault WHERE rowid IN (${placeholders})`)
-          .all(...rowids);
-
-        const byRowid = new Map();
-        for (const row of hydrated) byRowid.set(row.rowid, row);
-
-        for (const vr of vecRows) {
-          const row = byRowid.get(vr.rowid);
-          if (!row) continue;
-          if (kindFilter && row.kind !== kindFilter) continue;
-          if (categoryFilter && row.category !== categoryFilter) 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()) continue;
-
-          const { rowid: _rowid, ...cleanRow } = row;
-          // sqlite-vec returns L2 distance [0, 2] for normalized vectors.
-          // Convert to similarity [1, 0] with: 1 - distance/2
-          const vecScore = Math.max(0, 1 - vr.distance / 2) * VEC_WEIGHT;
-          const existing = results.get(cleanRow.id);
-          if (existing) {
-            existing.score += vecScore;
-          } else {
-            results.set(cleanRow.id, { ...cleanRow, score: vecScore });
+      if (queryVec) {
+        // Increase limits in hosted mode to compensate for post-filtering
+        const hasUserFilter = userIdFilter !== undefined;
+        const vecLimit = hasUserFilter ? (kindFilter ? 60 : 30) : (kindFilter ? 30 : 15);
+        const vecRows = ctx.db
+          .prepare(
+            `SELECT v.rowid, v.distance FROM vault_vec v WHERE embedding MATCH ? ORDER BY distance LIMIT ${vecLimit}`
+          )
+          .all(queryVec);
+
+        if (vecRows.length) {
+          // Batch hydration: single query instead of N+1
+          const rowids = vecRows.map((vr) => vr.rowid);
+          const placeholders = rowids.map(() => "?").join(",");
+          const hydrated = ctx.db
+            .prepare(`SELECT rowid, * FROM vault WHERE rowid IN (${placeholders})`)
+            .all(...rowids);
+
+          const byRowid = new Map();
+          for (const row of hydrated) byRowid.set(row.rowid, row);
+
+          for (const vr of vecRows) {
+            const row = byRowid.get(vr.rowid);
+            if (!row) continue;
+            if (userIdFilter !== undefined && row.user_id !== userIdFilter) continue;
+            if (kindFilter && row.kind !== kindFilter) continue;
+            if (categoryFilter && row.category !== categoryFilter) 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()) continue;
+
+            const { rowid: _rowid, ...cleanRow } = row;
+            // sqlite-vec returns L2 distance [0, 2] for normalized vectors.
+            // Convert to similarity [1, 0] with: 1 - distance/2
+            const vecScore = Math.max(0, 1 - vr.distance / 2) * VEC_WEIGHT;
+            const existing = results.get(cleanRow.id);
+            if (existing) {
+              existing.score += vecScore;
+            } else {
+              results.set(cleanRow.id, { ...cleanRow, score: vecScore });
+            }
           }
         }
       }
@@ -165,7 +174,7 @@ export async function hybridSearch(
 
   // Apply category-aware recency boost
   for (const [, entry] of results) {
-    entry.score *= recencyBoost(entry.created_at, entry.category);
+    entry.score *= recencyBoost(entry.created_at, entry.category, decayDays);
   }
 
   const sorted = [...results.values()].sort((a, b) => b.score - a.score);

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

@@ -1,8 +1,8 @@
 /**
  * tools.js — MCP tool registrations
  *
- * Five tools: save_context (write/update), get_context (search), list_context (browse),
- * delete_context (remove), context_status (diag).
+ * Six tools: save_context (write/update), get_context (search), list_context (browse),
+ * delete_context (remove), submit_feedback (bug/feature reports), context_status (diag).
  * Auto-reindex runs transparently on first tool call per session.
  */
 
@@ -25,10 +25,12 @@ import { ok, err, ensureVaultExists, ensureValidKind } from "./helpers.js";
  */
 export function registerTools(server, ctx) {
   const { config } = ctx;
+  const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
   // ─── Auto-Reindex (runs once per session, on first tool call) ──────────────
 
-  let reindexDone = false;
+  // In hosted mode, skip reindex — DB is always in sync via writeEntry→indexEntry
+  let reindexDone = userId !== undefined ? true : false;
   let reindexPromise = null;
   let reindexAttempts = 0;
   let reindexFailed = false;
@@ -63,52 +65,132 @@ export function registerTools(server, ctx) {
 
   server.tool(
     "get_context",
-    "Search your knowledge vault. Returns entries ranked by relevance using hybrid full-text + semantic search. Use this to find insights, decisions, patterns, or any saved context.",
+    "Search your knowledge vault. Returns entries ranked by relevance using hybrid full-text + semantic search. Use this to find insights, decisions, patterns, or any saved context. Each result includes an `id` you can use with save_context or delete_context.",
     {
-      query: z.string().describe("Search query (natural language or keywords)"),
+      query: z.string().optional().describe("Search query (natural language or keywords). Optional if filters (tags, kind, category) are provided."),
       kind: z.string().optional().describe("Filter by kind (e.g. 'insight', 'decision', 'pattern')"),
       category: z.enum(["knowledge", "entity", "event"]).optional().describe("Filter by category"),
+      identity_key: z.string().optional().describe("For entity lookup: exact match on identity key. Requires kind."),
       tags: z.array(z.string()).optional().describe("Filter by tags (entries must match at least one)"),
       since: z.string().optional().describe("ISO date, return entries created after this"),
       until: z.string().optional().describe("ISO date, return entries created before this"),
       limit: z.number().optional().describe("Max results to return (default 10)"),
     },
-    async ({ query, kind, category, tags, since, until, limit }) => {
-      if (!query?.trim()) return err("Required: query (non-empty string)", "INVALID_INPUT");
+    async ({ query, kind, category, identity_key, tags, since, until, limit }) => {
+      const hasQuery = query?.trim();
+      const hasFilters = kind || category || tags?.length || since || until || identity_key;
+      if (!hasQuery && !hasFilters) return err("Required: query or at least one filter (kind, category, tags, since, until, identity_key)", "INVALID_INPUT");
       await ensureIndexed();
 
       const kindFilter = kind ? normalizeKind(kind) : null;
-      const sorted = await hybridSearch(ctx, query, {
-        kindFilter,
-        categoryFilter: category || null,
-        since: since || null,
-        until: until || null,
-        limit: limit || 10,
-      });
 
-      // Post-filter by tags if provided
-      const filtered = tags?.length
-        ? sorted.filter((r) => {
-            const entryTags = r.tags ? JSON.parse(r.tags) : [];
-            return tags.some((t) => entryTags.includes(t));
-          })
-        : sorted;
+      // Gap 1: Entity exact-match by identity_key
+      if (identity_key) {
+        if (!kindFilter) return err("identity_key requires kind to be specified", "INVALID_INPUT");
+        const match = ctx.stmts.getByIdentityKey.get(kindFilter, identity_key, userId !== undefined ? userId : null);
+        if (match) {
+          const entryTags = match.tags ? JSON.parse(match.tags) : [];
+          const tagStr = entryTags.length ? entryTags.join(", ") : "none";
+          const relPath = match.file_path && config.vaultDir ? match.file_path.replace(config.vaultDir + "/", "") : match.file_path || "n/a";
+          const lines = [
+            `## Entity Match (exact)\n`,
+            `### ${match.title || "(untitled)"} [${match.kind}/${match.category}]`,
+            `1.000 · ${tagStr} · ${relPath} · id: \`${match.id}\``,
+            match.body?.slice(0, 300) + (match.body?.length > 300 ? "..." : ""),
+          ];
+          return ok(lines.join("\n"));
+        }
+        // Fall through to semantic search as fallback
+      }
 
-      if (!filtered.length) return ok("No results found for: " + query);
+      // Gap 2: Event default time-window
+      const effectiveCategory = category || (kindFilter ? categoryFor(kindFilter) : null);
+      let effectiveSince = since || null;
+      let effectiveUntil = until || null;
+      let autoWindowed = false;
+      if (effectiveCategory === "event" && !since && !until) {
+        const decayMs = (config.eventDecayDays || 30) * 86400000;
+        effectiveSince = new Date(Date.now() - decayMs).toISOString();
+        autoWindowed = true;
+      }
+
+      let filtered;
+      if (hasQuery) {
+        // Hybrid search mode
+        const sorted = await hybridSearch(ctx, query, {
+          kindFilter,
+          categoryFilter: category || null,
+          since: effectiveSince,
+          until: effectiveUntil,
+          limit: limit || 10,
+          decayDays: config.eventDecayDays || 30,
+          userIdFilter: userId,
+        });
+
+        // Post-filter by tags if provided
+        filtered = tags?.length
+          ? sorted.filter((r) => {
+              const entryTags = r.tags ? JSON.parse(r.tags) : [];
+              return tags.some((t) => entryTags.includes(t));
+            })
+          : sorted;
+      } else {
+        // Filter-only mode (no query, use SQL directly)
+        const clauses = [];
+        const params = [];
+        if (userId !== undefined) { clauses.push("user_id = ?"); params.push(userId); }
+        if (kindFilter) { clauses.push("kind = ?"); params.push(kindFilter); }
+        if (category) { clauses.push("category = ?"); params.push(category); }
+        if (effectiveSince) { clauses.push("created_at >= ?"); params.push(effectiveSince); }
+        if (effectiveUntil) { clauses.push("created_at <= ?"); params.push(effectiveUntil); }
+        clauses.push("(expires_at IS NULL OR expires_at > datetime('now'))");
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const effectiveLimit = limit || 10;
+        params.push(effectiveLimit);
+        const rows = ctx.db.prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT ?`).all(...params);
+
+        filtered = tags?.length
+          ? rows.filter((r) => {
+              const entryTags = r.tags ? JSON.parse(r.tags) : [];
+              return tags.some((t) => entryTags.includes(t));
+            })
+          : rows;
+
+        // Add score field for consistent output
+        for (const r of filtered) r.score = 0;
+      }
+
+      if (!filtered.length) 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) {
+        for (const r of filtered) {
+          if (r.body_encrypted) {
+            const decrypted = await ctx.decrypt(r);
+            r.body = decrypted.body;
+            if (decrypted.title) r.title = decrypted.title;
+            if (decrypted.meta) r.meta = JSON.stringify(decrypted.meta);
+          }
+        }
+      }
 
       const lines = [];
       if (reindexFailed) lines.push(`> **Warning:** Auto-reindex failed. Results may be stale. Run \`context-mcp reindex\` to fix.\n`);
-      lines.push(`## Results for "${query}" (${filtered.length} matches)\n`);
+      const heading = hasQuery ? `Results for "${query}"` : "Filtered entries";
+      lines.push(`## ${heading} (${filtered.length} matches)\n`);
       for (let i = 0; i < filtered.length; i++) {
         const r = filtered[i];
         const entryTags = r.tags ? JSON.parse(r.tags) : [];
         const tagStr = entryTags.length ? entryTags.join(", ") : "none";
         const relPath = r.file_path && config.vaultDir ? r.file_path.replace(config.vaultDir + "/", "") : r.file_path || "n/a";
         lines.push(`### [${i + 1}/${filtered.length}] ${r.title || "(untitled)"} [${r.kind}/${r.category}]`);
-        lines.push(`${r.score.toFixed(3)} · ${tagStr} · ${relPath}`);
+        lines.push(`${r.score.toFixed(3)} · ${tagStr} · ${relPath} · id: \`${r.id}\``);
         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"));
     }
   );
@@ -117,7 +199,7 @@ export function registerTools(server, ctx) {
 
   server.tool(
     "save_context",
-    "Save knowledge to your vault. Creates a .md file and indexes it for search. Use for any kind of context: insights, decisions, patterns, references, or any custom kind.",
+    "Save knowledge to your vault. Creates a .md file and indexes it for search. Use for any kind of context: insights, decisions, patterns, references, or any custom kind. To update an existing entry, pass its `id` — omitted fields are preserved.",
     {
       id: z.string().optional().describe("Entry ULID to update. When provided, updates the existing entry instead of creating new. Omitted fields are preserved."),
       kind: z.string().optional().describe("Entry kind — determines folder (e.g. 'insight', 'decision', 'pattern', 'reference', or any custom kind). Required for new entries."),
@@ -141,6 +223,11 @@ export function registerTools(server, ctx) {
         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
+        if (userId !== undefined && existing.user_id !== userId) {
+          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.`, "INVALID_UPDATE");
         }
@@ -148,6 +235,14 @@ export function registerTools(server, ctx) {
           return err(`Cannot change identity_key (current: "${existing.identity_key}"). Delete and re-create instead.`, "INVALID_UPDATE");
         }
 
+        // Decrypt existing entry before merge if encrypted
+        if (ctx.decrypt && existing.body_encrypted) {
+          const decrypted = await ctx.decrypt(existing);
+          existing.body = decrypted.body;
+          if (decrypted.title) existing.title = decrypted.title;
+          if (decrypted.meta) existing.meta = JSON.stringify(decrypted.meta);
+        }
+
         const entry = updateEntryFile(ctx, existing, { title, body, tags, meta, source, expires_at });
         await indexEntry(ctx, entry);
         const relPath = entry.filePath ? entry.filePath.replace(config.vaultDir + "/", "") : entry.filePath;
@@ -155,6 +250,7 @@ export function registerTools(server, ctx) {
         if (entry.title) parts.push(`  title: ${entry.title}`);
         const entryTags = entry.tags || [];
         if (entryTags.length) parts.push(`  tags: ${entryTags.join(", ")}`);
+        parts.push("", "_Search with get_context to verify changes._");
         return ok(parts.join("\n"));
       }
 
@@ -174,11 +270,12 @@ export function registerTools(server, ctx) {
       if (folder) mergedMeta.folder = folder;
       const finalMeta = Object.keys(mergedMeta).length ? mergedMeta : undefined;
 
-      const entry = await captureAndIndex(ctx, { kind, title, body, meta: finalMeta, tags, source, folder, identity_key, expires_at }, indexEntry);
+      const entry = await captureAndIndex(ctx, { kind, title, body, meta: finalMeta, tags, source, folder, identity_key, expires_at, userId }, indexEntry);
       const relPath = entry.filePath ? entry.filePath.replace(config.vaultDir + "/", "") : entry.filePath;
       const parts = [`✓ Saved ${kind} → ${relPath}`, `  id: ${entry.id}`];
       if (title) parts.push(`  title: ${title}`);
       if (tags?.length) parts.push(`  tags: ${tags.join(", ")}`);
+      parts.push("", "_Use this id to update or delete later._");
       return ok(parts.join("\n"));
     }
   );
@@ -187,7 +284,7 @@ export function registerTools(server, ctx) {
 
   server.tool(
     "list_context",
-    "Browse vault entries without a search query. Returns id, title, kind, category, tags, created_at. Use get_context with a query for semantic search.",
+    "Browse vault entries without a search query. Returns id, title, kind, category, tags, created_at. Use get_context with a query for semantic search. Use this to browse by tags or find recent entries.",
     {
       kind: z.string().optional().describe("Filter by kind (e.g. 'insight', 'decision', 'pattern')"),
       category: z.enum(["knowledge", "entity", "event"]).optional().describe("Filter by category"),
@@ -203,6 +300,10 @@ export function registerTools(server, ctx) {
       const clauses = [];
       const params = [];
 
+      if (userId !== undefined) {
+        clauses.push("user_id = ?");
+        params.push(userId);
+      }
       if (kind) {
         clauses.push("kind = ?");
         params.push(normalizeKind(kind));
@@ -229,7 +330,7 @@ export function registerTools(server, ctx) {
       const total = ctx.db.prepare(`SELECT COUNT(*) as c FROM vault ${where}`).get(...countParams).c;
 
       params.push(effectiveLimit, effectiveOffset);
-      const rows = ctx.db.prepare(`SELECT id, title, kind, category, tags, created_at FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params);
+      const rows = ctx.db.prepare(`SELECT id, title, kind, category, tags, created_at, SUBSTR(body, 1, 120) as preview FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params);
 
       // Post-filter by tags if provided
       const filtered = tags?.length
@@ -246,6 +347,7 @@ export function registerTools(server, ctx) {
         const entryTags = r.tags ? JSON.parse(r.tags) : [];
         const tagStr = entryTags.length ? entryTags.join(", ") : "none";
         lines.push(`- **${r.title || "(untitled)"}** [${r.kind}/${r.category}] — ${tagStr} — ${r.created_at} — \`${r.id}\``);
+        if (r.preview) lines.push(`  ${r.preview.replace(/\n+/g, " ").trim()}${r.preview.length >= 120 ? "…" : ""}`);
       }
 
       if (effectiveOffset + effectiveLimit < total) {
@@ -271,6 +373,11 @@ export function registerTools(server, ctx) {
       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
+      if (userId !== undefined && entry.user_id !== userId) {
+        return err(`Entry not found: ${id}`, "NOT_FOUND");
+      }
+
       // Delete file from disk first (source of truth)
       if (entry.file_path) {
         try { unlinkSync(entry.file_path); } catch {}
@@ -289,14 +396,51 @@ export function registerTools(server, ctx) {
     }
   );
 
+  // ─── submit_feedback (bug/feature reports) ────────────────────────────────
+
+  server.tool(
+    "submit_feedback",
+    "Report a bug, request a feature, or suggest an improvement. Feedback is stored in the vault and triaged by the development pipeline.",
+    {
+      type: z.enum(["bug", "feature", "improvement"]).describe("Type of feedback"),
+      title: z.string().describe("Short summary of the feedback"),
+      body: z.string().describe("Detailed description"),
+      severity: z.enum(["low", "medium", "high"]).optional().describe("Severity level (default: medium)"),
+    },
+    async ({ type, title, body, severity }) => {
+      const vaultErr = ensureVaultExists(config);
+      if (vaultErr) return vaultErr;
+
+      await ensureIndexed();
+
+      const effectiveSeverity = severity || "medium";
+      const entry = await captureAndIndex(
+        ctx,
+        {
+          kind: "feedback",
+          title,
+          body,
+          tags: [type, effectiveSeverity],
+          source: "submit_feedback",
+          meta: { feedback_type: type, severity: effectiveSeverity, status: "new" },
+          userId,
+        },
+        indexEntry
+      );
+
+      const relPath = entry.filePath ? entry.filePath.replace(config.vaultDir + "/", "") : entry.filePath;
+      return ok(`Feedback submitted: ${type} [${effectiveSeverity}] → ${relPath}\n  id: ${entry.id}\n  title: ${title}`);
+    }
+  );
+
   // ─── context_status (diagnostics) ──────────────────────────────────────────
 
   server.tool(
     "context_status",
-    "Show vault health: resolved config, file counts per kind, database size, and any issues. Use to verify setup or troubleshoot.",
+    "Show vault health: resolved config, file counts per kind, database size, and any issues. Use to verify setup or troubleshoot. Call this when a user asks about their vault or to debug search issues.",
     {},
     () => {
-      const status = gatherVaultStatus(ctx);
+      const status = gatherVaultStatus(ctx, { userId });
 
       const hasIssues = status.stalePaths || (status.embeddingStatus?.missing > 0);
       const healthIcon = hasIssues ? "⚠" : "✓";
@@ -310,7 +454,7 @@ export function registerTools(server, ctx) {
         `Data dir:  ${config.dataDir}`,
         `Config:    ${config.configPath}`,
         `Resolved via: ${status.resolvedFrom}`,
-        `Schema:    v5 (categories)`,
+        `Schema:    v6 (multi-tenancy)`,
       ];
 
       if (status.embeddingStatus) {
@@ -318,6 +462,15 @@ export function registerTools(server, ctx) {
         const pct = total > 0 ? Math.round((indexed / total) * 100) : 100;
         lines.push(`Embeddings: ${indexed}/${total} (${pct}%)`);
       }
+      if (status.embedModelAvailable === false) {
+        lines.push(`Embed model: unavailable (semantic search disabled, FTS still works)`);
+      } else if (status.embedModelAvailable === true) {
+        lines.push(`Embed model: loaded`);
+      }
+      lines.push(`Decay:     ${config.eventDecayDays} days (event recency window)`);
+      if (status.expiredCount > 0) {
+        lines.push(`Expired:   ${status.expiredCount} entries (pruned on next reindex)`);
+      }
 
       lines.push(``, `### Indexed`);
 
@@ -346,6 +499,17 @@ export function registerTools(server, ctx) {
         lines.push(`Auto-reindex will fix this on next search or save.`);
       }
 
+      // Suggested actions
+      const actions = [];
+      if (status.stalePaths) actions.push("- Run `context-mcp reindex` to fix stale paths");
+      if (status.embeddingStatus?.missing > 0) actions.push("- Run `context-mcp reindex` to generate missing embeddings");
+      if (!config.vaultDirExists) actions.push("- Run `context-mcp setup` to create the vault directory");
+      if (status.kindCounts.length === 0 && config.vaultDirExists) actions.push("- Use `save_context` to add your first entry");
+
+      if (actions.length) {
+        lines.push("", "### Suggested Actions", ...actions);
+      }
+
       return ok(lines.join("\n"));
     }
   );

package/package.json

@@ -1,37 +1,37 @@
 {
   "name": "context-vault",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "type": "module",
   "description": "Persistent memory for AI agents — saves and searches knowledge across sessions",
   "bin": {
     "context-mcp": "bin/cli.js"
   },
   "main": "src/server/index.js",
+  "exports": {
+    ".": "./src/server/index.js",
+    "./cli": "./bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "prepack": "node scripts/prepack.js"
+  },
   "files": [
     "bin/",
     "src/",
+    "scripts/",
     "ui/",
     "README.md",
-    "LICENSE",
-    "smithery.yaml"
+    "LICENSE"
   ],
   "license": "MIT",
   "engines": { "node": ">=20" },
   "author": "Felix Hellstrom",
-  "repository": { "type": "git", "url": "https://github.com/fellanH/context-mcp.git" },
+  "repository": { "type": "git", "url": "git+https://github.com/fellanH/context-mcp.git" },
   "homepage": "https://github.com/fellanH/context-mcp",
+  "bugs": { "url": "https://github.com/fellanH/context-mcp/issues" },
   "keywords": ["mcp", "model-context-protocol", "ai", "knowledge-base", "knowledge-management", "vault", "rag", "sqlite", "embeddings", "claude", "cursor", "cline", "windsurf"],
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
-  "devDependencies": {
-    "vitest": "^3.0.0"
-  },
+  "bundledDependencies": ["@context-vault/core"],
   "dependencies": {
-    "@huggingface/transformers": "^3.0.0",
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "better-sqlite3": "^12.6.2",
-    "sqlite-vec": "^0.1.0"
+    "@context-vault/core": "^2.4.0"
   }
 }

package/scripts/postinstall.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+/**
+ * postinstall.js — Auto-rebuild native modules on install
+ *
+ * Detects NODE_MODULE_VERSION mismatches and attempts a rebuild.
+ */
+
+import { execSync } from "node:child_process";
+
+async function main() {
+  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");
+    }
+  }
+}
+
+main().catch(() => {});

package/scripts/prepack.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+/**
+ * prepack.js — Cross-platform bundle preparation
+ *
+ * Copies @context-vault/core into node_modules for npm pack bundling.
+ * Replaces the Unix shell script in package.json "prepack".
+ */
+
+import { cpSync, rmSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const LOCAL_ROOT = join(__dirname, "..");
+const CORE_SRC = join(LOCAL_ROOT, "..", "core");
+const CORE_DEST = join(LOCAL_ROOT, "node_modules", "@context-vault", "core");
+
+// Ensure target directory exists
+mkdirSync(join(LOCAL_ROOT, "node_modules", "@context-vault"), { recursive: true });
+
+// Remove old copy if present
+rmSync(CORE_DEST, { recursive: true, force: true });
+
+// Copy core package (dereference symlinks)
+cpSync(CORE_SRC, CORE_DEST, { recursive: true, dereference: true });
+
+// Remove nested node_modules from the copy
+rmSync(join(CORE_DEST, "node_modules"), { recursive: true, force: true });
+
+console.log("[prepack] Bundled @context-vault/core into node_modules");