context-vault 3.17.0 → 3.19.0

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

@@ -0,0 +1,187 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { hybridSearch } from './search.js';
+import { VaultConfig } from './types.js';
+
+export interface AssembleOptions {
+  role: 'worker' | 'pm' | 'ceo' | 'steer';
+  task: string;
+  budget: number;
+}
+
+export interface IncludedEntryMeta {
+  title: string;
+  status: 'full' | 'condensed';
+}
+
+export interface AssembleResult {
+  markdown: string;
+  metadata: {
+    tokens_used: number;
+    budget: number;
+    entries_included: number;
+    role: string;
+    included_entries: IncludedEntryMeta[];
+  };
+}
+
+const TOKEN_TO_CHAR_RATIO = 4; // approximate conversion
+
+const CONDENSED_SUFFIX = '\n... [truncated for context budget]';
+const CONDENSED_BODY_CHARS = 400;
+
+type RoleProfile = { rules: string[]; skills: string[]; memory: string[] };
+
+const DEFAULT_ROLE_PROFILES: Record<string, RoleProfile> = {
+  worker: {
+    rules: ['coding', 'patterns', 'standards', 'error-handling', 'debugging'],
+    skills: ['git', 'compile', 'test', 'local'],
+    memory: ['feedback', 'user', 'project', 'reference']
+  },
+  pm: {
+    rules: ['orchestration', 'planning', 'spec-writing', 'review', 'debugging-escalation'],
+    skills: ['dispatch', 'review', 'triage', 'report'],
+    memory: ['project', 'team', 'feedback']
+  },
+  ceo: {
+    rules: ['strategy', 'epistemic-honesty', 'decision-making', 'business-logic'],
+    skills: ['triage', 'delegate', 'report'],
+    memory: ['north-star', 'project', 'user']
+  },
+  steer: {
+    rules: ['steer', 'strategy', 'feedback-loops', 'analysis'],
+    skills: ['triage', 'report', 'analyze'],
+    memory: ['north-star', 'feedback']
+  }
+};
+
+function loadRoleProfiles(dataDir: string): Record<string, RoleProfile> {
+  const rolesPath = join(dataDir, 'roles.json');
+  if (existsSync(rolesPath)) {
+    try {
+      const raw = readFileSync(rolesPath, 'utf-8');
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === 'object') {
+        return parsed as Record<string, RoleProfile>;
+      }
+    } catch {
+      // fall through to defaults
+    }
+  } else {
+    // Seed roles.json with defaults so the user can edit it later
+    try {
+      writeFileSync(rolesPath, JSON.stringify(DEFAULT_ROLE_PROFILES, null, 2) + '\n');
+    } catch {
+      // non-fatal: writable failure just means we use in-memory defaults
+    }
+  }
+  return DEFAULT_ROLE_PROFILES;
+}
+
+export async function assembleContext(
+  db: import('node:sqlite').DatabaseSync,
+  config: VaultConfig,
+  options: AssembleOptions
+): Promise<AssembleResult> {
+  const { role, task, budget } = options;
+
+  // 1. Load role profiles (dynamic — falls back to defaults)
+  const ROLE_PROFILES = loadRoleProfiles(config.dataDir);
+  const profile = ROLE_PROFILES[role] || ROLE_PROFILES.worker || DEFAULT_ROLE_PROFILES.worker;
+  const charsBudget = budget * TOKEN_TO_CHAR_RATIO;
+
+  // Allocate slots
+  const rulesChars = Math.floor(charsBudget * 0.2); // 20% for rules
+  const skillsChars = Math.floor(charsBudget * 0.1); // 10% for skills
+  const taskChars = Math.floor(charsBudget * 0.2);   // 20% for task
+  const vaultChars = Math.floor(charsBudget * 0.3);  // 30% for dynamically retrieved vault context
+  // reserve 20%
+
+  let markdown = `# Assembled Context: ${role.toUpperCase()}\n\n`;
+  let totalCharsUsed = markdown.length;
+
+  // 2. Add Task Spec
+  const taskSection = `## Active Task\n\n${task}\n\n`;
+  markdown += taskSection;
+  totalCharsUsed += taskSection.length;
+
+  // 3. Dynamic Vault Retrieval based on task
+  let entriesIncluded = 0;
+  const includedEntries: IncludedEntryMeta[] = [];
+  const totalBudgetChars = vaultChars + taskChars + rulesChars + skillsChars;
+
+  if (vaultChars > 0 && task.trim().length > 0) {
+    try {
+      // Over-retrieve candidates
+      const searchResults = await hybridSearch(
+        {
+          db,
+          config,
+          stmts: {} as any,
+          insertVec: () => {},
+          deleteVec: () => {},
+          embed: async () => new Float32Array(384),
+          insertCtxVec: () => {},
+          deleteCtxVec: () => {}
+        },
+        task,
+        { limit: 20 }
+      );
+
+      if (searchResults && searchResults.length > 0) {
+        markdown += `## Retrieved Context\n\n`;
+        const retrievedHeaderLen = `## Retrieved Context\n\n`.length;
+        totalCharsUsed += retrievedHeaderLen;
+
+        for (const item of searchResults) {
+          const entry = 'entry' in item ? (item as any).entry : (item as any);
+          const fullBody = entry.body || '';
+          const titleText = entry.title ? `### ${entry.title}\n` : '';
+          const entryTitle = entry.title || '(untitled)';
+
+          const fullEntryMarkdown = `${titleText}${fullBody}\n\n`;
+
+          if (totalCharsUsed + fullEntryMarkdown.length <= totalBudgetChars) {
+            // Full entry fits
+            markdown += fullEntryMarkdown;
+            totalCharsUsed += fullEntryMarkdown.length;
+            entriesIncluded++;
+            includedEntries.push({ title: entryTitle, status: 'full' });
+          } else {
+            // Try condensed version
+            const condensedBody = fullBody.slice(0, CONDENSED_BODY_CHARS) + CONDENSED_SUFFIX;
+            const condensedEntryMarkdown = `${titleText}${condensedBody}\n\n`;
+
+            if (totalCharsUsed + condensedEntryMarkdown.length <= totalBudgetChars) {
+              markdown += condensedEntryMarkdown;
+              totalCharsUsed += condensedEntryMarkdown.length;
+              entriesIncluded++;
+              includedEntries.push({ title: entryTitle, status: 'condensed' });
+            } else {
+              // Neither fits — stop adding vault entries
+              break;
+            }
+          }
+        }
+      }
+    } catch (e) {
+      console.error("Vault retrieval error during assembly:", e);
+    }
+  }
+
+  // 4. Construct System Prompts/Rules/Skills
+  const rulesSection = `## Role Directives\n\n### Rules\n${profile.rules.join(', ')}\n\n### Skills\n${profile.skills.join(', ')}\n\n`;
+  markdown = rulesSection + markdown; // U-Curve: Rules at the top
+  totalCharsUsed += rulesSection.length;
+
+  return {
+    markdown,
+    metadata: {
+      tokens_used: Math.ceil(totalCharsUsed / TOKEN_TO_CHAR_RATIO),
+      budget,
+      entries_included: entriesIncluded,
+      role,
+      included_entries: includedEntries
+    }
+  };
+}

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

