opencode-episodic-memory 0.1.2 → 0.2.0

package/src/store.ts

@@ -1,9 +1,14 @@
 // Index database: plain SQLite (bun:sqlite). Embeddings stored as Float32
-// blobs; similarity is brute-force cosine in JS. At our scale (tens of
+// blobs; vector similarity is brute-force cosine in JS. At our scale (tens of
 // thousands of chunks) this is single-digit milliseconds per query and has
 // zero native-extension risk. (sqlite-vec was rejected in Phase 0: bun:sqlite
 // cannot load dynamic extensions. Swap in a vec0 backend here if scale ever
 // demands it.)
+//
+// Lexical retrieval uses SQLite's built-in FTS5 (compiled into bun:sqlite —
+// verified in spikes/fts5-check.ts; it's a static module, NOT a loadable
+// extension, so the sqlite-vec limitation doesn't apply). search() fuses the
+// vector and BM25 rankings via reciprocal rank fusion.
 import { Database } from "bun:sqlite";
 import { mkdirSync } from "node:fs";
 import { homedir } from "node:os";
@@ -11,6 +16,13 @@ import { dirname, join } from "node:path";
 
 export const DEFAULT_INDEX_DB = join(homedir(), ".local/share/opencode-episodic-memory/index.db");
 
+// Bump when the FTS schema changes to force a one-time rebuild on next open.
+const FTS_SCHEMA_VERSION = 1;
+// Reciprocal rank fusion constant (standard default) and how deep into each
+// ranked list fusion looks — contributions past this depth are negligible.
+const RRF_K = 60;
+const FUSE_DEPTH = 200;
+
 export function indexDbPath(): string {
   return process.env.EPISODIC_INDEX_DB ?? DEFAULT_INDEX_DB;
 }
