sessionmem 1.0.4 → 1.0.6

package/dist/core/retrieve/score.js

@@ -5,9 +5,19 @@ export const SCORING_WEIGHTS = {
     recency: 0.25,
     importance: 0.15,
 };
+export const ACCESS_BOOST_THRESHOLD = 3;
+export const ACCESS_BOOST_AMOUNT = 2;
+export function computeEffectiveImportance(storedImportance, accessCount) {
+    if (accessCount >= ACCESS_BOOST_THRESHOLD) {
+        return Math.min(storedImportance + ACCESS_BOOST_AMOUNT, 10);
+    }
+    return storedImportance;
+}
 export function scoreMemoryCandidate(candidate, now = new Date()) {
     const recency = getRecencyBandScore(candidate.updated_at, now);
-    const importance = normalizeImportance(candidate.importance);
+    const baseImportance = candidate.decayedImportance ?? candidate.importance;
+    const effectiveImportance = computeEffectiveImportance(baseImportance, candidate.access_count ?? 0);
+    const importance = normalizeImportance(effectiveImportance);
     const weighted = {
         semantic: candidate.semantic * SCORING_WEIGHTS.semantic,
         recency: recency * SCORING_WEIGHTS.recency,

package/dist/core/schema/migrations/005_team_provenance.sql

@@ -1,9 +1,9 @@
--- Team-mode provenance: record who authored each memory and, for
--- synced/shared rows, which project they originated in. Both columns are added
--- to the existing `memories` table without rewriting it so pre-existing rows
--- survive. `author` is NOT NULL with a DEFAULT '' sentinel because a
--- NOT NULL ADD COLUMN requires a default and the local OS username is not
--- available inside static SQL. `origin_project_id` is nullable and
--- only set on rows pulled in from another project's store.
-ALTER TABLE memories ADD COLUMN author TEXT NOT NULL DEFAULT '';
-ALTER TABLE memories ADD COLUMN origin_project_id TEXT;
+-- Team-mode provenance: record who authored each memory and, for
+-- synced/shared rows, which project they originated in. Both columns are added
+-- to the existing `memories` table without rewriting it so pre-existing rows
+-- survive. `author` is NOT NULL with a DEFAULT '' sentinel because a
+-- NOT NULL ADD COLUMN requires a default and the local OS username is not
+-- available inside static SQL. `origin_project_id` is nullable and
+-- only set on rows pulled in from another project's store.
+ALTER TABLE memories ADD COLUMN author TEXT NOT NULL DEFAULT '';
+ALTER TABLE memories ADD COLUMN origin_project_id TEXT;

package/dist/core/schema/migrations/006_access_pattern_boosting.sql

@@ -0,0 +1,5 @@
+-- Access-pattern boosting: track how often each memory is included in
+-- retrieval output. access_count drives a read-time effective_importance
+-- boost without mutating the stored importance score.
+ALTER TABLE memories ADD COLUMN access_count INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE memories ADD COLUMN last_accessed TEXT;

package/dist/core/schema/migrations/007_feedback_manual_delete.sql

@@ -0,0 +1,23 @@
+-- Allow 'manual_delete' feedback_type and new_importance = 0 for deletion records.
+-- Remove FOREIGN KEY CASCADE so feedback rows survive when a memory is deleted.
+-- SQLite requires table recreation to alter CHECK constraints and FK behavior.
+
+CREATE TABLE IF NOT EXISTS memory_feedback_new (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL,
+  feedback_type TEXT NOT NULL CHECK (feedback_type IN ('auto_use', 'manual', 'manual_delete')),
+  previous_importance INTEGER NOT NULL CHECK (previous_importance >= 0 AND previous_importance <= 10),
+  new_importance INTEGER NOT NULL CHECK (new_importance >= 0 AND new_importance <= 10),
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+INSERT OR IGNORE INTO memory_feedback_new (id, memory_id, feedback_type, previous_importance, new_importance, created_at)
+  SELECT id, memory_id, feedback_type, previous_importance, new_importance, created_at
+  FROM memory_feedback;
+
+DROP TABLE memory_feedback;
+
+ALTER TABLE memory_feedback_new RENAME TO memory_feedback;
+
+CREATE INDEX IF NOT EXISTS idx_memory_feedback_memory_created
+ON memory_feedback(memory_id, created_at DESC);

package/dist/core/schema/migrations/008_fts5_search.sql

@@ -0,0 +1,33 @@
+-- FTS5 full-text search index on memory content for candidate pre-filtering.
+-- Using content-sync (external content) mode: the FTS index mirrors the
+-- memories table without duplicating storage. Triggers keep it in sync.
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+  content,
+  normalized_content,
+  content='memories',
+  content_rowid='rowid'
+);
+
+-- Populate FTS index from existing rows
+INSERT INTO memories_fts(rowid, content, normalized_content)
+  SELECT rowid, content, normalized_content FROM memories;
+
+-- Keep FTS index in sync: INSERT trigger
+CREATE TRIGGER IF NOT EXISTS memories_fts_insert AFTER INSERT ON memories BEGIN
+  INSERT INTO memories_fts(rowid, content, normalized_content)
+    VALUES (new.rowid, new.content, new.normalized_content);
+END;
+
+-- Keep FTS index in sync: DELETE trigger
+CREATE TRIGGER IF NOT EXISTS memories_fts_delete AFTER DELETE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, content, normalized_content)
+    VALUES ('delete', old.rowid, old.content, old.normalized_content);
+END;
+
+-- Keep FTS index in sync: UPDATE trigger (content or normalized_content changed)
+CREATE TRIGGER IF NOT EXISTS memories_fts_update AFTER UPDATE OF content, normalized_content ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, content, normalized_content)
+    VALUES ('delete', old.rowid, old.content, old.normalized_content);
+  INSERT INTO memories_fts(rowid, content, normalized_content)
+    VALUES (new.rowid, new.content, new.normalized_content);
+END;

