sessionmem 1.0.5 → 1.1.0

package/dist/core/storage/memoryRepo.js

@@ -1,4 +1,186 @@
-import { insertMemoryFeedbackEvent, } from "./memoryFeedbackRepo.js";
+// Shared INSERT ... ON CONFLICT(id) upsert column lists. The import and team-pull
+// paths differ only in how they resolve `importance` on conflict (import takes the
+// incoming value; pull preserves MAX(local, incoming)), so the surrounding SQL is
+// factored out to keep the two prepared statements byte-for-byte aligned.
+const UPSERT_INSERT_HEAD = `
+  INSERT INTO memories (
+    id, project_id, session_id, source_adapter, kind, content, normalized_content,
+    importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+    created_at, updated_at
+  ) VALUES (
+    @id, @project_id, @session_id, @source_adapter, @kind, @content, @normalized_content,
+    @importance, @embedding, @embedding_dim, @embedding_version, @author, @origin_project_id,
+    COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+  )
+  ON CONFLICT(id) DO UPDATE SET
+    project_id = excluded.project_id,
+    session_id = excluded.session_id,
+    source_adapter = excluded.source_adapter,
+    kind = excluded.kind,
+    content = excluded.content,
+    normalized_content = excluded.normalized_content,`;
+const UPSERT_INSERT_TAIL = `
+    embedding = excluded.embedding,
+    embedding_dim = excluded.embedding_dim,
+    embedding_version = excluded.embedding_version,
+    author = excluded.author,
+    origin_project_id = excluded.origin_project_id,
+    created_at = excluded.created_at,
+    updated_at = excluded.updated_at
+`;
+const stmtCache = new WeakMap();
+function getStatements(db) {
+    let stmts = stmtCache.get(db);
+    if (stmts)
+        return stmts;
+    stmts = {
+        insertMemory: db.prepare(`
+    INSERT INTO memories (
+      id, project_id, session_id, source_adapter, kind, content, normalized_content,
+      importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+      created_at, updated_at
+    ) VALUES (
+      @id, @project_id, @session_id, @source_adapter, @kind, @content, @normalized_content,
+      @importance, @embedding, @embedding_dim, @embedding_version, @author, @origin_project_id,
+      COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+      COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    )
+  `),
+        upsertSessionSummary: db.prepare(`
+    INSERT INTO memories (
+      id, project_id, session_id, source_adapter, kind, content, normalized_content,
+      importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+      created_at, updated_at
+    ) VALUES (
+      @id, @project_id, @session_id, @source_adapter, 'summary', @content, @normalized_content,
+      @importance, @embedding, @embedding_dim, @embedding_version, @author, @origin_project_id,
+      COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+      COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    )
+    ON CONFLICT(project_id, session_id, kind) WHERE kind = 'summary'
+    DO UPDATE SET
+      id = excluded.id,
+      source_adapter = excluded.source_adapter,
+      content = excluded.content,
+      normalized_content = excluded.normalized_content,
+      importance = excluded.importance,
+      embedding = excluded.embedding,
+      embedding_dim = excluded.embedding_dim,
+      embedding_version = excluded.embedding_version,
+      author = excluded.author,
+      origin_project_id = excluded.origin_project_id,
+      updated_at = COALESCE(excluded.updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    ON CONFLICT(id)
+    DO UPDATE SET
+      project_id = excluded.project_id,
+      session_id = excluded.session_id,
+      source_adapter = excluded.source_adapter,
+      content = excluded.content,
+      normalized_content = excluded.normalized_content,
+      importance = excluded.importance,
+      embedding = excluded.embedding,
+      embedding_dim = excluded.embedding_dim,
+      embedding_version = excluded.embedding_version,
+      author = excluded.author,
+      origin_project_id = excluded.origin_project_id,
+      updated_at = COALESCE(excluded.updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+  `),
+        listByProject: db.prepare(`
+    SELECT
+      id, project_id, session_id, source_adapter, kind, content, normalized_content,
+      importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+      access_count, last_accessed, created_at, updated_at
+    FROM memories
+    WHERE project_id = ?
+    ORDER BY updated_at DESC
+  `),
+        // Lightweight projection for token-savings accounting: only `content` is
+        // needed to count tokens, so we deliberately avoid pulling the (potentially
+        // multi-KB) embedding JSON and normalized_content for every row. Matters for
+        // large projects where `savings` would otherwise load the whole table.
+        listContentByProject: db.prepare("SELECT content FROM memories WHERE project_id = ?"),
+        importUpsert: db.prepare(`${UPSERT_INSERT_HEAD}\n    importance = excluded.importance,${UPSERT_INSERT_TAIL}`),
+        // Importance-preserving merge for team pulls: a teammate can never lower a
+        // locally-boosted importance. better-sqlite3@12 bundles a SQLite that accepts
+        // the two-arg scalar MAX() inside DO UPDATE.
+        pullUpsert: db.prepare(`${UPSERT_INSERT_HEAD}\n    importance = MAX(memories.importance, excluded.importance),${UPSERT_INSERT_TAIL}`),
+        listAllIds: db.prepare("SELECT id FROM memories"),
+        selectById: db.prepare(`
+      SELECT
+        id, project_id, session_id, source_adapter, kind, content, normalized_content,
+        importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+        access_count, last_accessed, created_at, updated_at
+      FROM memories
+      WHERE project_id = ? AND id = ?
+      LIMIT 1
+    `),
+        selectOwner: db.prepare("SELECT project_id FROM memories WHERE id = ?"),
+        deleteById: db.prepare("DELETE FROM memories WHERE project_id = ? AND id = ?"),
+        countOlderThan: db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM memories
+      WHERE project_id = ? AND created_at < ?
+    `),
+        deleteOlderThan: db.prepare(`
+      DELETE FROM memories
+      WHERE project_id = ? AND created_at < ?
+    `),
+        updateImportance: db.prepare(`
+      UPDATE memories
+      SET
+        importance = ?,
+        updated_at = COALESCE(?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      WHERE project_id = ? AND id = ?
+    `),
+        updateContent: db.prepare(`
+      UPDATE memories
+      SET
+        content = ?,
+        normalized_content = COALESCE(?, normalized_content),
+        embedding = COALESCE(?, embedding),
+        embedding_dim = COALESCE(?, embedding_dim),
+        embedding_version = COALESCE(?, embedding_version),
+        updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+      WHERE project_id = ? AND id = ?
+    `),
+        selectForRecordUse: db.prepare(`
+        SELECT id, importance
+        FROM memories
+        WHERE project_id = ? AND id = ?
+        LIMIT 1
+      `),
+        incrementAccess: db.prepare(`
+      UPDATE memories
+      SET
+        access_count = access_count + 1,
+        last_accessed = COALESCE(?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      WHERE project_id = ? AND id = ?
+    `),
+        resetAccess: db.prepare(`
+      UPDATE memories
+      SET access_count = 0, last_accessed = NULL
+      WHERE project_id = ?
+    `),
+        countBySession: db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM memories
+      WHERE session_id = ? AND project_id = ?
+    `),
+        countAll: db.prepare("SELECT COUNT(*) AS count FROM memories WHERE project_id = ?"),
+        // Memories whose stored embedding does not match the supplied current
+        // embedding version (NULL counts as stale). Used to surface a re-embed
+        // hint; the actual re-embed is the `sessionmem re-embed` command.
+        countStaleEmbeddings: db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM memories
+      WHERE project_id = ?
+        AND (embedding_version IS NULL OR embedding_version != ?)
+    `),
+    };
+    stmtCache.set(db, stmts);
+    return stmts;
+}
 function assertImportance(importance) {
     if (importance < 1 || importance > 10) {
         throw new Error("importance must be between 1 and 10");
@@ -18,60 +200,67 @@ function toParams(input) {
 }
 export function insertMemory(db, input) {
     assertImportance(input.importance);
-    const stmt = db.prepare(`
-    INSERT INTO memories (
-      id, project_id, session_id, source_adapter, kind, content, normalized_content,
-      importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
-      created_at, updated_at
-    ) VALUES (
-      @id, @project_id, @session_id, @source_adapter, @kind, @content, @normalized_content,
-      @importance, @embedding, @embedding_dim, @embedding_version, @author, @origin_project_id,
-      COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-      COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-    )
-  `);
-    stmt.run(toParams(input));
+    getStatements(db).insertMemory.run(toParams(input));
 }
 export function upsertSessionSummaryMemory(db, input) {
     assertImportance(input.importance);
-    const stmt = db.prepare(`
-    INSERT INTO memories (
-      id, project_id, session_id, source_adapter, kind, content, normalized_content,
-      importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
-      created_at, updated_at
-    ) VALUES (
-      @id, @project_id, @session_id, @source_adapter, 'summary', @content, @normalized_content,
-      @importance, @embedding, @embedding_dim, @embedding_version, @author, @origin_project_id,
-      COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-      COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-    )
-    ON CONFLICT(project_id, session_id, kind) WHERE kind = 'summary'
-    DO UPDATE SET
-      id = excluded.id,
-      source_adapter = excluded.source_adapter,
-      content = excluded.content,
-      normalized_content = excluded.normalized_content,
-      importance = excluded.importance,
-      embedding = excluded.embedding,
-      embedding_dim = excluded.embedding_dim,
-      embedding_version = excluded.embedding_version,
-      author = excluded.author,
-      origin_project_id = excluded.origin_project_id,
-      updated_at = COALESCE(excluded.updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-  `);
-    stmt.run(toParams({ ...input, kind: "summary" }));
+    getStatements(db).upsertSessionSummary.run(toParams({ ...input, kind: "summary" }));
+}
+/**
+ * Upsert a memory imported from an external export. On `id` conflict the incoming
+ * record wins on every column (including importance). Cross-project ownership
+ * collisions are filtered by the caller via {@link getMemoryOwnerProjectId} before
+ * this runs, so this never reassigns another project's row.
+ */
+export function upsertImportedMemory(db, input) {
+    assertImportance(input.importance);
+    getStatements(db).importUpsert.run(toParams(input));
+}
+/**
+ * Upsert a memory pulled from a teammate. Identical to {@link upsertImportedMemory}
+ * except importance is merged as MAX(local, incoming) so a pull can never lower a
+ * locally-boosted importance.
+ */
+export function upsertPulledMemory(db, input) {
+    assertImportance(input.importance);
+    getStatements(db).pullUpsert.run(toParams(input));
 }
 export function listMemoriesByProject(db, projectId) {
-    const stmt = db.prepare(`
-    SELECT
-      id, project_id, session_id, source_adapter, kind, content, normalized_content,
-      importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
-      created_at, updated_at
-    FROM memories
-    WHERE project_id = ?
-    ORDER BY updated_at DESC
-  `);
-    return stmt.all(projectId);
+    return getStatements(db).listByProject.all(projectId);
+}
+/**
+ * Return just the `content` of every memory in a project. Used by the
+ * token-savings command, which only needs `content` to count tokens and must
+ * not pay to load embedding JSON / normalized_content for the whole table.
+ */
+export function listMemoryContentsByProject(db, projectId) {
+    const rows = getStatements(db).listContentByProject.all(projectId);
+    return rows.map((r) => r.content);
+}
+/**
+ * Fetch a single memory row scoped to a project. Returns undefined when no row
+ * matches (caller maps that to NOT_FOUND). Uses a WeakMap-cached prepared
+ * statement — this is a high-frequency path (every store/get/forget and each
+ * batch item re-reads the inserted row).
+ */
+export function getMemoryRecordById(db, projectId, memoryId) {
+    return getStatements(db).selectById.get(projectId, memoryId);
+}
+/**
+ * Resolve the project that currently owns a globally-unique memory `id`, or
+ * undefined when the id is unused. Import/pull use this to skip (never overwrite)
+ * an id already owned by a different project.
+ */
+export function getMemoryOwnerProjectId(db, memoryId) {
+    const row = getStatements(db).selectOwner.get(memoryId);
+    return row?.project_id;
+}
+/**
+ * Hard-delete a single memory scoped to a project. Returns the number of rows
+ * removed (0 when the id does not exist in this project).
+ */
+export function deleteMemoryById(db, projectId, memoryId) {
+    return getStatements(db).deleteById.run(projectId, memoryId).changes;
 }
 /**
  * All memory ids across every project. `id` is a globally-unique
@@ -80,100 +269,82 @@ export function listMemoriesByProject(db, projectId) {
  * collisions as "skipped" rather than silently importing them.
  */
 export function listAllMemoryIds(db) {
-    const rows = db.prepare("SELECT id FROM memories").all();
+    const rows = getStatements(db).listAllIds.all();
     return new Set(rows.map((r) => r.id));
 }
 export function countMemoriesOlderThan(db, projectId, cutoffIso) {
     // created_at is stored as strftime('%Y-%m-%dT%H:%M:%fZ') text; lexicographic
     // comparison against an ISO-8601 UTC cutoff is correct for this fixed format.
-    const row = db
-        .prepare(`
-      SELECT COUNT(*) AS count
-      FROM memories
-      WHERE project_id = ? AND created_at < ?
-    `)
-        .get(projectId, cutoffIso);
+    const row = getStatements(db).countOlderThan.get(projectId, cutoffIso);
     return row.count;
 }
 export function deleteMemoriesOlderThan(db, projectId, cutoffIso) {
     // Hard-delete scoped to the memories table only; never touches
     // session_events or memory_feedback. project_id and cutoff are bound, never
     // string-concatenated, to prevent SQL injection.
-    const result = db
-        .prepare(`
-      DELETE FROM memories
-      WHERE project_id = ? AND created_at < ?
-    `)
-        .run(projectId, cutoffIso);
+    const result = getStatements(db).deleteOlderThan.run(projectId, cutoffIso);
     return result.changes;
 }
+// NOTE: no MCP tool, CLI command, or service method currently calls this. It is
+// retained as intentional repository API surface (the importance-update
+// counterpart to updateMemoryContent) for a future importance-adjustment tool,
+// not forgotten code. The `updateImportance` prepared statement above is wired
+// solely for this function. Keep or remove deliberately — do not delete on a
+// "looks unused" pass.
 export function updateMemoryImportance(db, projectId, memoryId, nextImportance, usedAt) {
     assertImportance(nextImportance);
-    const result = db
-        .prepare(`
-      UPDATE memories
-      SET
-        importance = ?,
-        updated_at = COALESCE(?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-      WHERE project_id = ? AND id = ?
-    `)
-        .run(nextImportance, usedAt ?? null, projectId, memoryId);
+    const result = getStatements(db).updateImportance.run(nextImportance, usedAt ?? null, projectId, memoryId);
     if (result.changes === 0) {
         throw new Error(`Memory not found: ${memoryId}`);
     }
 }
-export function updateMemoryContent(db, projectId, memoryId, newContent, newNormalizedContent) {
-    // In-place content rewrite for the one-time redaction scrub. All
-    // values are bound parameters — projectId, memoryId, and content are never
-    // string-concatenated — mirroring updateMemoryImportance to prevent SQL
-    // injection. normalized_content is only overwritten when a new
-    // value is supplied so embeddings stay consistent with the redacted text.
-    const result = db
-        .prepare(`
-      UPDATE memories
-      SET
-        content = ?,
-        normalized_content = COALESCE(?, normalized_content),
-        updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
-      WHERE project_id = ? AND id = ?
-    `)
-        .run(newContent, newNormalizedContent ?? null, projectId, memoryId);
+/**
+ * Count all memories stored in a project. Used to enforce per-session write
+ * soft limits — the count is
+ * checked before each storeMemory call and a warning is surfaced when the
+ * threshold is reached.
+ */
+export function countAllMemoriesByProject(db, projectId) {
+    const row = getStatements(db).countAll.get(projectId);
+    return row.count;
+}
+export function countMemoriesBySession(db, sessionId, projectId) {
+    const row = getStatements(db).countBySession.get(sessionId, projectId);
+    return row.count;
+}
+/**
+ * Count memories in a project whose embedding version differs from
+ * `currentVersion` (NULL counts as stale). Drives the startup re-embed hint;
+ * the fix is the `sessionmem re-embed` command.
+ */
+export function countStaleEmbeddings(db, projectId, currentVersion) {
+    const row = getStatements(db).countStaleEmbeddings.get(projectId, currentVersion);
+    return row.count;
+}
+export function updateMemoryContent(db, projectId, memoryId, newContent, newNormalizedContent, 
+// Optional re-embedding: when content is rewritten (e.g. a redactExisting
+// scrub) the stored embedding vector — computed from the PRE-edit text —
+// becomes stale and inconsistent with the new normalized_content. Pass the
+// recomputed embedding so the vector tracks the redacted text; omit to leave
+// the existing embedding untouched (COALESCE keeps the prior value on null).
+newEmbedding) {
+    const result = getStatements(db).updateContent.run(newContent, newNormalizedContent ?? null, newEmbedding ? JSON.stringify(newEmbedding.vector) : null, newEmbedding?.dimension ?? null, newEmbedding?.embeddingVersion ?? null, projectId, memoryId);
     if (result.changes === 0) {
         throw new Error(`Memory not found: ${memoryId}`);
     }
 }
-export function recordUse(db, input) {
-    const transaction = db.transaction((txInput) => {
-        const memory = db
-            .prepare(`
-        SELECT id, importance
-        FROM memories
-        WHERE project_id = ? AND id = ?
-        LIMIT 1
-      `)
-            .get(txInput.project_id, txInput.memory_id);
-        if (!memory) {
-            throw new Error(`Memory not found: ${txInput.memory_id}`);
+export function incrementAccessCounts(db, projectId, memoryIds, accessedAt) {
+    if (memoryIds.length === 0)
+        return;
+    const stmt = getStatements(db).incrementAccess;
+    const run = db.transaction(() => {
+        for (const id of memoryIds) {
+            stmt.run(accessedAt ?? null, projectId, id);
         }
-        const feedbackType = txInput.feedback_type ?? "auto_use";
-        const nextImportance = txInput.next_importance ??
-            (feedbackType === "auto_use"
-                ? Math.min(memory.importance + 1, 9)
-                : memory.importance);
-        updateMemoryImportance(db, txInput.project_id, txInput.memory_id, nextImportance, txInput.used_at);
-        insertMemoryFeedbackEvent(db, {
-            id: txInput.feedback_id,
-            memory_id: txInput.memory_id,
-            feedback_type: feedbackType,
-            previous_importance: memory.importance,
-            new_importance: nextImportance,
-            created_at: txInput.used_at,
-        });
-        return {
-            memory_id: txInput.memory_id,
-            previous_importance: memory.importance,
-            new_importance: nextImportance,
-        };
     });
-    return transaction(input);
+    run();
+}
+export function resetAccessCounts(db, projectId) {
+    const result = getStatements(db).resetAccess.run(projectId);
+    return result.changes;
 }

package/dist/core/storage/memorySearchRepo.js

@@ -1,3 +1,41 @@
+import { EMBEDDING_VERSION } from "../embed/embeddingVersion.js";
+const FTS_CANDIDATE_LIMIT = 50;
+const FTS_FALLBACK_THRESHOLD = 5;
+const searchStmtCache = new WeakMap();
+function getSearchStatements(db) {
+    let stmts = searchStmtCache.get(db);
+    if (stmts)
+        return stmts;
+    stmts = {
+        searchCandidates: db.prepare(`
+    SELECT
+      id, project_id, session_id, source_adapter, kind, content, normalized_content,
+      importance, author, origin_project_id, access_count, created_at, updated_at,
+      embedding, embedding_dim, embedding_version
+    FROM memories
+    WHERE project_id = ?
+      AND (
+        importance >= 8
+        OR updated_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-90 days')
+      )
+  `),
+        searchCandidatesFTS: db.prepare(`
+    SELECT
+      m.id, m.project_id, m.session_id, m.source_adapter, m.kind, m.content,
+      m.normalized_content, m.importance, m.author, m.origin_project_id,
+      m.access_count, m.created_at, m.updated_at,
+      m.embedding, m.embedding_dim, m.embedding_version
+    FROM memories_fts
+    JOIN memories m ON m.rowid = memories_fts.rowid
+    WHERE memories_fts MATCH ?
+      AND m.project_id = ?
+    ORDER BY rank
+    LIMIT ?
+  `),
+    };
+    searchStmtCache.set(db, stmts);
+    return stmts;
+}
 function parseEmbedding(value) {
     if (!value) {
         return null;
@@ -13,18 +51,92 @@ function parseEmbedding(value) {
         return null;
     }
 }
+function dedupById(candidates) {
+    // Defensive — FTS should not emit duplicates, but this guards backfill
+    // corruption (e.g. a double-run 008 migration) from inflating results.
+    const seen = new Set();
+    return candidates.filter((candidate) => {
+        if (seen.has(candidate.id))
+            return false;
+        seen.add(candidate.id);
+        return true;
+    });
+}
+function mapRows(rows) {
+    return rows.map((row) => {
+        const parsed = parseEmbedding(row.embedding);
+        const versionMatch = row.embedding_version === EMBEDDING_VERSION;
+        return {
+            ...row,
+            embedding: versionMatch ? parsed : null,
+        };
+    });
+}
 export function searchMemoryCandidates(db, projectId) {
-    const stmt = db.prepare(`
-    SELECT
-      id, project_id, session_id, source_adapter, kind, content, normalized_content,
-      importance, author, origin_project_id, created_at, updated_at, embedding,
-      embedding_dim, embedding_version
-    FROM memories
-    WHERE project_id = ?
-  `);
-    const rows = stmt.all(projectId);
-    return rows.map((row) => ({
-        ...row,
-        embedding: parseEmbedding(row.embedding),
-    }));
+    const rows = getSearchStatements(db).searchCandidates.all(projectId);
+    return mapRows(rows);
+}
+/**
+ * Sanitize query text for FTS5 MATCH syntax.
+ * Wraps each non-empty token in double quotes so special characters
+ * (colons, hyphens, parentheses, etc.) are treated as literals.
+ * Tokens are joined with implicit AND.
+ */
+function sanitizeFtsQuery(queryText) {
+    return queryText
+        .split(/\s+/)
+        .filter((token) => token.length > 0)
+        .map((token) => `"${token.replace(/"/g, '""')}"`)
+        .join(" ");
+}
+/**
+ * Pre-filter candidates using FTS5 full-text search before cosine similarity.
+ * Returns up to FTS_CANDIDATE_LIMIT candidates.
+ *
+ * FTS keyword overlap can be sparse, so the fallback recency/importance scan is
+ * UNIONed with (never substituted for) the FTS hits:
+ *  - >= FTS_FALLBACK_THRESHOLD FTS hits: use the FTS hits as-is (well-matched).
+ *  - 0 FTS hits: use the fallback scan only.
+ *  - 1..threshold-1 FTS hits: UNION the FTS hits with the fallback scan,
+ *    deduplicated by id (FTS hits first), capped at FTS_CANDIDATE_LIMIT.
+ *
+ * The previous behavior REPLACED a small FTS hit set with the fallback scan,
+ * which silently dropped genuine matches that were old (>90d) and low-importance
+ * (<8) — exactly the rows the fallback's filter excludes — returning zero
+ * candidates for a query that matched only such rows.
+ */
+export function searchMemoryCandidatesFTS(db, projectId, queryText) {
+    const sanitized = sanitizeFtsQuery(queryText);
+    if (!sanitized) {
+        return searchMemoryCandidates(db, projectId);
+    }
+    let rows;
+    try {
+        rows = getSearchStatements(db).searchCandidatesFTS.all(sanitized, projectId, FTS_CANDIDATE_LIMIT);
+    }
+    catch {
+        // FTS5 MATCH can throw on malformed queries — fall back to full scan
+        return searchMemoryCandidates(db, projectId);
+    }
+    if (rows.length >= FTS_FALLBACK_THRESHOLD) {
+        return dedupById(mapRows(rows));
+    }
+    const fallback = searchMemoryCandidates(db, projectId);
+    if (rows.length === 0) {
+        return fallback;
+    }
+    // UNION FTS hits (first) with the fallback scan, deduplicated by id and
+    // capped at the same total limit FTS would have returned.
+    const ftsHits = mapRows(rows);
+    const seen = new Set(ftsHits.map((candidate) => candidate.id));
+    const merged = [...ftsHits];
+    for (const candidate of fallback) {
+        if (merged.length >= FTS_CANDIDATE_LIMIT)
+            break;
+        if (seen.has(candidate.id))
+            continue;
+        seen.add(candidate.id);
+        merged.push(candidate);
+    }
+    return merged;
 }

package/dist/core/storage/sessionEventsRepo.js

@@ -1,20 +1,43 @@
-export function insertSessionEvent(db, input) {
-    const stmt = db.prepare(`
-    INSERT INTO session_events (
+const sessionEventsStmtCache = new WeakMap();
+function getSessionEventsStatements(db) {
+    let stmts = sessionEventsStmtCache.get(db);
+    if (stmts)
+        return stmts;
+    stmts = {
+        // INSERT OR IGNORE so re-ingesting an event with the same logical key
+        // (project_id, session_id, event_index) — now a UNIQUE index, migration 009
+        // — is a no-op rather than a duplicate row or a PK error.
+        insertEvent: db.prepare(`
+    INSERT OR IGNORE INTO session_events (
       id, project_id, session_id, event_index, event_type, payload_json, created_at
     ) VALUES (
       @id, @project_id, @session_id, @event_index, @event_type, @payload_json,
       COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
     )
-  `);
-    stmt.run(input);
-}
-export function listSessionEventsBySession(db, projectId, sessionId) {
-    const stmt = db.prepare(`
+  `),
+        listBySession: db.prepare(`
     SELECT id, project_id, session_id, event_index, event_type, payload_json, created_at
     FROM session_events
     WHERE project_id = ? AND session_id = ?
     ORDER BY event_index ASC
-  `);
-    return stmt.all(projectId, sessionId);
+  `),
+        countAll: db.prepare("SELECT COUNT(*) AS count FROM session_events WHERE project_id = ?"),
+    };
+    sessionEventsStmtCache.set(db, stmts);
+    return stmts;
+}
+/**
+ * Insert a session event. Returns the number of rows written (1, or 0 when the
+ * (project_id, session_id, event_index) key already exists and the insert was
+ * ignored).
+ */
+export function insertSessionEvent(db, input) {
+    return getSessionEventsStatements(db).insertEvent.run(input).changes;
+}
+export function countAllSessionEvents(db, projectId) {
+    const row = getSessionEventsStatements(db).countAll.get(projectId);
+    return row.count;
+}
+export function listSessionEventsBySession(db, projectId, sessionId) {
+    return getSessionEventsStatements(db).listBySession.all(projectId, sessionId);
 }