context-vault 3.4.5 → 3.5.0

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

@@ -143,7 +143,11 @@ export const SCHEMA_DDL = `
     last_accessed_at TEXT,
     source_files    TEXT,
     tier            TEXT DEFAULT 'working' CHECK(tier IN ('ephemeral', 'working', 'durable')),
-    related_to      TEXT
+    related_to      TEXT,
+    indexed         INTEGER DEFAULT 1,
+    recall_count    INTEGER DEFAULT 0,
+    recall_sessions INTEGER DEFAULT 0,
+    last_recalled_at TEXT
   );
 
   CREATE INDEX IF NOT EXISTS idx_vault_kind ON vault(kind);
@@ -153,33 +157,42 @@ export const SCHEMA_DDL = `
   CREATE UNIQUE INDEX IF NOT EXISTS idx_vault_identity ON vault(kind, identity_key) WHERE identity_key IS NOT NULL AND category = 'entity';
   CREATE INDEX IF NOT EXISTS idx_vault_superseded ON vault(superseded_by) WHERE superseded_by IS NOT NULL;
   CREATE INDEX IF NOT EXISTS idx_vault_tier ON vault(tier);
+  CREATE INDEX IF NOT EXISTS idx_vault_indexed ON vault(indexed);
 
   CREATE VIRTUAL TABLE IF NOT EXISTS vault_fts USING fts5(
     title, body, tags, kind,
     content='vault', content_rowid='rowid'
   );
 
-  CREATE TRIGGER IF NOT EXISTS vault_ai AFTER INSERT ON vault BEGIN
+  CREATE TRIGGER IF NOT EXISTS vault_ai AFTER INSERT ON vault WHEN new.indexed = 1 BEGIN
     INSERT INTO vault_fts(rowid, title, body, tags, kind)
       VALUES (new.rowid, new.title, new.body, new.tags, new.kind);
   END;
-  CREATE TRIGGER IF NOT EXISTS vault_ad AFTER DELETE ON vault BEGIN
+  CREATE TRIGGER IF NOT EXISTS vault_ad AFTER DELETE ON vault WHEN old.indexed = 1 BEGIN
     INSERT INTO vault_fts(vault_fts, rowid, title, body, tags, kind)
       VALUES ('delete', old.rowid, old.title, old.body, old.tags, old.kind);
   END;
-  CREATE TRIGGER IF NOT EXISTS vault_au AFTER UPDATE ON vault BEGIN
+  CREATE TRIGGER IF NOT EXISTS vault_au AFTER UPDATE ON vault WHEN old.indexed = 1 OR new.indexed = 1 BEGIN
     INSERT INTO vault_fts(vault_fts, rowid, title, body, tags, kind)
       VALUES ('delete', old.rowid, old.title, old.body, old.tags, old.kind);
     INSERT INTO vault_fts(rowid, title, body, tags, kind)
-      VALUES (new.rowid, new.title, new.body, new.tags, new.kind);
+      SELECT new.rowid, new.title, new.body, new.tags, new.kind WHERE new.indexed = 1;
   END;
 
   CREATE VIRTUAL TABLE IF NOT EXISTS vault_vec USING vec0(embedding float[384]);
 
   CREATE VIRTUAL TABLE IF NOT EXISTS vault_ctx_vec USING vec0(embedding float[384]);
