context-vault 3.4.3 → 3.4.4

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

@@ -106,6 +106,7 @@ export async function hybridSearch(
     decayDays = 30,
     includeSuperseeded = false,
     includeEphemeral = false,
+    contextEmbedding = null,
   } = opts;
 
   const rowMap = new Map<string, VaultEntry>();
@@ -209,9 +210,60 @@ export async function hybridSearch(
     }
   }
 
+  // Context vector pass: KNN against vault_ctx_vec for contextual reinstatement
+  const ctxRankedIds: string[] = [];
+  if (contextEmbedding) {
+    try {
+      const ctxVecCount = (
+        ctx.db.prepare('SELECT COUNT(*) as c FROM vault_ctx_vec').get() as { c: number }
+      ).c;
+      if (ctxVecCount > 0) {
+        const ctxRows = ctx.db
+          .prepare(
+            `SELECT v.rowid, v.distance FROM vault_ctx_vec v WHERE embedding MATCH ? ORDER BY distance LIMIT 15`
+          )
+          .all(contextEmbedding, 15) as { rowid: number; distance: number }[];
+
+        if (ctxRows.length) {
+          const ctxRowids = ctxRows.map((cr) => cr.rowid);
+          const placeholders = ctxRowids.map(() => '?').join(',');
+          const ctxHydrated = ctx.db
+            .prepare(`SELECT rowid, * FROM vault WHERE rowid IN (${placeholders})`)
+            .all(...ctxRowids) as unknown as (VaultEntry & { rowid: number })[];
+
+          const ctxByRowid = new Map<number, VaultEntry & { rowid: number }>();
+          for (const row of ctxHydrated) ctxByRowid.set(row.rowid, row);
+
+          for (const cr of ctxRows) {
+            const row = ctxByRowid.get(cr.rowid);
+            if (!row) 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()) continue;
+
+            const { rowid: _rowid, ...cleanRow } = row;
+            ctxRankedIds.push(cleanRow.id);
+            if (!rowMap.has(cleanRow.id)) rowMap.set(cleanRow.id, cleanRow);
+            if (!idToRowid.has(cleanRow.id)) idToRowid.set(cleanRow.id, Number(row.rowid));
+          }
+        }
+      }
+    } catch (err) {
+      if (!(err as Error).message?.includes('no such table')) {
+        console.error(`[retrieve] Context vector search error: ${(err as Error).message}`);
+      }
+    }
+  }
+
   if (rowMap.size === 0) return [];
 
