@context-vault/core 2.17.0 → 2.17.1

package/src/index/db.js

@@ -42,7 +42,69 @@ function runTransaction(db, fn) {
   }
 }
 
-export const SCHEMA_DDL = `
+// Local-mode schema: no multi-tenancy or encryption columns.
+// Identity uniqueness is scoped to (kind, identity_key) — no user_id.
+export const LOCAL_SCHEMA_DDL = `
+  CREATE TABLE IF NOT EXISTS vault (
+    id              TEXT PRIMARY KEY,
+    kind            TEXT NOT NULL,
+    category        TEXT NOT NULL DEFAULT 'knowledge',
+    title           TEXT,
+    body            TEXT NOT NULL,
+    meta            TEXT,
+    tags            TEXT,
+    source          TEXT,
+    file_path       TEXT UNIQUE,
+    identity_key    TEXT,
+    expires_at      TEXT,
+    superseded_by   TEXT,
+    created_at      TEXT DEFAULT (datetime('now')),
+    updated_at      TEXT,
+    hit_count       INTEGER DEFAULT 0,
+    last_accessed_at TEXT,
+    source_files    TEXT,
+    tier            TEXT DEFAULT 'working' CHECK(tier IN ('ephemeral', 'working', 'durable')),
+    related_to      TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_vault_kind ON vault(kind);
+  CREATE INDEX IF NOT EXISTS idx_vault_category ON vault(category);
+  CREATE INDEX IF NOT EXISTS idx_vault_category_created ON vault(category, created_at DESC);
+  CREATE INDEX IF NOT EXISTS idx_vault_updated ON vault(updated_at DESC);
+  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);
+
+  -- Single FTS5 table
+  CREATE VIRTUAL TABLE IF NOT EXISTS vault_fts USING fts5(
+    title, body, tags, kind,
+    content='vault', content_rowid='rowid'
+  );
+
+  -- FTS sync triggers
+  CREATE TRIGGER IF NOT EXISTS vault_ai AFTER INSERT ON vault 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
+    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
+    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);
+  END;
+
+  -- Single vec table (384-dim float32 for all-MiniLM-L6-v2)
+  CREATE VIRTUAL TABLE IF NOT EXISTS vault_vec USING vec0(embedding float[384]);
+`;
+
+// Hosted-mode schema: adds multi-tenancy (user_id, team_id) and at-rest
+// encryption columns (body_encrypted, title_encrypted, meta_encrypted, iv).
+// Identity uniqueness is scoped to (user_id, kind, identity_key).
+export const HOSTED_SCHEMA_DDL = `
   CREATE TABLE IF NOT EXISTS vault (
     id              TEXT PRIMARY KEY,
     kind            TEXT NOT NULL,
@@ -67,7 +129,8 @@ export const SCHEMA_DDL = `
     hit_count       INTEGER DEFAULT 0,
     last_accessed_at TEXT,
     source_files    TEXT,
-    tier            TEXT DEFAULT 'working' CHECK(tier IN ('ephemeral', 'working', 'durable'))
+    tier            TEXT DEFAULT 'working' CHECK(tier IN ('ephemeral', 'working', 'durable')),
+    related_to      TEXT
   );
 
   CREATE INDEX IF NOT EXISTS idx_vault_kind ON vault(kind);
@@ -106,7 +169,13 @@ export const SCHEMA_DDL = `
   CREATE VIRTUAL TABLE IF NOT EXISTS vault_vec USING vec0(embedding float[384]);
 `;
 
-export async function initDatabase(dbPath) {
+// Backward-compatible alias — kept for external consumers that reference SCHEMA_DDL.
+export const SCHEMA_DDL = HOSTED_SCHEMA_DDL;
+
+// Current target schema version. Bump this on every migration.
+const CURRENT_VERSION = 14;
+
+export async function initDatabase(dbPath, { mode = "local" } = {}) {
   const sqliteVec = await loadSqliteVec();
 
   function createDb(path) {
@@ -121,6 +190,8 @@ export async function initDatabase(dbPath) {
     return db;
   }
 
+  const schemaDdl = mode === "hosted" ? HOSTED_SCHEMA_DDL : LOCAL_SCHEMA_DDL;
+
   const db = createDb(dbPath);
   const version = db.prepare("PRAGMA user_version").get().user_version;
 
@@ -155,14 +226,14 @@ export async function initDatabase(dbPath) {
     } catch {}
 
     const freshDb = createDb(dbPath);
-    freshDb.exec(SCHEMA_DDL);
-    freshDb.exec("PRAGMA user_version = 12");
+    freshDb.exec(schemaDdl);
+    freshDb.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
     return freshDb;
   }
 
   if (version < 5) {
-    db.exec(SCHEMA_DDL);
-    db.exec("PRAGMA user_version = 12");
+    db.exec(schemaDdl);
+    db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
   } else if (version === 5) {
     // v5 -> v6 migration: add multi-tenancy + encryption columns
     // Wrapped in transaction with duplicate-column guards for idempotent retry
@@ -344,12 +415,108 @@ export async function initDatabase(dbPath) {
     });
   }
 
+  if (version >= 5 && version <= 12) {
+    // v12 -> v13 migration: add related_to column for graph linking
+    runTransaction(db, () => {
+      try {
+        db.exec(`ALTER TABLE vault ADD COLUMN related_to TEXT`);
+      } catch (e) {
+        if (!e.message.includes("duplicate column")) throw e;
+      }
+      db.exec("PRAGMA user_version = 13");
+    });
+  }
+
+  if (version >= 5 && version <= 13) {
+    // v13 -> v14 migration: separate local and hosted schemas.
+    // Local mode: drop the 6 hosted-only columns (user_id, team_id,
+    // body_encrypted, title_encrypted, meta_encrypted, iv) and rebuild
+    // the identity index without user_id.
+    // Hosted mode: no structural change — just bump version.
+    runTransaction(db, () => {
+      if (mode === "local") {
+        // Must drop indexes that reference the columns before dropping columns.
+        db.exec(`DROP INDEX IF EXISTS idx_vault_user`);
+        db.exec(`DROP INDEX IF EXISTS idx_vault_team`);
+        db.exec(`DROP INDEX IF EXISTS idx_vault_identity`);
+        const dropColumnSafe = (col) => {
+          try {
+            db.exec(`ALTER TABLE vault DROP COLUMN ${col}`);
+          } catch (e) {
+            // Column may not exist on older schemas that never had it added.
+            if (!e.message.includes("no such column")) throw e;
+          }
+        };
+        dropColumnSafe("user_id");
+        dropColumnSafe("team_id");
+        dropColumnSafe("body_encrypted");
+        dropColumnSafe("title_encrypted");
+        dropColumnSafe("meta_encrypted");
+        dropColumnSafe("iv");
+        // Recreate identity uniqueness index scoped to (kind, identity_key),
+        // restricted to entity-category entries only (knowledge/event entries
+        // with identity_key are informational and may duplicate).
+        db.exec(
+          `CREATE UNIQUE INDEX IF NOT EXISTS idx_vault_identity ON vault(kind, identity_key) WHERE identity_key IS NOT NULL AND category = 'entity'`,
+        );
+      }
+      db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
+    });
+  }
+
   return db;
 }
 
-export function prepareStatements(db) {
+export function prepareStatements(db, mode = "local") {
   try {
+    if (mode === "local") {
+      // Local mode: no user_id, team_id, or encryption columns.
+      // insertEntry has 15 params (no user_id).
+      // getByIdentityKey and upsertByIdentityKey have no user_id WHERE clause.
+      return {
+        _mode: "local",
+        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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        ),
+        updateEntry: db.prepare(
+          `UPDATE vault SET title = ?, body = ?, meta = ?, tags = ?, source = ?, category = ?, identity_key = ?, expires_at = ?, updated_at = datetime('now') WHERE file_path = ?`,
+        ),
+        deleteEntry: db.prepare(`DELETE FROM vault WHERE id = ?`),
+        getRowid: db.prepare(`SELECT rowid FROM vault WHERE id = ?`),
+        getRowidByPath: db.prepare(
+          `SELECT rowid FROM vault WHERE file_path = ?`,
+        ),
+        getEntryById: db.prepare(`SELECT * FROM vault WHERE id = ?`),
+        getByIdentityKey: db.prepare(
+          `SELECT * FROM vault WHERE kind = ? AND identity_key = ?`,
+        ),
+        upsertByIdentityKey: db.prepare(
+          `UPDATE vault SET title = ?, body = ?, meta = ?, tags = ?, source = ?, category = ?, file_path = ?, expires_at = ?, source_files = ?, updated_at = datetime('now') WHERE kind = ? AND identity_key = ?`,
+        ),
+        updateSourceFiles: db.prepare(
+          `UPDATE vault SET source_files = ? WHERE id = ?`,
+        ),
+        updateRelatedTo: db.prepare(
+          `UPDATE vault SET related_to = ? WHERE id = ?`,
+        ),
+        insertVecStmt: db.prepare(
+          `INSERT INTO vault_vec (rowid, embedding) VALUES (?, ?)`,
+        ),
+        deleteVecStmt: db.prepare(`DELETE FROM vault_vec WHERE rowid = ?`),
+        updateSupersededBy: db.prepare(
+          `UPDATE vault SET superseded_by = ? WHERE id = ?`,
+        ),
+        clearSupersededByRef: db.prepare(
+          `UPDATE vault SET superseded_by = NULL WHERE superseded_by = ?`,
+        ),
+      };
+    }
+
+    // Hosted mode: full schema with user_id scoping and encryption support.
+    // insertEntry has 16 params (includes user_id).
+    // getByIdentityKey and upsertByIdentityKey scope by user_id IS ?.
     return {
+      _mode: "hosted",
       insertEntry: db.prepare(
         `INSERT INTO vault (id, user_id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at, source_files, tier) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       ),