@@ -6,6 +6,7 @@ import { parseFrontmatter, formatFrontmatter } from './frontmatter.js';
 import { formatBody } from './formatters.js';
 import type { BaseCtx, CaptureInput, CaptureResult, IndexEntryInput } from './types.js';
 import { indexEntry } from './index.js';
+import { withBusyRetry } from './db.js';
 
 function safeFolderPath(vaultDir: string, kind: string, folder?: string | null): string {
   const base = resolve(vaultDir, kindToPath(kind));
@@ -303,14 +304,18 @@ export async function captureAndIndex(
   try {
     await indexEntry(ctx, entry, precomputedEmbedding);
     if (entry.supersedes?.length && ctx.stmts.updateSupersededBy) {
-      for (const supersededId of entry.supersedes) {
-        if (typeof supersededId === 'string' && supersededId.trim()) {
-          ctx.stmts.updateSupersededBy.run(entry.id, supersededId.trim());
+      await withBusyRetry(() => {
+        for (const supersededId of entry.supersedes!) {
+          if (typeof supersededId === 'string' && supersededId.trim()) {
+            ctx.stmts.updateSupersededBy.run(entry.id, supersededId.trim());
+          }
         }
-      }
+      });
     }
     if (entry.related_to?.length && ctx.stmts.updateRelatedTo) {
-      ctx.stmts.updateRelatedTo.run(JSON.stringify(entry.related_to), entry.id);
+      await withBusyRetry(() => {
+        ctx.stmts.updateRelatedTo.run(JSON.stringify(entry.related_to), entry.id);
+      });
     }
     return entry;
   } catch (err) {

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

@@ -0,0 +1,356 @@
+import type { BaseCtx } from './types.js';
+import { dotProduct } from './search.js';
+
+export interface DuplicateGroup {
+  canonical_id: string;
+  duplicate_ids: string[];
+  similarity: number;
+  importance_signal: number;
+  canonical_title: string;
+  sample_titles: string[];
+}
+
+export interface MergeResult {
+  canonical_id: string;
+  merged_count: number;
+  new_recall_count: number;
+  removed_ids: string[];
+}
+
+export interface DecayScore {
+  id: string;
+  title: string;
+  kind: string;
+  score: number;
+  days_since_recall: number;
+  recall_count: number;
+  recommendation: 'keep' | 'compact' | 'archive';
+}
+
+interface VaultRow {
+  id: string;
+  title: string | null;
+  kind: string;
+  recall_count: number;
+  recall_sessions: number;
+  last_recalled_at: string | null;
+  updated_at: string | null;
+  created_at: string;
+  rowid: number;
+}
+
+interface VecRow {
+  rowid: number;
+  embedding: Buffer;
+}
+
+const KIND_WEIGHTS: Record<string, number> = {
+  insight: 10,
+  decision: 8,
+  pattern: 7,
+  reference: 5,
+  event: 2,
+};
+
+export async function findDuplicates(
+  ctx: BaseCtx,
+  opts?: {
+    threshold?: number;
+    limit?: number;
+    kind?: string;
+    dryRun?: boolean;
+  }
+): Promise<DuplicateGroup[]> {
+  const threshold = opts?.threshold ?? 0.85;
+  const limit = opts?.limit ?? 50;
+  const kind = opts?.kind ?? null;
+
+  const whereParts = [
+    'indexed = 1',
+    'superseded_by IS NULL',
+    "(expires_at IS NULL OR expires_at > datetime('now'))",
+  ];
+  const params: (string | number)[] = [];
+  if (kind) {
+    whereParts.push('kind = ?');
+    params.push(kind);
+  }
+
+  const entries = ctx.db
+    .prepare(
+      `SELECT rowid, id, title, kind, recall_count, recall_sessions, last_recalled_at, updated_at, created_at
+       FROM vault WHERE ${whereParts.join(' AND ')} ORDER BY recall_count DESC`
+    )
+    .all(...params) as unknown as VaultRow[];
+
+  if (entries.length === 0) return [];
+
+  const entryMap = new Map<string, VaultRow>();
+  const rowidToId = new Map<number, string>();
+  for (const e of entries) {
+    entryMap.set(e.id, e);
+    rowidToId.set(e.rowid, e.id);
+  }
+
+  // Load embeddings for all eligible entries via vault_vec KNN
+  const embeddingMap = new Map<string, Float32Array>();
+  const rowids = entries.map((e) => e.rowid);
+  if (rowids.length > 0) {
+    const batchSize = 500;
+    for (let i = 0; i < rowids.length; i += batchSize) {
+      const batch = rowids.slice(i, i + batchSize);
+      const placeholders = batch.map(() => '?').join(',');
+      const vecRows = ctx.db
+        .prepare(`SELECT rowid, embedding FROM vault_vec WHERE rowid IN (${placeholders})`)
+        .all(...batch) as unknown as VecRow[];
+      for (const row of vecRows) {
+        const id = rowidToId.get(Number(row.rowid));
+        if (id && row.embedding) {
+          embeddingMap.set(
+            id,
+            new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4)
+          );
+        }
+      }
+    }
+  }
+
+  if (embeddingMap.size === 0) return [];
+
+  // Find duplicate groups using pairwise similarity
+  const merged = new Set<string>();
+  const groups: DuplicateGroup[] = [];
+
+  // For each entry with an embedding, use KNN to find neighbors
+  const entriesWithVec = entries.filter((e) => embeddingMap.has(e.id));
+
+  for (const entry of entriesWithVec) {
+    if (merged.has(entry.id)) continue;
+
+    const entryVec = embeddingMap.get(entry.id)!;
+    const neighbors: Array<{ id: string; sim: number }> = [];
+
+    // Compare against all other entries with embeddings
+    for (const other of entriesWithVec) {
+      if (other.id === entry.id || merged.has(other.id)) continue;
+      const otherVec = embeddingMap.get(other.id);
+      if (!otherVec) continue;
+      const sim = dotProduct(entryVec, otherVec);
+      if (sim >= threshold) {
+        neighbors.push({ id: other.id, sim });
+      }
+    }
+
+    if (neighbors.length === 0) continue;
+
+    // Build the group: canonical is the one with highest recall_count
+    const allIds = [entry.id, ...neighbors.map((n) => n.id)];
+    let canonicalId = entry.id;
+    let maxRecall = entry.recall_count;
+    for (const nId of neighbors.map((n) => n.id)) {
+      const nEntry = entryMap.get(nId);
+      if (nEntry && nEntry.recall_count > maxRecall) {
+        maxRecall = nEntry.recall_count;
+        canonicalId = nId;
+      }
+    }
+
+    const duplicateIds = allIds.filter((id) => id !== canonicalId);
+    const avgSim =
+      neighbors.reduce((sum, n) => sum + n.sim, 0) / neighbors.length;
+
+    const canonical = entryMap.get(canonicalId)!;
+    const sampleTitles = duplicateIds
+      .map((id) => entryMap.get(id)?.title)
+      .filter((t): t is string => t != null)
+      .slice(0, 5);
+
+    groups.push({
+      canonical_id: canonicalId,
+      duplicate_ids: duplicateIds,
+      similarity: Math.round(avgSim * 1000) / 1000,
+      importance_signal: allIds.length,
+      canonical_title: canonical.title ?? '(untitled)',
+      sample_titles: sampleTitles,
+    });
+
+    for (const id of allIds) merged.add(id);
+
+    if (groups.length >= limit) break;
+  }
+
+  // Sort by importance (more duplicates = more important)
+  groups.sort((a, b) => b.importance_signal - a.importance_signal);
+
+  return groups.slice(0, limit);
+}
+
+export function mergeEntries(
+  ctx: BaseCtx,
+  opts: {
+    canonical_id: string;
+    duplicate_ids: string[];
+    dryRun?: boolean;
+  }
+): MergeResult {
+  const dryRun = opts.dryRun ?? true;
+  const { canonical_id, duplicate_ids } = opts;
+
+  if (duplicate_ids.length === 0) {
+    const canonical = ctx.db
+      .prepare('SELECT recall_count FROM vault WHERE id = ?')
+      .get(canonical_id) as { recall_count: number } | undefined;
+    return {
+      canonical_id,
+      merged_count: 0,
+      new_recall_count: canonical?.recall_count ?? 0,
+      removed_ids: [],
+    };
+  }
+
+  // Gather recall stats from all entries
+  const allIds = [canonical_id, ...duplicate_ids];
+  const placeholders = allIds.map(() => '?').join(',');
+  const rows = ctx.db
+    .prepare(
+      `SELECT id, recall_count, recall_sessions FROM vault WHERE id IN (${placeholders})`
+    )
+    .all(...allIds) as unknown as Array<{
+    id: string;
+    recall_count: number;
+    recall_sessions: number;
+  }>;
+
+  let totalRecallCount = 0;
+  let totalRecallSessions = 0;
+  for (const row of rows) {
+    totalRecallCount += row.recall_count ?? 0;
+    totalRecallSessions += row.recall_sessions ?? 0;
+  }
+
+  if (dryRun) {
+    return {
+      canonical_id,
+      merged_count: duplicate_ids.length,
+      new_recall_count: totalRecallCount,
+      removed_ids: duplicate_ids,
+    };
+  }
+
+  const now = new Date().toISOString();
+  const dateStr = now.slice(0, 10);
+
+  // Update canonical: sum recall counts, append consolidation note
+  ctx.db
+    .prepare(
+      `UPDATE vault SET
+        recall_count = ?,
+        recall_sessions = ?,
+        updated_at = ?,
+        body = body || ?
+      WHERE id = ?`
+    )
+    .run(
+      totalRecallCount,
+      totalRecallSessions,
+      now,
+      `\n\n[Consolidated from ${duplicate_ids.length + 1} entries on ${dateStr}]`,
+      canonical_id
+    );
+
+  // Mark duplicates as superseded
+  for (const dupId of duplicate_ids) {
+    ctx.db
+      .prepare('UPDATE vault SET superseded_by = ?, updated_at = ? WHERE id = ?')
+      .run(canonical_id, now, dupId);
+  }
+
+  return {
+    canonical_id,
+    merged_count: duplicate_ids.length,
+    new_recall_count: totalRecallCount,
+    removed_ids: duplicate_ids,
+  };
+}
+
+export function computeDecayScores(
+  ctx: BaseCtx,
+  opts?: {
+    limit?: number;
+    minAgeDays?: number;
+  }
+): DecayScore[] {
+  const limit = opts?.limit ?? 100;
+  const minAgeDays = opts?.minAgeDays ?? 0;
+
+  const now = Date.now();
+  const cutoffDate = minAgeDays > 0
+    ? new Date(now - minAgeDays * 86400000).toISOString()
+    : null;
+
+  const whereParts = [
+    'indexed = 1',
+    'superseded_by IS NULL',
+    "(expires_at IS NULL OR expires_at > datetime('now'))",
+  ];
+  const params: string[] = [];
+  if (cutoffDate) {
+    whereParts.push('created_at <= ?');
+    params.push(cutoffDate);
+  }
+
+  const rows = ctx.db
+    .prepare(
+      `SELECT id, title, kind, recall_count, last_recalled_at, updated_at, created_at
+       FROM vault WHERE ${whereParts.join(' AND ')}
+       ORDER BY updated_at ASC`
+    )
+    .all(...params) as unknown as Array<{
+    id: string;
+    title: string | null;
+    kind: string;
+    recall_count: number;
+    last_recalled_at: string | null;
+    updated_at: string | null;
+    created_at: string;
+  }>;
+
+  const scores: DecayScore[] = [];
+
+  for (const row of rows) {
+    const lastActivity = row.last_recalled_at ?? row.updated_at ?? row.created_at;
+    const daysSinceRecall = (now - new Date(lastActivity).getTime()) / 86400000;
+
+    const baseValue = KIND_WEIGHTS[row.kind] ?? 5;
+    const timeDecay = Math.exp(-0.02 * daysSinceRecall);
+    const recallBoost = 1 + Math.log((row.recall_count ?? 0) + 1);
+
+    const rawScore = baseValue * timeDecay * recallBoost;
+    // Normalize to 0-100 scale (max possible: ~10 * 1.0 * ~5 = 50 for heavily recalled insight)
+    const score = Math.max(0, Math.min(100, Math.round(rawScore * 10)));
+
+    let recommendation: 'keep' | 'compact' | 'archive';
+    if (score >= 30) {
+      recommendation = 'keep';
+    } else if (score >= 10) {
+      recommendation = 'compact';
+    } else {
+      recommendation = 'archive';
+    }
+
+    scores.push({
+      id: row.id,
+      title: row.title ?? '(untitled)',
+      kind: row.kind,
+      score,
+      days_since_recall: Math.round(daysSinceRecall),
+      recall_count: row.recall_count ?? 0,
+      recommendation,
+    });
+  }
+
+  // Sort by score ascending (most decayed first)
+  scores.sort((a, b) => a.score - b.score);
+
+  return scores.slice(0, limit);
+}

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

@@ -123,6 +123,82 @@ function runTransaction(db: DatabaseSync, fn: () => void): void {
   }
 }
 
+export function isBusyError(err: unknown): boolean {
+  if (!err || typeof err !== 'object') return false;
+  const e = err as { code?: unknown; message?: unknown; errcode?: unknown };
+  if (e.code === 'SQLITE_BUSY' || e.errcode === 5) return true;
+  if (typeof e.message === 'string' && /SQLITE_BUSY|database is locked|database table is locked/i.test(e.message)) {
+    return true;
+  }
+  return false;
+}
+
+const BUSY_RETRY_DELAYS_MS = [50, 150, 500];
+
+/**
+ * Execute `fn` and retry on transient SQLITE_BUSY errors.
+ *
+ * WAL + busy_timeout=5000ms already handles most single-statement contention.
+ * This helper guards transactions / multi-statement paths where a single
+ * statement can still exceed the busy grace under N-parallel-daemon load,
+ * surfacing SQLITE_BUSY to callers.
+ *
+ * Delays follow the pattern 50ms / 150ms / 500ms with small jitter.
+ * On final failure, the original SQLITE_BUSY error is propagated as-is.
+ */
+export async function withBusyRetry<T>(
+  fn: () => T | Promise<T>,
+  opts: { attempts?: number; baseDelayMs?: number } = {}
+): Promise<T> {
+  const attempts = Math.max(1, opts.attempts ?? 3);
+  const baseDelayMs = opts.baseDelayMs ?? 50;
+  let lastErr: unknown;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (!isBusyError(err) || i === attempts - 1) throw err;
+      const preset = BUSY_RETRY_DELAYS_MS[i];
+      const base = preset !== undefined
+        ? (preset * baseDelayMs) / BUSY_RETRY_DELAYS_MS[0]
+        : baseDelayMs * Math.pow(3, i);
+      const jitter = Math.random() * (base * 0.2);
+      await new Promise((resolve) => setTimeout(resolve, base + jitter));
+    }
+  }
+  throw lastErr;
+}
+
+/**
+ * Synchronous variant. Uses Atomics.wait for backoff so it can run inside
+ * non-async hot paths (watcher, CLI init, migration).
+ */
+export function withBusyRetrySync<T>(
+  fn: () => T,
+  opts: { attempts?: number; baseDelayMs?: number } = {}
+): T {
+  const attempts = Math.max(1, opts.attempts ?? 3);
+  const baseDelayMs = opts.baseDelayMs ?? 50;
+  let lastErr: unknown;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return fn();
+    } catch (err) {
+      lastErr = err;
+      if (!isBusyError(err) || i === attempts - 1) throw err;
+      const preset = BUSY_RETRY_DELAYS_MS[i];
+      const base = preset !== undefined
+        ? (preset * baseDelayMs) / BUSY_RETRY_DELAYS_MS[0]
+        : baseDelayMs * Math.pow(3, i);
+      const jitter = Math.random() * (base * 0.2);
+      const waitMs = Math.max(1, Math.round(base + jitter));
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs);
+    }
+  }
+  throw lastErr;
+}
+
 export const SCHEMA_DDL = `
   CREATE TABLE IF NOT EXISTS vault (
     id              TEXT PRIMARY KEY,
@@ -148,7 +224,9 @@ export const SCHEMA_DDL = `
     recall_count    INTEGER DEFAULT 0,
     recall_sessions INTEGER DEFAULT 0,
     last_recalled_at TEXT,