-  const rrfScores = reciprocalRankFusion([ftsRankedIds, vecRankedIds]);
+  // Build ranked lists for RRF: content FTS + content vec + optional context vec
+  const rankedLists = [ftsRankedIds, vecRankedIds];
+  if (ctxRankedIds.length > 0) rankedLists.push(ctxRankedIds);
+  const rrfScores = reciprocalRankFusion(rankedLists);
 
   for (const [id, entry] of rowMap) {
     const boost = recencyBoost(entry.created_at, entry.category, decayDays);
@@ -274,7 +326,7 @@ export async function hybridSearch(
   return finalPage;
 }
 
-function trackAccess(ctx: BaseCtx, entries: SearchResult[]): void {
+export function trackAccess(ctx: BaseCtx, entries: SearchResult[]): void {
   if (!entries.length) return;
   try {
     const placeholders = entries.map(() => '?').join(',');

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

@@ -53,6 +53,8 @@ export interface PreparedStatements {
   deleteVecStmt: StatementSync;
   updateSupersededBy: StatementSync;
   clearSupersededByRef: StatementSync;
+  insertCtxVecStmt: StatementSync;
+  deleteCtxVecStmt: StatementSync;
 }
 
 export interface VaultEntry {
@@ -151,6 +153,8 @@ export interface BaseCtx {
   embed: (text: string) => Promise<Float32Array | null>;
   insertVec: (rowid: number, embedding: Float32Array) => void;
   deleteVec: (rowid: number) => void;
+  insertCtxVec: (rowid: number, embedding: Float32Array) => void;
+  deleteCtxVec: (rowid: number) => void;
 }
 
 export interface SearchOptions {
@@ -164,4 +168,6 @@ export interface SearchOptions {
   decayDays?: number;
   includeSuperseeded?: boolean;
   includeEphemeral?: boolean;
+  /** Pre-computed context embedding for contextual reinstatement boosting. */
+  contextEmbedding?: Float32Array | null;
 }

package/package.json

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

package/src/server.ts

@@ -26,6 +26,8 @@ import {
   prepareStatements,
   insertVec,
   deleteVec,
+  insertCtxVec,
+  deleteCtxVec,
 } from '@context-vault/core/db';
 import { registerTools } from './register-tools.js';
 import { pruneExpired } from '@context-vault/core/index';
@@ -328,6 +330,8 @@ async function main(): Promise<void> {
       embed,
       insertVec: (rowid: number, embedding: Float32Array) => insertVec(stmts, rowid, embedding),
       deleteVec: (rowid: number) => deleteVec(stmts, rowid),
+      insertCtxVec: (rowid: number, embedding: Float32Array) => insertCtxVec(stmts, rowid, embedding),
+      deleteCtxVec: (rowid: number) => deleteCtxVec(stmts, rowid),
       activeOps: { count: 0 },
       toolStats: { ok: 0, errors: 0, lastError: null },
     };
@@ -480,15 +484,34 @@ async function main(): Promise<void> {
             await transport.handleRequest(req, res, (req as any).body);
             return;
           } else if (sessionId) {
-            // Stale session (e.g., daemon restarted). Per MCP spec, 404 tells
-            // the client to re-initialize automatically.
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-              jsonrpc: '2.0',
-              error: { code: -32000, message: 'Session not found. Please reinitialize.' },
-              id: null,
-            }));
-            return;
+            // Stale session (e.g., daemon restarted). Claude Code's MCP client
+            // does not auto-reinitialize on 404, so we recover transparently:
+            // create a new transport reusing the stale session ID, force it into
+            // initialized state, and handle the request as if nothing happened.
+            console.error(`[context-vault] Recovering stale session ${sessionId.slice(0, 8)}...`);
+
+            transport = new StreamableHTTPServerTransport({
+              sessionIdGenerator: () => sessionId,
+              onsessioninitialized: (sid: string) => {
+                transports[sid] = transport;
+              },
+            });
+            transport.onclose = () => {
+              if (transports[sessionId]) delete transports[sessionId];
+            };
+
+            const sessionServer = createServer();
+            await sessionServer.connect(transport);
+
+            // Force transport into initialized state, bypassing the initialize
+            // handshake. The inner WebStandardStreamableHTTPServerTransport holds
+            // the _initialized flag and sessionId.
+            const inner = (transport as any)._webStandardTransport;
+            inner._initialized = true;
+            inner.sessionId = sessionId;
+            transports[sessionId] = transport;
+
+            // Fall through to handleRequest below
           } else {
             res.writeHead(400, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({

package/src/tools/get-context.ts

@@ -2,9 +2,10 @@ import { z } from 'zod';
 import { createHash } from 'node:crypto';
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { hybridSearch } from '@context-vault/core/search';
+import { hybridSearch, trackAccess } from '@context-vault/core/search';
 import { categoryFor } from '@context-vault/core/categories';
 import { normalizeKind } from '@context-vault/core/files';
+import { parseContextParam } from '@context-vault/core/context';
 import { resolveTemporalParams } from '../temporal.js';
 import { collectLinkedEntries } from '../linking.js';
 import { ok, err, errWithHint } from '../helpers.js';
@@ -346,6 +347,12 @@ export const inputSchema = {
     .describe(
       'When true with identity_key, return a clear "not found" instead of falling through to semantic search on miss. Default: false.'
     ),
+  context: z
+    .any()
+    .optional()
+    .describe(
+      'Current context for contextual reinstatement. Boosts entries that were saved in a similar context. Pass a structured object (e.g. { project: "myapp", arc: "auth-rewrite", task: "debugging token expiry" }) or a free-text string. Entries saved with matching encoding_context will rank higher.'
+    ),
 };
 
 export async function handler(
@@ -369,6 +376,7 @@ export async function handler(
     follow_links,
     body_limit,
     strict,
+    context,
   }: Record<string, any>,
   ctx: LocalCtx,
   { ensureIndexed, reindexFailed }: SharedCtx
@@ -413,6 +421,7 @@ export async function handler(
     if (!kindFilter) return err('identity_key requires kind to be specified', 'INVALID_INPUT');
     const match = ctx.stmts.getByIdentityKey.get(kindFilter, identity_key) as any;
     if (match) {
+      trackAccess(ctx, [{ ...match, score: 1 }]);
       const entryTags = match.tags ? JSON.parse(match.tags) : [];
       const tagStr = entryTags.length ? entryTags.join(', ') : 'none';
       const relPath =
@@ -452,6 +461,17 @@ export async function handler(
     ? Math.min(effectiveLimit * 10, MAX_FETCH_LIMIT)
     : effectiveLimit;
 
+  // Generate context embedding for contextual reinstatement boosting
+  let contextEmbedding: Float32Array | null = null;
+  const parsedCtx = parseContextParam(context);
+  if (parsedCtx?.text) {
+    try {
+      contextEmbedding = await ctx.embed(parsedCtx.text);
+    } catch {
+      // Non-fatal: proceed without context boosting
+    }
+  }
+
   let filtered: any[];
   if (hasQuery) {
     // Hybrid search mode
@@ -465,6 +485,7 @@ export async function handler(
       decayDays: config.eventDecayDays || 30,
       includeSuperseeded: include_superseded ?? false,
       includeEphemeral: include_ephemeral ?? false,
+      contextEmbedding,
     });
 
     // Post-filter by tags if provided, then apply requested limit
@@ -532,6 +553,9 @@ export async function handler(
 
     // Add score field for consistent output
     for (const r of filtered) r.score = 0;
+
+    // Track access for filter-only results (hybrid search tracks its own)
+    trackAccess(ctx, filtered);
   }
 
   // Brief score boost: briefs rank slightly higher so consolidated snapshots

package/src/tools/save-context.ts

@@ -3,6 +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 { parseContextParam } from '@context-vault/core/context';
 import { ok, err, errWithHint, ensureVaultExists, ensureValidKind } from '../helpers.js';
 import { maybeShowFeedbackPrompt } from '../telemetry.js';
 import { validateRelatedTo } from '../linking.js';
@@ -310,6 +311,12 @@ export const inputSchema = {
     .describe(
       'Conflict resolution mode. "suggest" (default): when similar entries are found, return structured conflict_candidates with suggested_action (ADD/UPDATE/SKIP) and reasoning_context for the calling agent to decide. Thresholds: score > 0.95 → SKIP (near-duplicate), score > 0.85 → UPDATE (very similar), score < 0.85 → ADD (distinct enough). "off": flag similar entries only (legacy behavior).'
     ),
+  encoding_context: z
+    .any()
+    .optional()
+    .describe(
+      'Encoding context for contextual reinstatement. Captures the situation when this entry was created, enabling context-aware retrieval boosting. Pass a structured object (e.g. { project: "myapp", arc: "auth-rewrite", task: "implementing JWT" }) or a free-text string describing the current context.'
+    ),
 };
 
 export async function handler(
@@ -331,6 +338,7 @@ export async function handler(
     similarity_threshold,
     tier,
     conflict_resolution,
+    encoding_context,
   }: Record<string, any>,
   ctx: LocalCtx,
   { ensureIndexed }: SharedCtx
@@ -388,13 +396,21 @@ export async function handler(
       );
     }
 
+    // Merge encoding context into meta for update path
+    const updateParsedCtx = parseContextParam(encoding_context);
+    let updateMeta = meta;
+    if (updateParsedCtx) {
+      updateMeta = { ...(meta || {}) };
+      updateMeta.encoding_context = updateParsedCtx.structured || updateParsedCtx.text;
+    }
+
     let entry;
     try {
       entry = updateEntryFile(ctx, existing, {
         title,
         body,
         tags,
-        meta,
+        meta: updateMeta,
         source,
         expires_at,
         supersedes,
@@ -409,6 +425,24 @@ export async function handler(
         'context-vault save_context update is failing. Check `cat ~/.context-mcp/error.log | tail -5` and help me debug.'
       );
     }
+
+    // Store context embedding for updated entry
+    if (updateParsedCtx?.text) {
+      try {
+        const ctxEmbed = await ctx.embed(updateParsedCtx.text);
+        if (ctxEmbed) {
+          const rowidResult = ctx.stmts.getRowid.get(entry.id) as { rowid: number } | undefined;
+          if (rowidResult?.rowid) {
+            const rowid = Number(rowidResult.rowid);
+            try { ctx.deleteCtxVec(rowid); } catch {}
+            ctx.insertCtxVec(rowid, ctxEmbed);
+          }
+        }
+      } catch (e) {
+        console.warn(`[context-vault] Context embedding update failed: ${(e as Error).message}`);
+      }
+    }
+
     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) {
@@ -502,6 +536,15 @@ export async function handler(
 
   const mergedMeta = { ...(meta || {}) };
   if (folder) mergedMeta.folder = folder;
+
+  // Merge encoding context into meta for persistence
+  const parsedCtx = parseContextParam(encoding_context);
+  if (parsedCtx?.structured) {
+    mergedMeta.encoding_context = parsedCtx.structured;
+  } else if (parsedCtx?.text) {
+    mergedMeta.encoding_context = parsedCtx.text;
+  }
+
   const finalMeta = Object.keys(mergedMeta).length ? mergedMeta : undefined;
 
   const effectiveTier = tier ?? defaultTierFor(normalizedKind);
@@ -538,6 +581,24 @@ export async function handler(
     );
   }
 
+  // Store context embedding in vault_ctx_vec for contextual reinstatement
+  if (parsedCtx?.text && entry) {
+    try {
+      const ctxEmbedding = await ctx.embed(parsedCtx.text);
+      if (ctxEmbedding) {
+        const rowidResult = ctx.stmts.getRowid.get(entry.id) as { rowid: number } | undefined;
+        if (rowidResult?.rowid) {
+          const rowid = Number(rowidResult.rowid);
+          try { ctx.deleteCtxVec(rowid); } catch {}
+          ctx.insertCtxVec(rowid, ctxEmbedding);
+        }
+      }
+    } catch (e) {
+      // Non-fatal: context embedding failure should not block the save
+      console.warn(`[context-vault] Context embedding failed: ${(e as Error).message}`);
+    }
+  }
+
   if (ctx.config?.dataDir) {
     maybeShowFeedbackPrompt(ctx.config.dataDir);
   }