@context-vault/core 2.8.14 → 2.8.16

package/package.json

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

package/src/index/embed.js

@@ -11,10 +11,10 @@ import { mkdirSync } from "node:fs";
 
 let extractor = null;
 
-/** @type {null | true | false} null = unknown, true = working, false = failed */
+/** @type {null | true | false} null = uninitialized/retry, true = ready, false = permanently failed */
 let embedAvailable = null;
 
-/** Shared promise for in-flight initialization — prevents concurrent loads */
+/** In-flight load promise — coalesces concurrent callers onto a single pipeline() call */
 let loadingPromise = null;
 
 async function ensurePipeline() {
@@ -99,9 +99,9 @@ export async function embedBatch(texts) {
       `Unexpected embedding dimension: ${result.data.length} / ${texts.length} = ${dim}`,
     );
   }
-  return texts.map(
-    (_, i) => new Float32Array(result.data.buffer, i * dim * 4, dim),
-  );
+  // subarray() creates a view into result.data's index-space, correctly
+  // accounting for any non-zero byteOffset on the source typed array.
+  return texts.map((_, i) => result.data.subarray(i * dim, (i + 1) * dim));
 }
 
 /** Force re-initialization on next embed call. */

package/src/index/index.js

@@ -49,6 +49,11 @@ export async function indexEntry(
     userId,
   },
 ) {
+  // Don't index entries that have already expired
+  if (expires_at && new Date(expires_at) <= new Date()) {
+    return;
+  }
+
   const tagsJson = tags ? JSON.stringify(tags) : null;
   const metaJson = meta ? JSON.stringify(meta) : null;
   const cat = category || categoryFor(kind);
@@ -239,8 +244,7 @@ export async function reindex(ctx, opts = {}) {
   // Phase 1: Sync DB ops in a transaction — FTS is searchable immediately after COMMIT.
   // Phase 2: Async embedding runs post-transaction so it can't hold the write lock
   //          or roll back DB state on failure.
-  const pendingEmbeds = []; // { rowid, text }
-  const staleVecRowids = []; // rowids whose old vectors need deleting before re-embed
+  const pendingEmbeds = []; // { rowid, text, isUpdate }
 
   ctx.db.exec("BEGIN");
   try {
@@ -347,11 +351,14 @@ export async function reindex(ctx, opts = {}) {
             if (bodyChanged || titleChanged) {
               const rowid = ctx.stmts.getRowid.get(existing.id)?.rowid;
               if (rowid) {
-                staleVecRowids.push(rowid);
                 const embeddingText = [parsed.title, parsed.body]
                   .filter(Boolean)
                   .join(" ");
-                pendingEmbeds.push({ rowid, text: embeddingText });
+                pendingEmbeds.push({
+                  rowid,
+                  text: embeddingText,
+                  isUpdate: true,
+                });
               }
             }
             stats.updated++;
@@ -433,20 +440,16 @@ export async function reindex(ctx, opts = {}) {
 
   // Phase 2: Async embedding — runs after COMMIT so FTS is already searchable.
   // Failures here are non-fatal; semantic search catches up on next reindex.
-
-  // Delete stale vectors for updated entries before re-embedding
-  for (const rowid of staleVecRowids) {
-    try {
-      ctx.deleteVec(rowid);
-    } catch {}
-  }
-
-  // Batch embed all pending texts
+  // Vec delete happens atomically with insert (only on success) to avoid
+  // leaving entries permanently without vectors if embedBatch() fails mid-batch.
   for (let i = 0; i < pendingEmbeds.length; i += EMBED_BATCH_SIZE) {
     const batch = pendingEmbeds.slice(i, i + EMBED_BATCH_SIZE);
     const embeddings = await embedBatch(batch.map((e) => e.text));
     for (let j = 0; j < batch.length; j++) {
       if (embeddings[j]) {
+        try {
+          ctx.deleteVec(batch[j].rowid);
+        } catch {}
         ctx.insertVec(batch[j].rowid, embeddings[j]);
       }
     }

package/src/server/helpers.js

@@ -13,7 +13,7 @@ export function err(text, code = "UNKNOWN") {
 export function ensureVaultExists(config) {
   if (!config.vaultDirExists) {
     return err(
-      `Vault directory not found: ${config.vaultDir}. Run context_status for diagnostics.`,
+      `Vault directory not found: ${config.vaultDir}. Run context-status for diagnostics.`,
       "VAULT_NOT_FOUND",
     );
   }

package/src/server/tools/delete-context.js

@@ -32,10 +32,16 @@ export async function handler({ id }, ctx, { ensureIndexed }) {
   }
 
   // Delete file from disk first (source of truth)
+  let fileWarning = null;
   if (entry.file_path) {
     try {
       unlinkSync(entry.file_path);
-    } catch {}
+    } 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}`;
+      }
+    }
   }
 
   // Delete vector embedding
@@ -49,5 +55,6 @@ export async function handler({ id }, ctx, { ensureIndexed }) {
   // Delete DB row (FTS trigger handles FTS cleanup)
   ctx.stmts.deleteEntry.run(id);
 
-  return ok(`Deleted ${entry.kind}: ${entry.title || "(untitled)"} [${id}]`);
+  const msg = `Deleted ${entry.kind}: ${entry.title || "(untitled)"} [${id}]`;
+  return ok(fileWarning ? `${msg}\nWarning: ${fileWarning}` : msg);
 }

package/src/server/tools/get-context.js

@@ -110,7 +110,10 @@ export async function handler(
 
   const effectiveLimit = limit || 10;
   // When tag-filtering, over-fetch to compensate for post-filter reduction
-  const fetchLimit = tags?.length ? effectiveLimit * 10 : effectiveLimit;
+  const MAX_FETCH_LIMIT = 500;
+  const fetchLimit = tags?.length
+    ? Math.min(effectiveLimit * 10, MAX_FETCH_LIMIT)
+    : effectiveLimit;
 
   let filtered;
   if (hasQuery) {

package/src/server/tools.js

@@ -28,9 +28,11 @@ export function registerTools(server, ctx) {
     return async (...args) => {
       if (ctx.activeOps) ctx.activeOps.count++;
       let timer;
+      let handlerPromise;
       try {
+        handlerPromise = Promise.resolve(handler(...args));
         return await Promise.race([
-          Promise.resolve(handler(...args)),
+          handlerPromise,
           new Promise((_, reject) => {
             timer = setTimeout(
               () => reject(new Error("TOOL_TIMEOUT")),
@@ -40,6 +42,9 @@ export function registerTools(server, ctx) {
         ]);
       } 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(() => {});
           return err(
             "Tool timed out after 60s. Try a simpler query or run `context-vault reindex` first.",
             "TIMEOUT",