@@ -39,9 +51,45 @@ export function openIndex(path: string = indexDbPath()): Database {
     PRIMARY KEY (session_id, seq)
   )`);
   db.run("CREATE INDEX IF NOT EXISTS chunks_time_idx ON chunks(time_created)");
+
+  // Full-text index over chunk text. External content (content='chunks') means
+  // the text isn't duplicated; the FTS index is kept in sync by triggers on
+  // chunks — robust to any write path (not just replaceSessionChunks), which is
+  // the standard SQLite pattern for external-content FTS5.
+  //
+  // WARNING — never VACUUM this DB. content_rowid rides chunks' IMPLICIT rowid
+  // (the PK is (session_id, seq), so there is no explicit INTEGER PRIMARY KEY
+  // alias for rowid). VACUUM may renumber implicit rowids, which would silently
+  // misalign every FTS posting from its chunk row. If VACUUM ever becomes
+  // necessary, give chunks an explicit `rowid INTEGER PRIMARY KEY` first (a
+  // migration) — do not just run it. See AGENTS.md.
+  db.run("CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(text, content='chunks', content_rowid='rowid')");
+  db.run(`CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+    INSERT INTO chunks_fts(rowid, text) VALUES (new.rowid, new.text);
+  END`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+    INSERT INTO chunks_fts(chunks_fts, rowid, text) VALUES('delete', old.rowid, old.text);
+  END`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
+    INSERT INTO chunks_fts(chunks_fts, rowid, text) VALUES('delete', old.rowid, old.text);
+    INSERT INTO chunks_fts(rowid, text) VALUES (new.rowid, new.text);
+  END`);
+  migrateFts(db);
   return db;
 }
 
+// One-time FTS backfill for index DBs created before FTS existed: they have
+// chunks but an empty FTS index. COUNT(*) on an external-content FTS returns the
+// content-row count (can't reveal "not indexed"), so gate on PRAGMA user_version
+// instead. 'rebuild' repopulates from chunks and is a no-op on a fresh/empty DB.
+function migrateFts(db: Database): void {
+  const version = db.prepare<{ user_version: number }, []>("PRAGMA user_version").get()?.user_version ?? 0;
+  if (version < FTS_SCHEMA_VERSION) {
+    db.run("INSERT INTO chunks_fts(chunks_fts) VALUES('rebuild')");
+    db.run(`PRAGMA user_version = ${FTS_SCHEMA_VERSION}`);
+  }
+}
+
 export interface IndexedSession {
   id: string;
   project_id: string;
@@ -102,32 +150,56 @@ export interface SearchOptions {
   limit?: number;
   after?: number; // ms epoch
   before?: number; // ms epoch
-  text?: string; // exact substring filter (ANDed with vector ranking)
+  text?: string; // exact substring filter (ANDed with ranking)
   minScore?: number;
+  // Raw natural-language query for the BM25/lexical arm of hybrid search
+  // (used only together with hybrid: true).
+  queryText?: string;
+  // Opt in to hybrid (vector + BM25 fused via RRF) retrieval. Default is pure
+  // vector: on this corpus BM25 tends to match injected boilerplate (e.g.
+  // [MEMORY] preamble), so fusion is offered, not forced (see AGENTS.md).
+  // Requires queryText.
+  hybrid?: boolean;
 }
 
-export function search(db: Database, queryVec: Float32Array, opts: SearchOptions = {}): SearchHit[] {
-  const limit = opts.limit ?? 10;
+// A scored candidate before display fields are fetched (phase 1 output).
+interface ScoredChunk {
+  session_id: string;
+  seq: number;
+  time_created: number;
+  score: number;
+}
+
+// Shared time/text filter clauses (no leading WHERE). `after`/`before` use
+// `!== undefined` (not truthiness) so a legitimate epoch-0 bound isn't dropped
+// as "absent". `text` keeps a truthiness check: an empty substring filter is a
+// no-op, not a match-everything `LIKE '%%'`. Reused by the vector, BM25, and
+// LIKE-fallback candidate scans so the three stay filter-consistent.
+function filterClauses(opts: SearchOptions): { clauses: string[]; params: (string | number)[] } {
   const clauses: string[] = [];
   const params: (string | number)[] = [];
-  if (opts.after) { clauses.push("c.time_created >= ?"); params.push(opts.after); }
-  if (opts.before) { clauses.push("c.time_created < ?"); params.push(opts.before); }
+  if (opts.after !== undefined) { clauses.push("c.time_created >= ?"); params.push(opts.after); }
+  if (opts.before !== undefined) { clauses.push("c.time_created < ?"); params.push(opts.before); }
   if (opts.text) { clauses.push("c.text LIKE ? ESCAPE '\\'"); params.push(`%${escapeLike(opts.text)}%`); }
-  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  return { clauses, params };
+}
 
-  const rows = db
-    .prepare<{
-      session_id: string; seq: number; time_created: number; text: string;
-      embedding: Uint8Array; title: string; directory: string;
-    }, (string | number)[]>(
-      `SELECT c.session_id, c.seq, c.time_created, c.text, c.embedding, s.title, s.directory
-       FROM chunks c JOIN sessions s ON s.id = c.session_id ${where}`
+// Phase 1 (vector): score every candidate chunk by cosine against the query,
+// apply the filters + minScore, and return them sorted best-first. Reads only
+// the embedding blob (not the bulky text/title/directory), so the per-query
+// cost is dims arithmetic, not full-row materialization.
+function scoreVector(db: Database, queryVec: Float32Array, opts: SearchOptions): ScoredChunk[] {
+  const { clauses, params } = filterClauses(opts);
+  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  const candidates = db
+    .prepare<{ session_id: string; seq: number; time_created: number; embedding: Uint8Array }, (string | number)[]>(
+      `SELECT c.session_id, c.seq, c.time_created, c.embedding FROM chunks c ${where}`
     )
     .all(...params);
 
   const dims = queryVec.length;
   const minScore = opts.minScore ?? 0;
-  return rows
+  return candidates
     // Skip vectors from a different embedding model (e.g. mid-migration or
     // orphaned rows) — a dims mismatch would corrupt the dot product or throw.
     .filter((r) => r.embedding.byteLength === dims * 4)
@@ -135,30 +207,147 @@ export function search(db: Database, queryVec: Float32Array, opts: SearchOptions
       const v = new Float32Array(r.embedding.buffer, r.embedding.byteOffset, dims);
       let dot = 0;
       for (let i = 0; i < dims; i++) dot += queryVec[i] * v[i];
-      return {
-        session_id: r.session_id, seq: r.seq, time_created: r.time_created,
-        text: r.text, score: dot, title: r.title, directory: r.directory,
-      };
+      return { session_id: r.session_id, seq: r.seq, time_created: r.time_created, score: dot };
     })
     .filter((h) => h.score >= minScore)
-    .sort((a, b) => b.score - a.score)
-    .slice(0, limit);
+    .sort((a, b) => b.score - a.score);
 }
 
-export function textSearch(db: Database, query: string, opts: SearchOptions = {}): SearchHit[] {
-  const limit = opts.limit ?? 10;
-  const clauses = ["c.text LIKE ? ESCAPE '\\'"];
-  const params: (string | number)[] = [`%${escapeLike(query)}%`];
-  if (opts.after) { clauses.push("c.time_created >= ?"); params.push(opts.after); }
-  if (opts.before) { clauses.push("c.time_created < ?"); params.push(opts.before); }
+// Phase 2: fetch display fields (text/title/directory) only for the winners —
+// a point lookup per hit on the (session_id, seq) primary key. K is bounded by
+// the caller's limit (≤ 50 in the plugin), so this is a tiny handful of reads.
+function hydrate(db: Database, scored: ScoredChunk[]): SearchHit[] {
+  const detail = db.prepare<{ text: string; title: string; directory: string }, [string, number]>(
+    `SELECT c.text, s.title, s.directory
+     FROM chunks c JOIN sessions s ON s.id = c.session_id
+     WHERE c.session_id = ? AND c.seq = ?`
+  );
+  const hits: SearchHit[] = [];
+  for (const h of scored) {
+    const d = detail.get(h.session_id, h.seq);
+    // Inner-join semantics: skip a chunk whose session row is gone (shouldn't
+    // happen — replaceSessionChunks/pruneOrphans keep chunks and sessions in
+    // lockstep).
+    if (!d) continue;
+    hits.push({
+      session_id: h.session_id, seq: h.seq, time_created: h.time_created,
+      text: d.text, score: h.score, title: d.title, directory: d.directory,
+    });
+  }
+  return hits;
+}
+
+// Turn a raw user query into a safe FTS5 MATCH expression: each whitespace-
+// separated token is wrapped as a quoted string (internal quotes doubled). This
+// neutralizes FTS operators (AND/OR/NOT/NEAR) and syntax chars in user input —
+// they become literal search terms, never MATCH syntax — while preserving
+// implicit-AND semantics across tokens. Empty input yields "" (→ no match).
+function ftsQueryString(query: string): string {
+  return query
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((t) => `"${t.replace(/"/g, '""')}"`)
+    .join(" ");
+}
+
+// Phase 1 (lexical): rank candidate chunks by BM25 over the FTS index, applying
+// the shared filters. Returns best-first with score = -bm25 (bm25 is
+// smaller-is-better/negative, so negating gives the higher-is-better convention
+// used by the vector score). Falls back to a LIKE substring scan only if the
+// MATCH expression is somehow still a syntax error.
+function scoreFts(db: Database, query: string, opts: SearchOptions, depth: number): ScoredChunk[] {
+  const match = ftsQueryString(query);
+  if (!match) return [];
+  const { clauses, params } = filterClauses(opts);
+  const where = ["chunks_fts MATCH ?", ...clauses].join(" AND ");
+  try {
+    const rows = db
+      .prepare<{ session_id: string; seq: number; time_created: number; rank: number }, (string | number)[]>(
+        `SELECT c.session_id, c.seq, c.time_created, bm25(chunks_fts) AS rank
+         FROM chunks_fts JOIN chunks c ON c.rowid = chunks_fts.rowid
+         WHERE ${where} ORDER BY rank LIMIT ?`
+      )
+      .all(match, ...params, depth);
+    return rows.map((r) => ({ session_id: r.session_id, seq: r.seq, time_created: r.time_created, score: -r.rank }));
+  } catch (e) {
+    // Degrade to the unranked LIKE scan ONLY for a malformed MATCH expression.
+    // ftsQueryString fully quotes every token, so this is defensive/near-dead —
+    // but a different SqliteError (e.g. a corrupt/missing FTS index) must NOT be
+    // masked as "no ranking"; rethrow it so the real failure surfaces.
+    if (e instanceof Error && e.message.includes("fts5: syntax error")) {
+      return scoreLike(db, query, opts, depth);
+    }
+    throw e;
+  }
+}
+
+// LIKE substring fallback for scoreFts. Order by recency (the pre-FTS textSearch
+// behavior); score is a constant since substring match has no ranking signal.
+function scoreLike(db: Database, query: string, opts: SearchOptions, depth: number): ScoredChunk[] {
+  const { clauses, params } = filterClauses(opts);
+  const where = ["c.text LIKE ? ESCAPE '\\'", ...clauses].join(" AND ");
   const rows = db
-    .prepare<Omit<SearchHit, "score">, (string | number)[]>(
-      `SELECT c.session_id, c.seq, c.time_created, c.text, s.title, s.directory
-       FROM chunks c JOIN sessions s ON s.id = c.session_id
-       WHERE ${clauses.join(" AND ")} ORDER BY c.time_created DESC LIMIT ?`
+    .prepare<{ session_id: string; seq: number; time_created: number }, (string | number)[]>(
+      `SELECT c.session_id, c.seq, c.time_created FROM chunks c
+       WHERE ${where} ORDER BY c.time_created DESC LIMIT ?`
     )
-    .all(...params, limit);
-  return rows.map((r) => ({ ...r, score: 1 }));
+    .all(`%${escapeLike(query)}%`, ...params, depth);
+  return rows.map((r) => ({ session_id: r.session_id, seq: r.seq, time_created: r.time_created, score: 1 }));
+}
+
+// Reciprocal rank fusion: combine several best-first ranked lists into one.
+// Each list contributes 1/(k + rank) per item (rank 1-based); scores sum across
+// lists, so an item ranked well by either signal surfaces. Ties/overlap dedupe
+// by (session_id, seq).
+function reciprocalRankFusion(lists: ScoredChunk[][], k: number = RRF_K): ScoredChunk[] {
+  const fused = new Map<string, { chunk: ScoredChunk; score: number }>();
+  for (const list of lists) {
+    list.forEach((c, i) => {
+      const key = `${c.session_id}\u0000${c.seq}`;
+      const contribution = 1 / (k + i + 1);
+      const existing = fused.get(key);
+      if (existing) existing.score += contribution;
+      else fused.set(key, { chunk: c, score: contribution });
+    });
+  }
+  return [...fused.values()]
+    .map((e) => ({ ...e.chunk, score: e.score }))
+    .sort((a, b) => b.score - a.score);
+}
+
+// Pure vector search by default. Opt in to hybrid retrieval (vector + BM25
+// fused via RRF) with hybrid: true + queryText. Pure vector is the default
+// because, empirically on this corpus, the BM25 arm surfaces boilerplate noise
+// and drags relevant semantic hits down (see AGENTS.md). minScore is applied to
+// the vector scores BEFORE fusion (its calibration is cosine, not BM25).
+export function search(db: Database, queryVec: Float32Array, opts: SearchOptions = {}): SearchHit[] {
+  const limit = opts.limit ?? 10;
+  const vector = scoreVector(db, queryVec, opts);
+
+  const queryText = opts.hybrid === true ? opts.queryText : undefined;
+  if (queryText === undefined || queryText.length === 0) {
+    return hydrate(db, vector.slice(0, limit));
+  }
+
+  const lexical = scoreFts(db, queryText, opts, FUSE_DEPTH);
+  const fused = reciprocalRankFusion([vector.slice(0, FUSE_DEPTH), lexical]);
+  return hydrate(db, fused.slice(0, limit));
+}
+
+// Lexical BM25 search. NOTE the behavior change from the pre-FTS LIKE
+// implementation: an empty or whitespace-only query now returns [] (the FTS
+// MATCH expression is empty → matches nothing), whereas the old LIKE '%%' scan
+// returned the most recent chunks. Callers wanting "recent" must query for it.
+export function textSearch(db: Database, query: string, opts: SearchOptions = {}): SearchHit[] {
+  const limit = opts.limit ?? 10;
+  return hydrate(db, scoreFts(db, query, opts, limit));
+}
+
+// Cheap "is there anything to search?" check. Shared by the CLI and the plugin
+// so their empty-index messaging stays consistent (a single COUNT, not the full
+// stats() roll-up).
+export function isIndexEmpty(db: Database): boolean {
+  return (db.prepare<{ n: number }, []>("SELECT COUNT(*) n FROM chunks").get()?.n ?? 0) === 0;
 }
 
 export interface IndexStats {

package/src/parser.test.ts

@@ -1,64 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { parseTranscript, exchangeText, EXCLUDE_MARKER } from "./parser";
-import type { SourceMessage } from "./reader";
-
-const msg = (role: string, timeCreated: number, parts: SourceMessage["parts"]): SourceMessage =>
-  ({ id: `${role}-${timeCreated}`, role, timeCreated, parts });
-
-describe("parseTranscript", () => {
-  test("builds exchanges from user/assistant pairs with tool names", () => {
-    const { exchanges, excluded } = parseTranscript([
-      msg("assistant", 1, [{ type: "text", text: "dropped: no user context" }]),
-      msg("user", 2, [{ type: "text", text: "how do I fix the redirect?" }]),
-      msg("assistant", 3, [
-        { type: "reasoning", text: "thinking..." },
-        { type: "text", text: "Change the callback URL." },
-        { type: "tool", tool: "edit" },
-        { type: "tool", tool: "bash" },
-      ]),
-      msg("user", 4, [{ type: "text", text: "thanks" }]),
-      msg("assistant", 5, [{ type: "text", text: "anytime" }]),
-    ]);
-    expect(excluded).toBe(false);
-    expect(exchanges).toHaveLength(2);
-    expect(exchanges[0].user).toBe("how do I fix the redirect?");
-    expect(exchanges[0].assistant).toBe("Change the callback URL.");
-    expect(exchanges[0].tools).toEqual(["edit", "bash"]);
-    expect(exchanges[1].tools).toEqual([]);
-  });
-
-  test("user turns without text are skipped", () => {
-    const { exchanges } = parseTranscript([
-      msg("user", 1, [{ type: "tool", tool: "read" }]), // pure tool-result turn
-      msg("user", 2, [{ type: "text", text: "real question" }]),
-    ]);
-    expect(exchanges).toHaveLength(1);
-    expect(exchanges[0].user).toBe("real question");
-  });
-
-  test("exclusion marker anywhere opts out the whole transcript", () => {
-    const { exchanges, excluded } = parseTranscript([
-      msg("user", 1, [{ type: "text", text: "hi" }]),
-      msg("assistant", 2, [{ type: "text", text: `note: ${EXCLUDE_MARKER}` }]),
-    ]);
-    expect(excluded).toBe(true);
-    expect(exchanges).toHaveLength(0);
-  });
-});
-
-describe("exchangeText", () => {
-  test("includes date, title, participants, deduped tools", () => {
-    const text = exchangeText("My session", "2026-07-22", {
-      user: "q", assistant: "a", tools: ["bash", "bash", "edit"], time: 0,
-    });
-    expect(text).toStartWith("2026-07-22 — My session\nUser: q\nAssistant: a");
-    expect(text).toContain("Tools used: bash, edit");
-  });
-
-  test("caps at 4000 chars", () => {
-    const text = exchangeText("t", "2026-07-22", {
-      user: "x".repeat(10000), assistant: "", tools: [], time: 0,
-    });
-    expect(text.length).toBe(4000);
-  });
-});

package/src/reader.test.ts

@@ -1,205 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { Database } from "bun:sqlite";
-import { listSessions, getSession, getTranscript, transcriptHasMarker, EXCLUDE_MARKER } from "./reader";
-
-// A minimal opencode.db mirroring only the columns reader.ts SELECTs. Writable
-// here so we can seed rows; the reader functions take a Database and never write.
-function makeSource(): Database {
-  const db = new Database(":memory:");
-  db.run(`CREATE TABLE session (
-    id TEXT, project_id TEXT, parent_id TEXT, title TEXT, directory TEXT,
-    time_created INTEGER, time_updated INTEGER, time_archived INTEGER
-  )`);
-  db.run(`CREATE TABLE message (
-    id TEXT, session_id TEXT, time_created INTEGER, data TEXT
-  )`);
-  db.run(`CREATE TABLE part (
-    id TEXT, message_id TEXT, session_id TEXT, time_created INTEGER, data TEXT
-  )`);
-  return db;
-}
-
-function addSession(db: Database, s: {
-  id: string; parent_id?: string | null; title?: string;
-  time_created?: number; time_updated?: number; time_archived?: number | null;
-}): void {
-  db.run(
-    `INSERT INTO session (id, project_id, parent_id, title, directory, time_created, time_updated, time_archived)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-    [s.id, "proj", s.parent_id ?? null, s.title ?? "Title", "/dir",
-     s.time_created ?? 1000, s.time_updated ?? 1000, s.time_archived ?? null]
-  );
-}
-function addMessage(db: Database, id: string, sessionId: string, time: number, data: string): void {
-  db.run("INSERT INTO message (id, session_id, time_created, data) VALUES (?, ?, ?, ?)",
-    [id, sessionId, time, data]);
-}
-function addPart(db: Database, id: string, messageId: string, sessionId: string, time: number, data: string): void {
-  db.run("INSERT INTO part (id, message_id, session_id, time_created, data) VALUES (?, ?, ?, ?, ?)",
-    [id, messageId, sessionId, time, data]);
-}
-
-describe("listSessions / getSession (structural rows)", () => {
-  test("lists active sessions ordered by time_created, excludes archived", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_b", time_created: 2000 });
-    addSession(db, { id: "ses_a", time_created: 1000, parent_id: "ses_b" });
-    addSession(db, { id: "ses_arch", time_created: 1500, time_archived: 9999 });
-    const sessions = listSessions(db);
-    expect(sessions.map((s) => s.id)).toEqual(["ses_a", "ses_b"]);
-    expect(sessions[0].parent_id).toBe("ses_b");
-    expect(sessions[1].parent_id).toBeNull();
-  });
-
-  test("getSession returns a row, or null for an unknown id", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a", title: "Hello" });
-    expect(getSession(db, "ses_a")?.title).toBe("Hello");
-    expect(getSession(db, "nope")).toBeNull();
-  });
-
-  test("throws (does not silently mis-read) when a structural column drifts", () => {
-    const db = makeSource();
-    // time_created NULL violates z.number() — simulates OpenCode schema drift.
-    db.run(
-      `INSERT INTO session (id, project_id, parent_id, title, directory, time_created, time_updated, time_archived)
-       VALUES ('ses_x', 'p', NULL, 't', '/d', NULL, 1000, NULL)`
-    );
-    expect(() => listSessions(db)).toThrow();
-  });
-
-  test("getSession throws on a drifted session row for an existing id", () => {
-    const db = makeSource();
-    // title NULL violates z.string() — simulates OpenCode schema drift.
-    db.run(
-      `INSERT INTO session (id, project_id, parent_id, title, directory, time_created, time_updated, time_archived)
-       VALUES ('ses_y', 'p', NULL, NULL, '/d', 1000, 1000, NULL)`
-    );
-    expect(() => getSession(db, "ses_y")).toThrow();
-  });
-});
-
-describe("getTranscript (JSON blob degradation)", () => {
-  test("parses roles and part fields; degrades malformed blobs per-row", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    addMessage(db, "m1", "ses_a", 1, `{"role":"user"}`);
-    addMessage(db, "m2", "ses_a", 2, `{"role":"assistant"}`);
-    addMessage(db, "m3", "ses_a", 3, `{not valid json`);   // role -> "unknown"
-    addMessage(db, "m4", "ses_a", 4, `{"noRole":true}`);    // role -> "unknown"
-
-    addPart(db, "p1", "m1", "ses_a", 1, `{"type":"text","text":"hello"}`);
-    addPart(db, "p2", "m1", "ses_a", 2, `{"type":"tool","tool":"edit"}`);
-    addPart(db, "p3", "m2", "ses_a", 3, `{oops not json`);          // -> {type:"unknown"}
-    addPart(db, "p4", "m2", "ses_a", 4, `{"type":123,"text":"keep"}`); // type->unknown, text kept
-    addPart(db, "p5", "m4", "ses_a", 5, `42`);                       // non-object -> {type:"unknown"}
-
-    const t = getTranscript(db, "ses_a");
-    expect(t.map((m) => m.role)).toEqual(["user", "assistant", "unknown", "unknown"]);
-
-    expect(t[0].parts).toEqual([
-      { type: "text", text: "hello" },
-      { type: "tool", tool: "edit" },
-    ]);
-    expect(t[1].parts).toEqual([
-      { type: "unknown" },
-      { type: "unknown", text: "keep" },
-    ]);
-    expect(t[3].parts).toEqual([{ type: "unknown" }]);
-  });
-
-  test("per-field catch: bad text/tool fields are dropped, type is preserved", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    addMessage(db, "m1", "ses_a", 1, `{"role":"user"}`);
-    addPart(db, "p1", "m1", "ses_a", 1, `{"type":"text","text":123}`); // bad text dropped
-    addPart(db, "p2", "m1", "ses_a", 2, `{"type":"tool","tool":123}`); // bad tool dropped
-
-    const t = getTranscript(db, "ses_a");
-    expect(t[0].parts).toEqual([{ type: "text" }, { type: "tool" }]);
-  });
-
-  test("throws when a part row's data column is non-string (structural drift)", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    // Valid message first so the message-row parse passes and the throw comes
-    // from the part row below.
-    addMessage(db, "m1", "ses_a", 1, `{"role":"user"}`);
-    db.run("INSERT INTO part (id, message_id, session_id, time_created, data) VALUES ('p1', 'm1', 'ses_a', 1, NULL)");
-    expect(() => getTranscript(db, "ses_a")).toThrow();
-  });
-
-  test("throws when a message row's data column is non-string (structural drift)", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    // data NULL violates the row schema's z.string(); structural, so it throws.
-    db.run("INSERT INTO message (id, session_id, time_created, data) VALUES ('m1', 'ses_a', 1, NULL)");
-    expect(() => getTranscript(db, "ses_a")).toThrow();
-  });
-});
-
-describe("transcriptHasMarker (raw blob scan)", () => {
-  test("detects the marker in a well-formed text part", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    addMessage(db, "m1", "ses_a", 1, `{"role":"user"}`);
-    addPart(db, "p1", "m1", "ses_a", 1, `{"type":"text","text":"note: ${EXCLUDE_MARKER}"}`);
-    expect(transcriptHasMarker(db, "ses_a")).toBe(true);
-  });
-
-  // Regression for issue #10: the parsed-text scan degrades this blob to
-  // text: undefined, so the marker is invisible to hasExcludeMarker — but the
-  // raw scan must still see it. The privacy kill-switch must not depend on
-  // blob parseability.
-  test("detects the marker inside a malformed/unparseable part blob", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    addMessage(db, "m1", "ses_a", 1, `{"role":"user"}`);
-    addPart(db, "p1", "m1", "ses_a", 1, `{oops not json ${EXCLUDE_MARKER}`);
-
-    // Sanity: the parsed view really does lose the marker text.
-    const t = getTranscript(db, "ses_a");
-    expect(t[0].parts).toEqual([{ type: "unknown" }]);
-
-    expect(transcriptHasMarker(db, "ses_a")).toBe(true);
-  });
-
-  test("detects the marker in a blob whose fields all fail validation", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    addMessage(db, "m1", "ses_a", 1, `{"role":"user"}`);
-    // Valid JSON, but type is non-string → degrades to {type:"unknown"}.
-    addPart(db, "p1", "m1", "ses_a", 1, `{"type":123,"note":"${EXCLUDE_MARKER}"}`);
-
-    const t = getTranscript(db, "ses_a");
-    expect(t[0].parts).toEqual([{ type: "unknown" }]);
-    expect(transcriptHasMarker(db, "ses_a")).toBe(true);
-  });
-
-  test("returns false when no part contains the marker", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    addMessage(db, "m1", "ses_a", 1, `{"role":"user"}`);
-    addPart(db, "p1", "m1", "ses_a", 1, `{"type":"text","text":"hello"}`);
-    expect(transcriptHasMarker(db, "ses_a")).toBe(false);
-  });
-
-  test("is scoped to the requested session", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    addSession(db, { id: "ses_b" });
-    addMessage(db, "m1", "ses_b", 1, `{"role":"user"}`);
-    addPart(db, "p1", "m1", "ses_b", 1, `{"type":"text","text":"${EXCLUDE_MARKER}"}`);
-    expect(transcriptHasMarker(db, "ses_a")).toBe(false);
-    expect(transcriptHasMarker(db, "ses_b")).toBe(true);
-  });
-
-  test("does not match case variants or partial markers (exact substring)", () => {
-    const db = makeSource();
-    addSession(db, { id: "ses_a" });
-    addMessage(db, "m1", "ses_a", 1, `{"role":"user"}`);
-    addPart(db, "p1", "m1", "ses_a", 1, `{"type":"text","text":"do not index this chat"}`);
-    addPart(db, "p2", "m1", "ses_a", 2, `{"type":"text","text":"DO NOT INDEX THIS"}`);
-    expect(transcriptHasMarker(db, "ses_a")).toBe(false);
-  });
-});

package/src/store.test.ts

@@ -1,72 +0,0 @@
-import { describe, test, expect, afterAll } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { openIndex, replaceSessionChunks, search, textSearch, getIndexedSession } from "./store";
-
-const dir = mkdtempSync(join(tmpdir(), "episodic-store-test-"));
-const db = openIndex(join(dir, "index.db"));
-afterAll(() => rmSync(dir, { recursive: true, force: true }));
-
-const meta = {
-  id: "ses_test", project_id: "p", parent_id: null,
-  title: "Test session", directory: "/tmp",
-  time_created: 1000, source_time_updated: 1000,
-};
-
-describe("store", () => {
-  test("replaceSessionChunks + search round-trip ranks by cosine", () => {
-    replaceSessionChunks(db, meta, [
-      { seq: 0, time_created: 1000, text: "alpha chunk", embedding: new Float32Array([1, 0]) },
-      { seq: 1, time_created: 1001, text: "beta chunk", embedding: new Float32Array([0, 1]) },
-    ]);
-    const hits = search(db, new Float32Array([1, 0]));
-    expect(hits).toHaveLength(2);
-    expect(hits[0].text).toBe("alpha chunk");
-    expect(hits[0].score).toBeCloseTo(1);
-    expect(hits[1].score).toBeCloseTo(0);
-    expect(getIndexedSession(db, "ses_test")?.title).toBe("Test session");
-  });
-
-  test("search skips embeddings with mismatched dims instead of crashing", () => {
-    // 4-byte blob while the query is 2 dims (8 bytes) — must be skipped.
-    db.run("INSERT INTO chunks (session_id, seq, time_created, text, embedding) VALUES (?, ?, ?, ?, ?)",
-      ["ses_test", 99, 1002, "stale wrong-dims chunk", new Float32Array([0.5])]);
-    const hits = search(db, new Float32Array([1, 0]));
-    expect(hits.map((h) => h.text)).not.toContain("stale wrong-dims chunk");
-    expect(hits).toHaveLength(2);
-  });
-
-  test("re-embedding a session replaces its chunks", () => {
-    replaceSessionChunks(db, meta, [
-      { seq: 0, time_created: 1000, text: "only chunk now", embedding: new Float32Array([1, 0]) },
-    ]);
-    const hits = search(db, new Float32Array([1, 0]));
-    expect(hits.map((h) => h.text)).toEqual(["only chunk now"]);
-  });
-
-  test("textSearch does exact substring matching", () => {
-    expect(textSearch(db, "only chunk")).toHaveLength(1);
-    expect(textSearch(db, "no such phrase")).toHaveLength(0);
-  });
-
-  test("LIKE wildcards in user input are escaped (treated literally)", () => {
-    replaceSessionChunks(db, meta, [
-      { seq: 0, time_created: 1000, text: "progress at 50% done", embedding: new Float32Array([1, 0]) },
-      { seq: 1, time_created: 1001, text: "snake_case name here", embedding: new Float32Array([0, 1]) },
-      { seq: 2, time_created: 1002, text: "path \\tmp", embedding: new Float32Array([1, 0]) },
-    ]);
-    // % must match literally, not as a wildcard
-    expect(textSearch(db, "50%").map((h) => h.text)).toEqual(["progress at 50% done"]);
-    // _ must match literally, not as a single-char wildcard
-    expect(textSearch(db, "snake_case").map((h) => h.text)).toEqual(["snake_case name here"]);
-    // a bare % should NOT match everything (would if unescaped)
-    expect(textSearch(db, "%")).toHaveLength(1);
-    expect(textSearch(db, "_")).toHaveLength(1);
-    // a literal backslash must match only the row containing one — escapeLike
-    // escapes the escape char itself, so this would break if that were missed
-    expect(textSearch(db, "\\").map((h) => h.text)).toEqual(["path \\tmp"]);
-    // search() text filter should also escape
-    expect(search(db, new Float32Array([1, 0]), { text: "50%" })).toHaveLength(1);
-  });
-});