@@ -372,6 +539,9 @@ export function prepareStatements(db) {
       updateSourceFiles: db.prepare(
         `UPDATE vault SET source_files = ? WHERE id = ?`,
       ),
+      updateRelatedTo: db.prepare(
+        `UPDATE vault SET related_to = ? WHERE id = ?`,
+      ),
       insertVecStmt: db.prepare(
         `INSERT INTO vault_vec (rowid, embedding) VALUES (?, ?)`,
       ),

package/src/index/index.js

@@ -66,37 +66,53 @@ export async function indexEntry(
   const cat = category || categoryFor(kind);
   const effectiveTier = tier || defaultTierFor(kind);
   const userIdVal = userId || null;
+  const isLocal = ctx.stmts._mode === "local";
 
   let wasUpdate = false;
 
-  // Entity upsert: check by (kind, identity_key, user_id) first
+  // Entity upsert: check by (kind, identity_key[, user_id]) first.
+  // Local mode omits user_id — all entries are user-agnostic.
   if (cat === "entity" && identity_key) {
-    const existing = ctx.stmts.getByIdentityKey.get(
-      kind,
-      identity_key,
-      userIdVal,
-    );
+    const existing = isLocal
+      ? ctx.stmts.getByIdentityKey.get(kind, identity_key)
+      : ctx.stmts.getByIdentityKey.get(kind, identity_key, userIdVal);
     if (existing) {
-      ctx.stmts.upsertByIdentityKey.run(
-        title || null,
-        body,
-        metaJson,
-        tagsJson,
-        source || "claude-code",
-        cat,
-        filePath,
-        expires_at || null,
-        sourceFilesJson,
-        kind,
-        identity_key,
-        userIdVal,
-      );
+      if (isLocal) {
+        ctx.stmts.upsertByIdentityKey.run(
+          title || null,
+          body,
+          metaJson,
+          tagsJson,
+          source || "claude-code",
+          cat,
+          filePath,
+          expires_at || null,
+          sourceFilesJson,
+          kind,
+          identity_key,
+        );
+      } else {
+        ctx.stmts.upsertByIdentityKey.run(
+          title || null,
+          body,
+          metaJson,
+          tagsJson,
+          source || "claude-code",
+          cat,
+          filePath,
+          expires_at || null,
+          sourceFilesJson,
+          kind,
+          identity_key,
+          userIdVal,
+        );
+      }
       wasUpdate = true;
     }
   }
 
   if (!wasUpdate) {
-    // Prepare encryption if ctx.encrypt is available
+    // Prepare encryption if ctx.encrypt is available (hosted mode only)
     let encrypted = null;
     if (ctx.encrypt) {
       encrypted = await ctx.encrypt({ title, body, meta });
@@ -104,7 +120,8 @@ export async function indexEntry(
 
     try {
       if (encrypted) {
-        // Encrypted insert: store preview in body column for FTS, full content in encrypted columns
+        // Hosted-mode encrypted insert: store preview in body for FTS,
+        // full content in encrypted columns.
         const bodyPreview = body.slice(0, 200);
         ctx.stmts.insertEntryEncrypted.run(
           id,
@@ -128,7 +145,27 @@ export async function indexEntry(
           sourceFilesJson,
           effectiveTier,
         );
+      } else if (isLocal) {
+        // Local mode: no user_id column — 15 params.
+        ctx.stmts.insertEntry.run(
+          id,
+          kind,
+          cat,
+          title || null,
+          body,
+          metaJson,
+          tagsJson,
+          source || "claude-code",
+          filePath,
+          identity_key || null,
+          expires_at || null,
+          createdAt,
+          createdAt,
+          sourceFilesJson,
+          effectiveTier,
+        );
       } else {
+        // Hosted mode without encryption: 16 params (includes user_id).
         ctx.stmts.insertEntry.run(
           id,
           userIdVal,
@@ -262,10 +299,14 @@ export async function reindex(ctx, opts = {}) {
 
   if (!existsSync(ctx.config.vaultDir)) return stats;
 
-  // Use INSERT OR IGNORE for reindex — handles files with duplicate frontmatter IDs
-  // user_id is NULL for reindex (always local mode)
+  // Use INSERT OR IGNORE for reindex — handles files with duplicate frontmatter IDs.
+  // Local mode: no user_id column (15 params).
+  // Hosted mode: user_id is NULL for file-sourced entries (14 params, NULL literal).
+  const isLocalReindex = ctx.stmts._mode === "local";
   const upsertEntry = ctx.db.prepare(
-    `INSERT OR IGNORE INTO vault (id, user_id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at) VALUES (?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    isLocalReindex
+      ? `INSERT OR IGNORE INTO vault (id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      : `INSERT OR IGNORE INTO vault (id, user_id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at) VALUES (?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
 
   // Auto-discover kind directories, supporting both:
@@ -317,7 +358,7 @@ export async function reindex(ctx, opts = {}) {
       // P3: Fetch all mutable fields for change detection
       const dbRows = ctx.db
         .prepare(
-          "SELECT id, file_path, body, title, tags, meta FROM vault WHERE kind = ?",
+          "SELECT id, file_path, body, title, tags, meta, related_to FROM vault WHERE kind = ?",
         )
         .all(kind);
       const dbByPath = new Map(dbRows.map((r) => [r.file_path, r]));
@@ -343,6 +384,12 @@ export async function reindex(ctx, opts = {}) {
         // Extract identity_key and expires_at from frontmatter
         const identity_key = fmMeta.identity_key || null;
         const expires_at = fmMeta.expires_at || null;
+        const related_to = Array.isArray(fmMeta.related_to)
+          ? fmMeta.related_to
+          : null;
+        const relatedToJson = related_to?.length
+          ? JSON.stringify(related_to)
+          : null;
 
         // Derive folder from disk location (source of truth)
         const meta = { ...(parsed.meta || {}) };
@@ -372,6 +419,9 @@ export async function reindex(ctx, opts = {}) {
             fmMeta.updated || created,
           );
           if (result.changes > 0) {
+            if (relatedToJson && ctx.stmts.updateRelatedTo) {
+              ctx.stmts.updateRelatedTo.run(relatedToJson, id);
+            }
             if (category !== "event") {
               const rowidResult = ctx.stmts.getRowid.get(id);
               if (rowidResult?.rowid) {
@@ -396,8 +446,16 @@ export async function reindex(ctx, opts = {}) {
           const bodyChanged = existing.body !== parsed.body;
           const tagsChanged = tagsJson !== (existing.tags || null);
           const metaChanged = metaJson !== (existing.meta || null);
-
-          if (bodyChanged || titleChanged || tagsChanged || metaChanged) {
+          const relatedToChanged =
+            relatedToJson !== (existing.related_to || null);
+
+          if (
+            bodyChanged ||
+            titleChanged ||
+            tagsChanged ||
+            metaChanged ||
+            relatedToChanged
+          ) {
             ctx.stmts.updateEntry.run(
               parsed.title || null,
               parsed.body,
@@ -409,6 +467,9 @@ export async function reindex(ctx, opts = {}) {
               expires_at,
               filePath,
             );
+            if (relatedToChanged && ctx.stmts.updateRelatedTo) {
+              ctx.stmts.updateRelatedTo.run(relatedToJson, existing.id);
+            }
 
             // Queue re-embed if title or body changed (vector ops deferred to Phase 2)
             if ((bodyChanged || titleChanged) && category !== "event") {

package/src/index.js

@@ -29,6 +29,11 @@ export {
   parseEntryFromMarkdown,
 } from "./core/frontmatter.js";
 export { gatherVaultStatus } from "./core/status.js";
+export {
+  PLURAL_TO_SINGULAR,
+  planMigration,
+  executeMigration,
+} from "./core/migrate-dirs.js";
 
 // Capture layer
 export {

package/src/retrieve/index.js

@@ -11,8 +11,6 @@ const NEAR_DUP_THRESHOLD = 0.92;
 
 const RRF_K = 60;
 
-const MMR_LAMBDA = 0.7;
-
 /**
  * Exponential recency decay score based on updated_at timestamp.
  * Returns e^(-decayRate * ageDays) for valid dates, or 0.5 as a neutral
@@ -132,108 +130,16 @@ export function reciprocalRankFusion(rankedLists, k = RRF_K) {
   return scores;
 }
 
-/**
- * Jaccard similarity between two strings based on word sets.
- * Used as a fallback for MMR when embedding vectors are unavailable.
- *
- * @param {string} a
- * @param {string} b
- * @returns {number} Similarity in [0, 1].
- */
-export function jaccardSimilarity(a, b) {
-  const wordsA = new Set((a ?? "").toLowerCase().split(/\W+/).filter(Boolean));
-  const wordsB = new Set((b ?? "").toLowerCase().split(/\W+/).filter(Boolean));
-  if (wordsA.size === 0 && wordsB.size === 0) return 1;
-  if (wordsA.size === 0 || wordsB.size === 0) return 0;
-  let intersection = 0;
-  for (const w of wordsA) if (wordsB.has(w)) intersection++;
-  return intersection / (wordsA.size + wordsB.size - intersection);
-}
-
-/**
- * Maximal Marginal Relevance reranking.
- *
- * Selects up to n candidates that balance relevance to the query and
- * diversity from already-selected results.
- *
- * MMR_score = lambda * querySim(doc) - (1 - lambda) * max(sim(doc, selected))
- *
- * @param {Array<object>} candidates - Entries with at least {id, title, body}.
- * @param {Map<string, number>} querySimMap - Map of id -> relevance score.
- * @param {Map<string, Float32Array|null>} embeddingMap - Map of id -> embedding (null if unavailable).
- * @param {number} n - Number of results to select.
- * @param {number} lambda - Trade-off weight (default MMR_LAMBDA = 0.7).
- * @returns {Array<object>} Reranked subset of candidates (length <= n).
- */
-export function maximalMarginalRelevance(
-  candidates,
-  querySimMap,
-  embeddingMap,
-  n,
-  lambda = MMR_LAMBDA,
-) {
-  if (candidates.length === 0) return [];
-
-  const remaining = [...candidates];
-  const selected = [];
-  const selectedVecs = [];
-  const selectedEntries = [];
-
-  while (selected.length < n && remaining.length > 0) {
-    let bestIdx = -1;
-    let bestScore = -Infinity;
-
-    for (let i = 0; i < remaining.length; i++) {
-      const candidate = remaining[i];
-      const relevance = querySimMap.get(candidate.id) ?? 0;
-
-      let maxRedundancy = 0;
-      if (selectedVecs.length > 0) {
-        const vec = embeddingMap.get(candidate.id);
-        for (let j = 0; j < selectedVecs.length; j++) {
-          let sim;
-          if (vec && selectedVecs[j]) {
-            sim = dotProduct(vec, selectedVecs[j]);
-          } else {
-            const selEntry = selectedEntries[j];
-            sim = jaccardSimilarity(
-              `${candidate.title} ${candidate.body}`,
-              `${selEntry.title} ${selEntry.body}`,
-            );
-          }
-          if (sim > maxRedundancy) maxRedundancy = sim;
-        }
-      }
-
-      const score = lambda * relevance - (1 - lambda) * maxRedundancy;
-      if (score > bestScore) {
-        bestScore = score;
-        bestIdx = i;
-      }
-    }
-
-    if (bestIdx === -1) break;
-
-    const chosen = remaining.splice(bestIdx, 1)[0];
-    selected.push(chosen);
-    selectedVecs.push(embeddingMap.get(chosen.id) ?? null);
-    selectedEntries.push(chosen);
-  }
-
-  return selected;
-}
-
 /**
  * Hybrid search combining FTS5 text matching and vector similarity,
- * with RRF merging and MMR reranking for diversity.
+ * with RRF merging, recency decay, and near-duplicate suppression.
  *
  * Pipeline:
  *   1. FTS5 ranked list
  *   2. Vector (semantic) ranked list
  *   3. RRF: merge the two ranked lists into a single score
- *   4. Apply recency decay to RRF scores
- *   5. MMR: rerank top candidates for diversity (uses embeddings or Jaccard fallback)
- *   6. Near-duplicate suppression on the final selection
+ *   4. Recency decay: penalise old events (knowledge/entity entries unaffected)
+ *   5. Near-duplicate suppression (cosine similarity > 0.92 threshold)
  *
  * @param {import('../server/types.js').BaseCtx} ctx
  * @param {string} query
@@ -383,20 +289,6 @@ export async function hybridSearch(
     rrfScores.set(id, (rrfScores.get(id) ?? 0) * boost);
   }
 
-  // Stage 3b: Frequency signal — log(1 + hit_count) / log(1 + max_hit_count)
-  const allRows = [...rowMap.values()];
-  const maxHitCount = Math.max(...allRows.map((e) => e.hit_count || 0), 0);
-  if (maxHitCount > 0) {
-    const logMax = Math.log(1 + maxHitCount);
-    for (const entry of allRows) {
-      const freqScore = Math.log(1 + (entry.hit_count || 0)) / logMax;
-      rrfScores.set(
-        entry.id,
-        (rrfScores.get(entry.id) ?? 0) + freqScore * 0.13,
-      );
-    }
-  }
-
   // Attach final score to each entry and sort by RRF score descending
   const candidates = [...rowMap.values()].map((entry) => ({
     ...entry,
@@ -404,7 +296,7 @@ export async function hybridSearch(
   }));
   candidates.sort((a, b) => b.score - a.score);
 
-  // Stage 4: Fetch embeddings for all candidates that have a rowid
+  // Stage 4: Fetch embeddings for near-duplicate suppression
   const embeddingMap = new Map();
   if (queryVec && idToRowid.size > 0) {
     const rowidToId = new Map();
@@ -429,34 +321,15 @@ export async function hybridSearch(
         }
       }
     } catch (_) {
-      // Embeddings unavailable — MMR will fall back to Jaccard similarity
+      // Embeddings unavailable — near-dup suppression skipped
     }
   }
 
-  // Use vecSim as the query-relevance signal for MMR; fall back to RRF score
-  const querySimMap = new Map();
-  for (const candidate of candidates) {
-    querySimMap.set(
-      candidate.id,
-      vecSimMap.has(candidate.id)
-        ? vecSimMap.get(candidate.id)
-        : candidate.score,
-    );
-  }
-
-  // Stage 5: MMR — rerank for diversity using embeddings or Jaccard fallback
-  const mmrSelected = maximalMarginalRelevance(
-    candidates,
-    querySimMap,
-    embeddingMap,
-    offset + limit,
-  );
-
-  // Stage 6: Near-duplicate suppression (hard filter, not reorder)
-  if (queryVec && embeddingMap.size > 0 && mmrSelected.length > limit) {
+  // Stage 5: Near-duplicate suppression (cosine similarity > 0.92 threshold)
+  if (queryVec && embeddingMap.size > 0) {
     const selected = [];
     const selectedVecs = [];
-    for (const candidate of mmrSelected) {
+    for (const candidate of candidates) {
       if (selected.length >= offset + limit) break;
       const vec = embeddingMap.get(candidate.id);
       if (vec && selectedVecs.length > 0) {
@@ -475,7 +348,7 @@ export async function hybridSearch(
     return dedupedPage;
   }
 
-  const finalPage = mmrSelected.slice(offset, offset + limit);
+  const finalPage = candidates.slice(offset, offset + limit);
   trackAccess(ctx.db, finalPage);
   return finalPage;
 }