+
+  CREATE TABLE IF NOT EXISTS co_retrievals (
+    entry_a TEXT NOT NULL,
+    entry_b TEXT NOT NULL,
+    count INTEGER DEFAULT 1,
+    last_at TEXT NOT NULL,
+    PRIMARY KEY (entry_a, entry_b)
+  );
 `;
 
-const CURRENT_VERSION = 16;
+const CURRENT_VERSION = 18;
 
 export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
   const sqliteVec = await loadSqliteVec();
@@ -208,9 +221,60 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
     if (version === 15) {
       try {
         db.exec('CREATE VIRTUAL TABLE IF NOT EXISTS vault_ctx_vec USING vec0(embedding float[384])');
-        db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
+        db.exec('PRAGMA user_version = 16');
       } catch (e) {
         console.error(`[context-vault] v15->v16 migration failed: ${(e as Error).message}`);
+        return db;
+      }
+      // Fall through to v16->v17 migration
+    }
+
+    // v16 -> v17: add indexed column for selective indexing
+    if (version === 16 || version === 15) {
+      try {
+        db.exec('ALTER TABLE vault ADD COLUMN indexed INTEGER DEFAULT 1');
+        db.exec('CREATE INDEX IF NOT EXISTS idx_vault_indexed ON vault(indexed)');
+        db.exec('DROP TRIGGER IF EXISTS vault_ai');
+        db.exec('DROP TRIGGER IF EXISTS vault_ad');
+        db.exec('DROP TRIGGER IF EXISTS vault_au');
+        db.exec(`CREATE TRIGGER vault_ai AFTER INSERT ON vault WHEN new.indexed = 1 BEGIN
+          INSERT INTO vault_fts(rowid, title, body, tags, kind)
+            VALUES (new.rowid, new.title, new.body, new.tags, new.kind);
+        END`);
+        db.exec(`CREATE TRIGGER vault_ad AFTER DELETE ON vault WHEN old.indexed = 1 BEGIN
+          INSERT INTO vault_fts(vault_fts, rowid, title, body, tags, kind)
+            VALUES ('delete', old.rowid, old.title, old.body, old.tags, old.kind);
+        END`);
+        db.exec(`CREATE TRIGGER vault_au AFTER UPDATE ON vault WHEN old.indexed = 1 OR new.indexed = 1 BEGIN
+          INSERT INTO vault_fts(vault_fts, rowid, title, body, tags, kind)
+            VALUES ('delete', old.rowid, old.title, old.body, old.tags, old.kind);
+          INSERT INTO vault_fts(rowid, title, body, tags, kind)
+            SELECT new.rowid, new.title, new.body, new.tags, new.kind WHERE new.indexed = 1;
+        END`);
+        db.exec('PRAGMA user_version = 17');
+      } catch (e) {
+        console.error(`[context-vault] v16->v17 migration failed: ${(e as Error).message}`);
+        return db;
+      }
+      // Fall through to v17->v18 migration
+    }
+
+    // v17 -> v18: add recall frequency tracking columns and co_retrievals table
+    if (version === 17 || version === 16 || version === 15) {
+      try {
+        db.exec('ALTER TABLE vault ADD COLUMN recall_count INTEGER DEFAULT 0');
+        db.exec('ALTER TABLE vault ADD COLUMN recall_sessions INTEGER DEFAULT 0');
+        db.exec('ALTER TABLE vault ADD COLUMN last_recalled_at TEXT');
+        db.exec(`CREATE TABLE IF NOT EXISTS co_retrievals (
+          entry_a TEXT NOT NULL,
+          entry_b TEXT NOT NULL,
+          count INTEGER DEFAULT 1,
+          last_at TEXT NOT NULL,
+          PRIMARY KEY (entry_a, entry_b)
+        )`);
+        db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
+      } catch (e) {
+        console.error(`[context-vault] v17->v18 migration failed: ${(e as Error).message}`);
       }
       return db;
     }
@@ -256,7 +320,7 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
       return freshDb;
     }
 
-    if (version < 16) {
+    if (version < 18) {
       db.exec(SCHEMA_DDL);
       db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
     }
@@ -271,7 +335,7 @@ export function prepareStatements(db: DatabaseSync): PreparedStatements {
   try {
     return {
       insertEntry: db.prepare(
-        `INSERT INTO vault (id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at, source_files, tier) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        `INSERT INTO vault (id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at, source_files, tier, indexed) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       ),
       updateEntry: db.prepare(
         `UPDATE vault SET title = ?, body = ?, meta = ?, tags = ?, source = ?, category = ?, identity_key = ?, expires_at = ?, updated_at = datetime('now') WHERE file_path = ?`

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

@@ -4,7 +4,9 @@ import { dirToKind, walkDir, ulid } from './files.js';
 import { categoryFor, defaultTierFor, CATEGORY_DIRS } from './categories.js';
 import { parseFrontmatter, parseEntryFromMarkdown } from './frontmatter.js';
 import { embedBatch } from './embed.js';
-import type { BaseCtx, IndexEntryInput, ReindexStats } from './types.js';
+import type { BaseCtx, IndexEntryInput, IndexingConfig, ReindexStats } from './types.js';
+import { shouldIndex } from './indexing.js';
+import { DEFAULT_INDEXING } from './constants.js';
 
 const EXCLUDED_DIRS = new Set(['projects', '_archive']);
 const EXCLUDED_FILES = new Set(['context.md', 'memory.md', 'README.md']);
@@ -33,6 +35,7 @@ export async function indexEntry(
     expires_at,
     source_files,
     tier,
+    indexed = true,
   } = entry;
 
   if (expires_at && new Date(expires_at) <= new Date()) return;
@@ -84,7 +87,8 @@ export async function indexEntry(
         createdAt,
         createdAt,
         sourceFilesJson,
-        effectiveTier
+        effectiveTier,
+        indexed ? 1 : 0
       );
     } catch (e) {
       if ((e as Error).message.includes('UNIQUE constraint')) {
@@ -132,7 +136,7 @@ export async function indexEntry(
     );
   }
 
-  if (cat !== 'event') {
+  if (indexed && cat !== 'event') {
     let embedding: Float32Array | null = null;
     if (precomputedEmbedding !== undefined) {
       embedding = precomputedEmbedding;
@@ -184,14 +188,17 @@ export async function pruneExpired(ctx: BaseCtx): Promise<number> {
 
 export async function reindex(
   ctx: BaseCtx,
-  opts: { fullSync?: boolean } = {}
+  opts: { fullSync?: boolean; indexingConfig?: IndexingConfig; dryRun?: boolean; kindFilter?: string } = {}
 ): Promise<ReindexStats> {
-  const { fullSync = true } = opts;
+  const { fullSync = true, indexingConfig, dryRun = false, kindFilter: reindexKindFilter } = opts;
+  const ixConfig = indexingConfig ?? (ctx.config as any)?.indexing ?? DEFAULT_INDEXING;
   const stats: ReindexStats = {
     added: 0,
     updated: 0,
     removed: 0,
     unchanged: 0,
+    skippedIndexing: 0,
+    embeddingsCleared: 0,
   };
 
   if (!existsSync(ctx.config.vaultDir)) return stats;
@@ -225,17 +232,44 @@ export async function reindex(
     }
   }
 
+  const filteredKindEntries = reindexKindFilter
+    ? kindEntries.filter((ke) => ke.kind === reindexKindFilter)
+    : kindEntries;
+
   const pendingEmbeds: { rowid: number; text: string }[] = [];
 
+  if (dryRun) {
+    for (const { kind, dir } of filteredKindEntries) {
+      const category = categoryFor(kind);
+      const mdFiles = walkDir(dir).filter((f) => !EXCLUDED_FILES.has(basename(f.filePath)));
+      for (const { filePath } of mdFiles) {
+        const raw = readFileSync(filePath, 'utf-8');
+        if (!raw.startsWith('---\n')) continue;
+        const { meta: fmMeta, body: rawBody } = parseFrontmatter(raw);
+        const parsed = parseEntryFromMarkdown(kind, rawBody, fmMeta);
+        const entryIndexed = shouldIndex(
+          { kind, category, bodyLength: parsed.body.length },
+          ixConfig
+        );
+        if (entryIndexed) {
+          stats.added++;
+        } else {
+          stats.skippedIndexing!++;
+        }
+      }
+    }
+    return stats;
+  }
+
   ctx.db.exec('BEGIN');
   try {
-    for (const { kind, dir } of kindEntries) {
+    for (const { kind, dir } of filteredKindEntries) {
       const category = categoryFor(kind);
       const mdFiles = walkDir(dir).filter((f) => !EXCLUDED_FILES.has(basename(f.filePath)));
 
       const dbRows = ctx.db
         .prepare(
-          'SELECT id, file_path, body, title, tags, meta, related_to FROM vault WHERE kind = ?'
+          'SELECT id, file_path, body, title, tags, meta, related_to, indexed FROM vault WHERE kind = ?'
         )
         .all(kind) as Record<string, unknown>[];
       const dbByPath = new Map(dbRows.map((r) => [r.file_path as string, r]));
@@ -269,6 +303,11 @@ export async function reindex(
         else delete meta.folder;
         const metaJson = Object.keys(meta).length ? JSON.stringify(meta) : null;
 
+        const entryIndexed = shouldIndex(
+          { kind, category, bodyLength: parsed.body.length },
+          ixConfig
+        );
+
         if (!existing) {
           const id = (fmMeta.id as string) || ulid();
           const tagsJson = fmMeta.tags ? JSON.stringify(fmMeta.tags) : null;
@@ -290,10 +329,11 @@ export async function reindex(
             (fmMeta.updated as string) || created
           );
           if ((result as { changes: number }).changes > 0) {
+            ctx.db.prepare('UPDATE vault SET indexed = ? WHERE id = ?').run(entryIndexed ? 1 : 0, id);
             if (relatedToJson && ctx.stmts.updateRelatedTo) {
               ctx.stmts.updateRelatedTo.run(relatedToJson, id);
             }
-            if (category !== 'event') {
+            if (entryIndexed && category !== 'event') {
               const rowidResult = ctx.stmts.getRowid.get(id) as { rowid: number } | undefined;
               if (rowidResult?.rowid) {
                 const embeddingText = [parsed.title, parsed.body].filter(Boolean).join(' ');
@@ -303,6 +343,7 @@ export async function reindex(
                 });
               }
             }
+            if (!entryIndexed) stats.skippedIndexing!++;
             stats.added++;
           } else {
             stats.unchanged++;
@@ -315,7 +356,10 @@ export async function reindex(
           const metaChanged = metaJson !== ((existing.meta as string) || null);
           const relatedToChanged = relatedToJson !== ((existing.related_to as string) || null);
 
-          if (bodyChanged || titleChanged || tagsChanged || metaChanged || relatedToChanged) {
+          const existingIndexed = (existing as any).indexed;
+          const indexedChanged = (entryIndexed ? 1 : 0) !== (existingIndexed ?? 1);
+
+          if (bodyChanged || titleChanged || tagsChanged || metaChanged || relatedToChanged || indexedChanged) {
             ctx.stmts.updateEntry.run(
               parsed.title || null,
               parsed.body,
@@ -327,11 +371,20 @@ export async function reindex(
               expires_at,
               filePath
             );
-            if (relatedToChanged && ctx.stmts.updateRelatedTo) {
+            ctx.db.prepare('UPDATE vault SET indexed = ? WHERE file_path = ?').run(entryIndexed ? 1 : 0, filePath);
+            if (relatedToJson && ctx.stmts.updateRelatedTo) {
               ctx.stmts.updateRelatedTo.run(relatedToJson, existing.id as string);
             }
 
-            if ((bodyChanged || titleChanged) && category !== 'event') {
+            if (!entryIndexed) {
+              const rowid = (
+                ctx.stmts.getRowid.get(existing.id as string) as { rowid: number } | undefined
+              )?.rowid;
+              if (rowid) {
+                try { ctx.deleteVec(rowid); stats.embeddingsCleared!++; } catch {}
+              }
+              stats.skippedIndexing!++;
+            } else if ((bodyChanged || titleChanged) && category !== 'event') {
               const rowid = (
                 ctx.stmts.getRowid.get(existing.id as string) as { rowid: number } | undefined
               )?.rowid;
@@ -435,6 +488,7 @@ export async function reindex(
       .prepare(
         `SELECT v.rowid, v.title, v.body FROM vault v
          WHERE v.category != 'event'