package/dist/core/storage/db.js

@@ -2,7 +2,13 @@ import BetterSqlite3 from "better-sqlite3";
 import { runMigrations } from "../schema/runMigrations.js";
 export function openDb(options = {}) {
     const db = new BetterSqlite3(options.dbPath ?? ":memory:");
+    // Performance pragmas — WAL enables concurrent reads during writes;
+    // busy_timeout prevents SQLITE_BUSY under concurrent MCP tool calls.
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
     db.pragma("foreign_keys = ON");
+    db.pragma("busy_timeout = 5000");
+    db.pragma("cache_size = -32000");
     runMigrations(db, options.migrationsDir);
     return db;
 }

package/dist/core/storage/memoryFeedbackRepo.js

@@ -1,14 +1,24 @@
 import { randomUUID } from "node:crypto";
-export function insertMemoryFeedbackEvent(db, event) {
-    const stmt = db.prepare(`
+const feedbackStmtCache = new WeakMap();
+function getFeedbackStatements(db) {
+    let stmts = feedbackStmtCache.get(db);
+    if (stmts)
+        return stmts;
+    stmts = {
+        insertFeedback: db.prepare(`
     INSERT INTO memory_feedback (
       id, memory_id, feedback_type, previous_importance, new_importance, created_at
     ) VALUES (
       @id, @memory_id, @feedback_type, @previous_importance, @new_importance,
       COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
     )
-  `);
-    stmt.run({
+  `),
+    };
+    feedbackStmtCache.set(db, stmts);
+    return stmts;
+}
+export function insertMemoryFeedbackEvent(db, event) {
+    getFeedbackStatements(db).insertFeedback.run({
         ...event,
         id: event.id ?? randomUUID(),
         created_at: event.created_at ?? null,

package/dist/core/storage/memoryRepo.js

@@ -1,4 +1,107 @@
-import { insertMemoryFeedbackEvent, } from "./memoryFeedbackRepo.js";
+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'))
+  `),
+        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
+  `),
+        listAllIds: db.prepare("SELECT id FROM memories"),
+        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),
+        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 = ?
+    `),
+    };
+    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 +121,14 @@ 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" }));
 }
 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);
 }
 /**
  * All memory ids across every project. `id` is a globally-unique
@@ -80,100 +137,57 @@ 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;
 }
 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}`);
     }
 }
+/**
+ * Count the number of memories stored under a given session_id across all
+ * projects. 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 countMemoriesBySession(db, sessionId) {
+    const row = getStatements(db).countBySession.get(sessionId);
+    return row.count;
+}
 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);
+    const result = getStatements(db).updateContent.run(newContent, newNormalizedContent ?? 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 > datetime('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,54 @@ function parseEmbedding(value) {
         return null;
     }
 }
+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 top-50 candidates by FTS rank. Falls back to full
+ * searchMemoryCandidates when FTS returns fewer than 5 results
+ * (poor keyword overlap).
+ */
+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 searchMemoryCandidates(db, projectId);
+    }
+    return mapRows(rows);
 }

package/dist/core/storage/sessionEventsRepo.js

@@ -1,20 +1,30 @@
-export function insertSessionEvent(db, input) {
-    const stmt = db.prepare(`
+const sessionEventsStmtCache = new WeakMap();
+function getSessionEventsStatements(db) {
+    let stmts = sessionEventsStmtCache.get(db);
+    if (stmts)
+        return stmts;
+    stmts = {
+        insertEvent: db.prepare(`
     INSERT 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);
+  `),
+    };
+    sessionEventsStmtCache.set(db, stmts);
+    return stmts;
+}
+export function insertSessionEvent(db, input) {
+    getSessionEventsStatements(db).insertEvent.run(input);
+}
+export function listSessionEventsBySession(db, projectId, sessionId) {
+    return getSessionEventsStatements(db).listBySession.all(projectId, sessionId);
 }