-    heat_tier       TEXT CHECK(heat_tier IN ('hot', 'warm', 'cold'))
+    heat_tier       TEXT CHECK(heat_tier IN ('hot', 'warm', 'cold')),
+    summary_condensed TEXT,
+    summary_keypoint  TEXT
   );
 
   CREATE INDEX IF NOT EXISTS idx_vault_kind ON vault(kind);
@@ -205,7 +283,7 @@ export const SCHEMA_DDL = `
   CREATE INDEX IF NOT EXISTS idx_access_log_goal ON access_log(session_goal) WHERE session_goal IS NOT NULL;
 `;
 
-const CURRENT_VERSION = 19;
+const CURRENT_VERSION = 20;
 
 export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
   const sqliteVec = await loadSqliteVec();
@@ -308,10 +386,23 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
         db.exec(`CREATE INDEX IF NOT EXISTS idx_access_log_goal ON access_log(session_goal) WHERE session_goal IS NOT NULL`);
         db.exec(`ALTER TABLE vault ADD COLUMN heat_tier TEXT CHECK(heat_tier IN ('hot', 'warm', 'cold'))`);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_vault_heat_tier ON vault(heat_tier) WHERE heat_tier IS NOT NULL`);
-        db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
+        db.exec(`PRAGMA user_version = 19`);
       } catch (e) {
         console.error(`[context-vault] v18->v19 migration failed: ${(e as Error).message}`);
+        return db;
       }
+      // Fall through to v19->v20 migration
+    }
+
+    // v19 -> v20: add precomputed summary tier columns
+    if (version >= 15 && version <= 19) {
+      try {
+        db.exec('ALTER TABLE vault ADD COLUMN summary_condensed TEXT');
+      } catch {}
+      try {
+        db.exec('ALTER TABLE vault ADD COLUMN summary_keypoint TEXT');
+      } catch {}
+      db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
       return db;
     }
 
@@ -356,7 +447,7 @@ export async function initDatabase(dbPath: string): Promise<DatabaseSync> {
       return freshDb;
     }
 
-    if (version < 19) {
+    if (version < 20) {
       db.exec(SCHEMA_DDL);
       db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
     }