+           AND v.indexed = 1
            AND v.rowid NOT IN (SELECT rowid FROM vault_vec)`
       )
       .all() as { rowid: number; title: string | null; body: string }[];

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

@@ -0,0 +1,35 @@
+import type { IndexingConfig } from './types.js';
+import { DEFAULT_INDEXING } from './constants.js';
+
+export function shouldIndex(
+  opts: {
+    kind: string;
+    category: string;
+    bodyLength: number;
+    explicitIndexed?: boolean;
+  },
+  config?: IndexingConfig | null
+): boolean {
+  if (opts.explicitIndexed === true) return true;
+  if (opts.explicitIndexed === false) return false;
+
+  const c = config ?? DEFAULT_INDEXING;
+
+  if (c.excludeKinds.length > 0 && c.excludeKinds.includes(opts.kind)) {
+    return false;
+  }
+
+  if (c.excludeCategories.length > 0 && c.excludeCategories.includes(opts.category)) {
+    return false;
+  }
+
+  if (opts.category === 'event' && !c.autoIndexEvents) {
+    return false;
+  }
+
+  if (c.maxBodySize > 0 && opts.bodyLength > c.maxBodySize) {
+    return false;
+  }
+
+  return true;
+}

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

@@ -4,6 +4,7 @@ export type {
   RecallConfig,
   ConsolidationConfig,
   GrowthThresholds,
+  IndexingConfig,
   PreparedStatements,
   VaultEntry,
   SearchResult,
@@ -31,6 +32,7 @@ export {
   MAX_IDENTITY_KEY_LENGTH,
   DEFAULT_GROWTH_THRESHOLDS,
   DEFAULT_LIFECYCLE,
+  DEFAULT_INDEXING,
 } from './constants.js';
 
 // Categories
@@ -99,5 +101,8 @@ export {
 // Capture
 export { writeEntry, updateEntryFile, captureAndIndex } from './capture.js';
 
+// Indexing
+export { shouldIndex } from './indexing.js';
+
 // Ingest URL
 export { htmlToMarkdown, extractHtmlContent, ingestUrl } from './ingest-url.js';

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

@@ -2,6 +2,9 @@ import type { BaseCtx, SearchResult, SearchOptions, VaultEntry } from './types.j
 
 const NEAR_DUP_THRESHOLD = 0.92;
 const RRF_K = 60;
+const RECALL_BOOST_CAP = 2.0;
+const RECALL_HALF_LIFE_DAYS = 30;
+const DISCOVERY_SLOTS = 2;
 
 export function recencyDecayScore(updatedAt: string | null | undefined, decayRate = 0.05): number {
   if (updatedAt == null) return 0.5;
@@ -34,6 +37,18 @@ export function recencyBoost(createdAt: string, category: string, decayDays = 30
   return 1 / (1 + ageDays / decayDays);
 }
 
+export function recallBoost(recallCount: number, lastRecalledAt: string | null): number {
+  if (recallCount <= 0) return 1.0;
+  const logBoost = Math.log(recallCount + 1);
+  let recencyWeight = 1.0;
+  if (lastRecalledAt) {
+    const ageDays = (Date.now() - new Date(lastRecalledAt).getTime()) / 86400000;
+    recencyWeight = Math.pow(0.5, ageDays / RECALL_HALF_LIFE_DAYS);
+  }
+  const boost = 1 + logBoost * recencyWeight;
+  return Math.min(boost, RECALL_BOOST_CAP);
+}
+
 export function buildFilterClauses({
   categoryFilter,
   excludeEvents = false,
@@ -73,6 +88,7 @@ export function buildFilterClauses({
   if (!includeEphemeral) {
     clauses.push("e.tier != 'ephemeral'");
   }
+  clauses.push('e.indexed = 1');
   return { clauses, params };
 }
 
@@ -191,6 +207,7 @@ export async function hybridSearch(
             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;
+            if (!row.indexed) continue;
 
             const { rowid: _rowid, ...cleanRow } = row;
             idToRowid.set(cleanRow.id, Number(row.rowid));
@@ -243,6 +260,7 @@ export async function hybridSearch(
             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;
+            if (!row.indexed) continue;
 
             const { rowid: _rowid, ...cleanRow } = row;
             ctxRankedIds.push(cleanRow.id);
@@ -267,7 +285,11 @@ export async function hybridSearch(
 
   for (const [id, entry] of rowMap) {
     const boost = recencyBoost(entry.created_at, entry.category, decayDays);
-    rrfScores.set(id, (rrfScores.get(id) ?? 0) * boost);
+    const recall = recallBoost(
+      entry.recall_count ?? 0,
+      entry.last_recalled_at ?? null
+    );
+    rrfScores.set(id, (rrfScores.get(id) ?? 0) * boost * recall);
   }
 
   const candidates: SearchResult[] = [...rowMap.values()].map((entry) => ({
@@ -316,26 +338,94 @@ export async function hybridSearch(
       selected.push(candidate);
       if (vec) selectedVecs.push(vec);
     }
-    const dedupedPage = selected.slice(offset, offset + limit);
+    const dedupedPage = injectDiscoverySlots(selected.slice(offset, offset + limit), candidates);
     trackAccess(ctx, dedupedPage);
     return dedupedPage;
   }
 
-  const finalPage = candidates.slice(offset, offset + limit);
+  const page = candidates.slice(offset, offset + limit);
+  const finalPage = injectDiscoverySlots(page, candidates);
   trackAccess(ctx, finalPage);
   return finalPage;
 }
 
+function injectDiscoverySlots(
+  page: SearchResult[],
+  allCandidates: SearchResult[]
+): SearchResult[] {
+  if (page.length < 4) return page;
+  const pageIds = new Set(page.map((e) => e.id));
+  const discoveries = allCandidates
+    .filter(
+      (c) =>
+        !pageIds.has(c.id) &&
+        (c.recall_count ?? 0) <= 2 &&
+        c.score > 0
+    )
+    .slice(0, DISCOVERY_SLOTS);
+  if (!discoveries.length) return page;
+  const result = [...page];
+  for (let i = 0; i < discoveries.length && result.length > 2; i++) {
+    result.splice(result.length - 1 - i, 1, discoveries[i]);
+  }
+  return result;
+}
+
+let _sessionId: string | null = null;
+const _seenSessionIds = new Set<string>();
+
+export function setSessionId(id: string): void {
+  _sessionId = id;
+}
+
 export function trackAccess(ctx: BaseCtx, entries: SearchResult[]): void {
   if (!entries.length) return;
+
+  const ids = entries.map((e) => e.id);
+  const now = new Date().toISOString();
+
   try {
-    const placeholders = entries.map(() => '?').join(',');
+    const placeholders = ids.map(() => '?').join(',');
     ctx.db
       .prepare(
-        `UPDATE vault SET hit_count = hit_count + 1, last_accessed_at = datetime('now') WHERE id IN (${placeholders})`
+        `UPDATE vault SET hit_count = hit_count + 1, last_accessed_at = datetime('now'), recall_count = recall_count + 1, last_recalled_at = ? WHERE id IN (${placeholders})`
       )
-      .run(...entries.map((e) => e.id));
+      .run(now, ...ids);
   } catch {
     // Non-fatal
   }
+
+  const sessionId = _sessionId || 'default';
+  const sessionKey = `${sessionId}:${ids.sort().join(',')}`;
+  const isNewSession = !_seenSessionIds.has(sessionKey);
+  if (isNewSession) {
+    _seenSessionIds.add(sessionKey);
+    try {
+      const placeholders = ids.map(() => '?').join(',');
+      ctx.db
+        .prepare(
+          `UPDATE vault SET recall_sessions = recall_sessions + 1 WHERE id IN (${placeholders})`
+        )
+        .run(...ids);
+    } catch {
+      // Non-fatal
+    }
+  }
+
+  if (ids.length >= 2) {
+    try {
+      const upsert = ctx.db.prepare(
+        `INSERT INTO co_retrievals (entry_a, entry_b, count, last_at) VALUES (?, ?, 1, ?)
+         ON CONFLICT(entry_a, entry_b) DO UPDATE SET count = count + 1, last_at = ?`
+      );
+      for (let i = 0; i < ids.length; i++) {
+        for (let j = i + 1; j < ids.length; j++) {
+          const [a, b] = ids[i] < ids[j] ? [ids[i], ids[j]] : [ids[j], ids[i]];
+          upsert.run(a, b, now, now);
+        }
+      }
+    } catch {
+      // Non-fatal
+    }
+  }
 }

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

@@ -1,5 +1,20 @@
 import type { DatabaseSync, StatementSync } from 'node:sqlite';
 
+export interface AutoInsightsConfig {
+  enabled: boolean;
+  patterns: string[];
+  minChars: number;
+  maxPerSession: number;
+  tier: string;
+}
+
+export interface IndexingConfig {
+  excludeKinds: string[];
+  excludeCategories: string[];
+  maxBodySize: number;
+  autoIndexEvents: boolean;
+}
+
 export interface VaultConfig {
   vaultDir: string;
   dataDir: string;
@@ -14,6 +29,8 @@ export interface VaultConfig {
   recall: RecallConfig;
   consolidation: ConsolidationConfig;
   lifecycle: Record<string, { archiveAfterDays?: number }>;
+  autoInsights: AutoInsightsConfig;
+  indexing: IndexingConfig;
 }
 
 export interface RecallConfig {
@@ -77,6 +94,10 @@ export interface VaultEntry {
   source_files: string | null;
   tier: string;
   related_to: string | null;
+  indexed: number;
+  recall_count: number;
+  recall_sessions: number;
+  last_recalled_at: string | null;
   rowid?: number;
 }
 
@@ -100,6 +121,7 @@ export interface CaptureInput {
   related_to?: string[] | null;
   source_files?: Array<{ path: string; hash: string }> | null;
   tier?: string | null;
+  indexed?: boolean;
 }
 
 export interface CaptureResult {
@@ -120,6 +142,7 @@ export interface CaptureResult {
   related_to: string[] | null;
   source_files: Array<{ path: string; hash: string }> | null;
   tier: string | null;
+  indexed: boolean;
 }
 
 export interface IndexEntryInput {
@@ -137,6 +160,7 @@ export interface IndexEntryInput {
   expires_at: string | null;
   source_files: Array<{ path: string; hash: string }> | null;
   tier: string | null;
+  indexed?: boolean;
 }
 
 export interface ReindexStats {
@@ -144,6 +168,8 @@ export interface ReindexStats {
   updated: number;
   removed: number;
   unchanged: number;
+  skippedIndexing?: number;
+  embeddingsCleared?: number;
 }
 
 export interface BaseCtx {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-vault",
-  "version": "3.4.5",
+  "version": "3.5.0",
   "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.5",
+    "@context-vault/core": "^3.5.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "adm-zip": "^0.5.16",
     "sqlite-vec": "^0.1.0"

package/src/server.ts

@@ -31,6 +31,7 @@ import {
 } from '@context-vault/core/db';
 import { registerTools } from './register-tools.js';
 import { pruneExpired } from '@context-vault/core/index';
+import { setSessionId } from '@context-vault/core/search';
 
 const DAEMON_PORT = 3377;
 const PID_PATH = join(homedir(), '.context-mcp', 'daemon.pid');
@@ -359,6 +360,8 @@ async function main(): Promise<void> {
       toolStats: { ok: 0, errors: 0, lastError: null },
     };
 
+    setSessionId(randomUUID());
+
     try {
       const pruned = await pruneExpired(ctx);
       if (pruned > 0) {