pi-mega-compact 0.8.21 → 0.8.23

package/dist/src/dedup-engine.test.js

@@ -16,7 +16,7 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import { compactSession } from "./engine.js";
-import { VectorStore } from "./vectorStore.js";
+import { VectorStore, vectorList, vectorStats, vectorWasInjected, vectorMarkInjected, vectorSearch } from "./vectorStore.js";
 import { extractiveSummarize } from "./extractive.js";
 import { estimateSessionTokens, estimateMessageTokens } from "./tokens.js";
 import { autoCompactCheck } from "./compact.js";
@@ -122,7 +122,7 @@ describe("Dedupe Levels", () => {
         const r2 = compactFull(s, SESS, [makeMsg("user", region)]);
         assert.equal(r2.deduped, true);
         assert.equal(r2.checkpointId, r1.checkpointId);
-        assert.equal(s.list(SESS).length, 1);
+        assert.equal(vectorList(s, SESS).length, 1);
     });
     it("L0 only: distinct content stored twice creates two checkpoints", () => {
         const s = makeStore({ L0_ENABLED: true, L1_ENABLED: false, L2_ENABLED: false });
@@ -133,7 +133,7 @@ describe("Dedupe Levels", () => {
         assert.equal(r1.deduped, false);
         assert.equal(r2.deduped, false);
         assert.notEqual(r1.checkpointId, r2.checkpointId);
-        assert.equal(s.list(SESS).length, 2);
+        assert.equal(vectorList(s, SESS).length, 2);
     });
     it("L1 only: one-word variants collapse; major rewrites do not", () => {
         const s = makeStore({ L0_ENABLED: false, L1_ENABLED: true, L2_ENABLED: false });
@@ -144,10 +144,10 @@ describe("Dedupe Levels", () => {
         assert.equal(r1.deduped, false);
         const r2 = s.add({ sessionId: SESS, summary: "migration", regionText: variant, timestamp: 2 });
         assert.equal(r2.deduped, true, "one-word variant should be collapsed by L1");
-        assert.equal(s.list(SESS).length, 1);
+        assert.equal(vectorList(s, SESS).length, 1);
         const r3 = s.add({ sessionId: SESS, summary: "frontend", regionText: rewrite, timestamp: 3 });
         assert.equal(r3.deduped, false, "major rewrite should not be collapsed by L1");
-        assert.equal(s.list(SESS).length, 2);
+        assert.equal(vectorList(s, SESS).length, 2);
     });
     it("L2 only: semantic paraphrases collapse; unrelated topics do not", () => {
         // Use a lower threshold and longer, lexically-overlapping paraphrase so the
@@ -161,10 +161,10 @@ describe("Dedupe Levels", () => {
         assert.equal(r1.deduped, false);
         const r2 = s.add({ sessionId: SESS, summary: "auth paraphrase", regionText: paraphrase, timestamp: 2 });
         assert.equal(r2.deduped, true, "semantic paraphrase should be collapsed by L2");
-        assert.equal(s.list(SESS).length, 1);
+        assert.equal(vectorList(s, SESS).length, 1);
         const r3 = s.add({ sessionId: SESS, summary: "frontend", regionText: unrelated, timestamp: 3 });
         assert.equal(r3.deduped, false, "unrelated topic should not be collapsed by L2");
-        assert.equal(s.list(SESS).length, 2);
+        assert.equal(vectorList(s, SESS).length, 2);
     });
     it("All tiers disabled: every store.add() with different region text creates a distinct checkpoint", () => {
         // Even with all dedup tiers disabled, the store still enforces a unique
@@ -178,7 +178,7 @@ describe("Dedupe Levels", () => {
         assert.equal(r3.deduped, false);
         assert.notEqual(r1.checkpoint.checkpointId, r2.checkpoint.checkpointId);
         assert.notEqual(r2.checkpoint.checkpointId, r3.checkpoint.checkpointId);
-        assert.equal(s.list(SESS).length, 3);
+        assert.equal(vectorList(s, SESS).length, 3);
     });
     it("Combined L0+L1+L2: layered behavior exact -> near -> semantic", () => {
         const s = makeStore({ L0_ENABLED: true, L1_ENABLED: true, L2_ENABLED: true });
@@ -202,8 +202,8 @@ describe("Dedupe Levels", () => {
         if (r4.deduped) {
             okReason(r4.dedupReason, ["contentSimilarity", "l1MinHash"]);
         }
-        assert.ok(s.list(SESS).length >= 1, "layered dedup keeps at least one checkpoint");
-        assert.ok(s.list(SESS).length <= 4, "layered dedup should not explode to many checkpoints");
+        assert.ok(vectorList(s, SESS).length >= 1, "layered dedup keeps at least one checkpoint");
+        assert.ok(vectorList(s, SESS).length <= 4, "layered dedup should not explode to many checkpoints");
     });
 });
 function okReason(reason, expected) {
@@ -242,16 +242,16 @@ describe("Compression / Store Stats", () => {
         compactFull(s, SESS, [makeMsg("user", unique)], 1);
         const dup = "duplicate topic about payment gateway integration";
         compactFull(s, SESS, [makeMsg("user", dup)], 1);
-        const statsBefore = s.stats(SESS);
+        const statsBefore = vectorStats(s, SESS);
         assert.ok(statsBefore.checkpointCount >= 1, "checkpointCount should be positive");
         assert.ok(statsBefore.totalTokenEstimate >= 0, "totalTokenEstimate should be non-negative");
         assert.equal(statsBefore.dedupHitRate, 0, "no injections yet => dedupHitRate 0");
         assert.equal(statsBefore.injectedCount, 0, "no injections yet => injectedCount 0");
-        const hits = s.search(SESS, "payment gateway", 5);
+        const hits = vectorSearch(s, SESS, "payment gateway", 5);
         assert.ok(hits.length > 0, "should find the stored checkpoint");
         const cpId = hits[0].checkpoint.checkpointId;
-        s.markInjected(SESS, cpId);
-        const statsAfter = s.stats(SESS);
+        vectorMarkInjected(s, SESS, cpId);
+        const statsAfter = vectorStats(s, SESS);
         assert.equal(statsAfter.injectedCount, 1, "injectedCount tracks markInjected");
         if (statsAfter.checkpointCount > 0) {
             assert.ok(Math.abs(statsAfter.dedupHitRate - 1 / statsAfter.checkpointCount) < 0.001, "dedupHitRate = injected / checkpoints");
@@ -267,10 +267,10 @@ describe("Compression / Store Stats", () => {
         }
         compactFull(s, SESS, [makeMsg("user", "unique region for hit-rate measurement variant")], 1);
         // Mark the first as injected.
-        const first = s.search(SESS, base, 1)[0]?.checkpoint.checkpointId;
+        const first = vectorSearch(s, SESS, base, 1)[0]?.checkpoint.checkpointId;
         if (first)
-            s.markInjected(SESS, first);
-        const stats = s.stats(SESS);
+            vectorMarkInjected(s, SESS, first);
+        const stats = vectorStats(s, SESS);
         assert.ok(stats.checkpointCount >= 1);
         assert.ok(stats.dedupHitRate > 0 || stats.checkpointCount === 1, "hit rate should be positive when there are multiple checkpoint");
     });
@@ -304,13 +304,13 @@ describe("Recall & Dedup Sentinel", () => {
         const s = makeStore();
         const region = "manual sentinel tracking without recallAndInline";
         compactFull(s, SESS, [makeMsg("user", region)]);
-        const hits = s.search(SESS, "manual sentinel", 3);
+        const hits = vectorSearch(s, SESS, "manual sentinel", 3);
         assert.ok(hits.length > 0, "search should return checkpoint");
         const cpId = hits[0].checkpoint.checkpointId;
-        assert.equal(s.wasInjected(SESS, cpId), false, "not yet injected");
-        s.markInjected(SESS, cpId);
-        assert.equal(s.wasInjected(SESS, cpId), true, "markInjected recorded");
-        const hits2 = s.search(SESS, "manual sentinel", 3).filter((h) => !s.wasInjected(SESS, h.checkpoint.checkpointId));
+        assert.equal(vectorWasInjected(s, SESS, cpId), false, "not yet injected");
+        vectorMarkInjected(s, SESS, cpId);
+        assert.equal(vectorWasInjected(s, SESS, cpId), true, "markInjected recorded");
+        const hits2 = vectorSearch(s, SESS, "manual sentinel", 3).filter((h) => !vectorWasInjected(s, SESS, h.checkpoint.checkpointId));
         assert.equal(hits2.length, 0, "filtered search excludes injected checkpoint");
     });
 });
@@ -322,13 +322,13 @@ describe("Edge Cases", () => {
         const r = compactSession({ sessionId: SESS, messages: [], keepFrom: 0 }, s);
         assert.equal(r.skipped, true);
         assert.equal(r.summary, "");
-        assert.equal(s.list(SESS).length, 0);
+        assert.equal(vectorList(s, SESS).length, 0);
     });
     it("single message with keepFrom=0 returns skipped", () => {
         const s = makeStore();
         const r = compactSession({ sessionId: SESS, messages: [makeMsg("user", "only one message")], keepFrom: 0 }, s);
         assert.equal(r.skipped, true);
-        assert.equal(s.list(SESS).length, 0);
+        assert.equal(vectorList(s, SESS).length, 0);
     });
     it("keepFrom at messages.length compacts all prior messages (verified behavior)", () => {
         // The engine treats keepFrom as the compactable boundary: messages[0..keepFrom)
@@ -339,7 +339,7 @@ describe("Edge Cases", () => {
         const r = compactSession({ sessionId: SESS, messages, keepFrom: messages.length }, s);
         assert.equal(r.skipped, false);
         assert.ok(r.checkpointId);
-        assert.equal(s.list(SESS).length, 1);
+        assert.equal(vectorList(s, SESS).length, 1);
     });
     it("unicode and emoji messages store and retrieve intact", () => {
         const s = makeStore();
@@ -347,7 +347,7 @@ describe("Edge Cases", () => {
             "日本語テキスト 日本語テキスト 👍🔥";
         const r = compactFull(s, SESS, [makeMsg("user", text)], 1);
         assert.equal(r.skipped, false);
-        const stored = s.list(SESS)[0];
+        const stored = vectorList(s, SESS)[0];
         assert.ok(stored);
         const recovered = Buffer.from(stored.compressedOriginal ?? Buffer.alloc(0));
         assert.ok(recovered.toString("utf-8").includes("🎉"), "emoji recovered from compressedOriginal");
@@ -360,8 +360,8 @@ describe("Edge Cases", () => {
         const r = compactFull(s, SESS, [makeMsg("user", big)], 1);
         assert.equal(r.skipped, false);
         assert.ok(r.checkpointId);
-        assert.equal(s.list(SESS).length, 1);
-        const stats = s.stats(SESS);
+        assert.equal(vectorList(s, SESS).length, 1);
+        const stats = vectorStats(s, SESS);
         assert.ok(stats.totalTokenEstimate > 0);
     });
     it("mixed roles (user/assistant/tool) are included in summary", () => {
@@ -380,7 +380,7 @@ describe("Edge Cases", () => {
             r.summary.includes("Edit") ||
             r.summary.includes("user") ||
             r.summary.includes("assistant"), "summary should reference roles or tools");
-        assert.equal(s.list(SESS).length, 1);
+        assert.equal(vectorList(s, SESS).length, 1);
     });
 });
 // -------------------- 7. Tier Switching (percentage-based) --------------------

package/dist/src/e2e.test.js

@@ -9,7 +9,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { VectorStore, computeRegionHash } from "./vectorStore.js";
+import { VectorStore, computeRegionHash, vectorList, vectorSemDedup, vectorWasInjected, vectorMarkInjected, vectorTopSimilar, vectorStats, vectorSearch } from "./vectorStore.js";
 import { compactSession, recall, supersededCount } from "./engine.js";
 import { loadDedupConfig } from "./config/dedup.js";
 import { defaultEmbedder } from "./embedder.js";
@@ -101,8 +101,8 @@ test("1. Full compaction pipeline: SUPERSEDE → COLLAPSE → CLUSTER", () => {
     // Verify: checkpoint persisted
     assert.ok(r.checkpointId, "checkpointId should be set");
     assert.match(r.checkpointId, /^chkpt_001$/);
-    // Verify: checkpoint is searchable via store.search()
-    const hits = s.search(SESS, "server.ts memory leak JWT auth", 5);
+    // Verify: checkpoint is searchable via vectorSearch(store, )
+    const hits = vectorSearch(s, SESS, "server.ts memory leak JWT auth", 5);
     assert.ok(hits.length > 0, "checkpoint should be searchable");
     assert.equal(hits[0].checkpoint.checkpointId, r.checkpointId);
 });
@@ -133,7 +133,7 @@ test("2. Multi-session dedup: identical content in same session detected by L0",
     assert.equal(rB.deduped, true, "second identical compaction should be deduped by L0");
     assert.ok(rB.dedupReason === "regionHash" || rB.dedupReason === "contentHash", `dedup reason should be L0 (regionHash or contentHash), got ${rB.dedupReason}`);
     // Search should still return the checkpoint
-    const hits = s.search("sess_multi_a", "database connection pooling", 5);
+    const hits = vectorSearch(s, "sess_multi_a", "database connection pooling", 5);
     assert.ok(hits.length > 0, "search returns the deduped result");
     assert.equal(hits[0].checkpoint.checkpointId, rA.checkpointId);
 });
@@ -162,7 +162,7 @@ test("3. Near-duplicate detection: L1 MinHash/LSH catches one-word edits that L0
     // L1 should catch the near-dup
     assert.equal(r2.deduped, true, "L1 should catch the near-duplicate");
     assert.equal(r2.reason, "l1MinHash", "dedup reason should be l1MinHash");
-    assert.equal(s.list(SESS).length, 1, "only one checkpoint stored");
+    assert.equal(vectorList(s, SESS).length, 1, "only one checkpoint stored");
 });
 test("3b. Negative: L1 does NOT collapse genuinely different content", () => {
     const s = store({ L2_ENABLED: false });
@@ -180,7 +180,7 @@ test("3b. Negative: L1 does NOT collapse genuinely different content", () => {
         timestamp: 2,
     });
     assert.equal(r2.deduped, false, "distinct content should not be deduped");
-    assert.equal(s.list(SESS).length, 2, "both checkpoints stored");
+    assert.equal(vectorList(s, SESS).length, 2, "both checkpoints stored");
 });
 // ---------------------------------------------------------------------------
 // 4. Semantic Dedup (L2 cosine)
@@ -208,7 +208,7 @@ test("4. Semantic dedup: L2 cosine catches highly similar content that L0/L1 mis
     // L2 semantic cosine should catch this high-similarity paraphrase
     assert.equal(r2.deduped, true, "L2 should catch the high-similarity paraphrase");
     assert.ok(r2.reason === "contentSimilarity" || r2.reason === "l1MinHash", `dedup reason should be L2 contentSimilarity or L1 l1MinHash, got ${r2.reason}`);
-    assert.equal(s.list(SESS).length, 1, "only one checkpoint after semantic dedup");
+    assert.equal(vectorList(s, SESS).length, 1, "only one checkpoint after semantic dedup");
 });
 test("4b. MMR diversifies search results", () => {
     const s = store();
@@ -230,7 +230,7 @@ test("4b. MMR diversifies search results", () => {
         });
     }
     // Search for parser-related content — should return relevant results
-    const hits = s.search(SESS, "parser tokenization source code files", 4);
+    const hits = vectorSearch(s, SESS, "parser tokenization source code files", 4);
     assert.ok(hits.length >= 1, "should return at least one result");
     // The top hit should be the parser checkpoint
     assert.ok(hits[0].checkpoint.summary.includes("topic_0"), "top hit is the parser topic");
@@ -255,20 +255,20 @@ test("5. SemDeDup offline cleanup: redundant rows marked removed, not deleted",
         { id: "chkpt_003", text: "the frontend uses a virtualized list for rendering large datasets efficiently", tok: 500, ts: 3 },
     ]);
     // Run SemDeDup with threshold that catches the near-identical pair
-    const removed = s.semDedup(SESS, 0.85);
+    const removed = vectorSemDedup(s, SESS, 0.85);
     assert.equal(removed, 1, "one redundant row should be marked removed");
     // Verify: the lower-tokenEstimate row is the one removed
-    const all = s.list(SESS);
+    const all = vectorList(s, SESS);
     const dropped = all.find((c) => c.dedupStatus === "removed");
     assert.ok(dropped, "a row should have dedup_status='removed'");
     assert.equal(dropped.checkpointId, "chkpt_001", "lower tokenEstimate row removed");
     assert.equal(dropped.dedupStatus, "removed");
     // Verify: search excludes removed rows (3 total, 1 removed → 2 active)
-    const hits = s.search(SESS, "cache parsed ast nodes frontend virtualized list", 10);
+    const hits = vectorSearch(s, SESS, "cache parsed ast nodes frontend virtualized list", 10);
     assert.equal(hits.length, 2, "search excludes the removed row, returns 2 active");
     assert.ok(hits.every((h) => h.checkpoint.dedupStatus !== "removed"), "no removed rows in search");
     // Verify: idempotent re-run removes nothing new
-    const secondRun = s.semDedup(SESS, 0.85);
+    const secondRun = vectorSemDedup(s, SESS, 0.85);
     assert.equal(secondRun, 0, "idempotent re-run removes nothing new");
     closeStore(dir);
 });
@@ -293,15 +293,15 @@ test("6. Recall + inline with dedup sentinel: injected checkpoints are skipped",
     assert.equal(first.hits.length, 1);
     // Mark it injected
     const cpId = first.hits[0].checkpoint.checkpointId;
-    s.markInjected(SESS, cpId);
+    vectorMarkInjected(s, SESS, cpId);
     // Recall again — should skip the injected checkpoint
     const second = recall({ sessionId: SESS, query: "vectorStore dedup cascade", limit: 5, skipInjected: true }, s);
     assert.equal(second.newHits.length, 0, "injected checkpoint should be skipped (dedup sentinel)");
     // Without skipInjected, hits still surface
     assert.equal(second.hits.length, 1, "hits still surface without skipInjected");
     // Verify wasInjected
-    assert.equal(s.wasInjected(SESS, cpId), true, "wasInjected returns true for injected checkpoint");
-    assert.equal(s.wasInjected(SESS, "chkpt_999"), false, "wasInjected returns false for non-injected");
+    assert.equal(vectorWasInjected(s, SESS, cpId), true, "wasInjected returns true for injected checkpoint");
+    assert.equal(vectorWasInjected(s, SESS, "chkpt_999"), false, "wasInjected returns false for non-injected");
 });
 // ---------------------------------------------------------------------------
 // 7. topSimilar
@@ -326,11 +326,11 @@ test("7. topSimilar: returns n most cosine-similar checkpoints", () => {
         });
     }
     // Call topSimilar(3)
-    const hits = s.topSimilar(SESS, 3);
+    const hits = vectorTopSimilar(s, SESS, 3);
     assert.ok(hits.length <= 3, "should respect n limit");
     assert.ok(hits.length > 0, "should return results");
     // Verify self-exclusion: the most recent checkpoint should not be in results
-    const all = s.list(SESS);
+    const all = vectorList(s, SESS);
     const ordered = [...all].sort((a, b) => a.checkpointId.localeCompare(b.checkpointId));
     const current = ordered[ordered.length - 1];
     assert.ok(!hits.some((h) => h.checkpoint.checkpointId === current.checkpointId), "current checkpoint excluded");
@@ -358,14 +358,14 @@ test("7b. topSimilar respects n limit strictly", () => {
             timestamp: i + 1,
         });
     }
-    const hits = s.topSimilar(SESS, 2);
+    const hits = vectorTopSimilar(s, SESS, 2);
     assert.equal(hits.length, 2, "n limit respected");
 });
 test("7c. topSimilar returns empty for sessions with 0 or 1 checkpoints", () => {
     const s = store();
-    assert.deepEqual(s.topSimilar("sess_empty", 5), []);
+    assert.deepEqual(vectorTopSimilar(s, "sess_empty", 5), []);
     s.add({ sessionId: "sess_one", summary: "solo", regionText: "only checkpoint here", timestamp: 1 });
-    assert.deepEqual(s.topSimilar("sess_one", 5), []);
+    assert.deepEqual(vectorTopSimilar(s, "sess_one", 5), []);
 });
 // ---------------------------------------------------------------------------
 // 8. Compression Round-Trip
@@ -390,7 +390,7 @@ test("8. Compression round-trip: decompression produces original content", () =>
         timestamp: 1,
     });
     // Retrieve and verify decompression
-    const cp = s.list(SESS)[0];
+    const cp = vectorList(s, SESS)[0];
     assert.ok(cp.compressedOriginal instanceof Buffer, "compressedOriginal is a Buffer");
     const restored = decompressSmart(cp.compressedOriginal).toString("utf-8");
     assert.equal(restored, originalText, "decompression produces the original content");
@@ -407,7 +407,7 @@ test("8b. Compression round-trip with different content sizes", () => {
     // Large text (>4KB → gzip level 6 or brotli)
     const large = "detailed region text with lots of context about the codebase. ".repeat(200);
     s.add({ sessionId: SESS, summary: "large", regionText: large, timestamp: 3 });
-    const checkpoints = s.list(SESS);
+    const checkpoints = vectorList(s, SESS);
     assert.equal(checkpoints.length, 3);
     // Verify each round-trips correctly
     const texts = [small, medium, large];
@@ -444,7 +444,7 @@ test("9. Store stats and metrics reflect actual state after compactions", () =>
     const r3 = compactSession({ sessionId: SESS, messages: conv3, keepFrom: 2, timestamp: 3 }, s);
     assert.equal(r3.deduped, false);
     // Get stats
-    const st = s.stats(SESS);
+    const st = vectorStats(s, SESS);
     assert.equal(st.checkpointCount, 3, "three checkpoints stored");
     assert.ok(st.totalTokenEstimate > 0, "totalTokenEstimate should be positive");
     assert.equal(st.lastCheckpointId, "chkpt_003", "last checkpoint id correct");
@@ -452,14 +452,14 @@ test("9. Store stats and metrics reflect actual state after compactions", () =>
     assert.equal(st.injectedCount, 0, "no injections yet");
     assert.equal(st.dedupHitRate, 0, "dedupHitRate is 0 with no injections");
     // Mark one injected and re-check
-    s.markInjected(SESS, "chkpt_001");
-    const st2 = s.stats(SESS);
+    vectorMarkInjected(s, SESS, "chkpt_001");
+    const st2 = vectorStats(s, SESS);
     assert.equal(st2.injectedCount, 1, "one injection tracked");
     assert.ok(Math.abs(st2.dedupHitRate - 1 / 3) < 1e-9, "dedupHitRate = injected/checkpoints");
 });
 test("9b. Stats on empty session returns zeros", () => {
     const s = store();
-    const st = s.stats("sess_nothing");
+    const st = vectorStats(s, "sess_nothing");
     assert.equal(st.checkpointCount, 0);
     assert.equal(st.totalTokenEstimate, 0);
     assert.equal(st.lastCheckpointId, undefined);
@@ -496,15 +496,15 @@ test("10. Concurrent sessions: no cross-contamination", () => {
     });
     // Verify: each session has exactly one checkpoint
     sessions.forEach((sess) => {
-        const cps = s.list(sess.id);
+        const cps = vectorList(s, sess.id);
         assert.equal(cps.length, 1, `${sess.id} should have 1 checkpoint`);
     });
     // Verify: search in one session doesn't return another session's checkpoints
-    const hitsA = s.search("sess_concurrent_a", "authentication JWT", 5);
+    const hitsA = vectorSearch(s, "sess_concurrent_a", "authentication JWT", 5);
     assert.ok(hitsA.every((h) => h.checkpoint.sessionId === "sess_concurrent_a"), "search in A returns only A's checkpoints");
-    const hitsB = s.search("sess_concurrent_b", "database queries indexes", 5);
+    const hitsB = vectorSearch(s, "sess_concurrent_b", "database queries indexes", 5);
     assert.ok(hitsB.every((h) => h.checkpoint.sessionId === "sess_concurrent_b"), "search in B returns only B's checkpoints");
-    const hitsC = s.search("sess_concurrent_c", "canvas rendering bug", 5);
+    const hitsC = vectorSearch(s, "sess_concurrent_c", "canvas rendering bug", 5);
     assert.ok(hitsC.every((h) => h.checkpoint.sessionId === "sess_concurrent_c"), "search in C returns only C's checkpoints");
 });
 // ---------------------------------------------------------------------------
@@ -516,7 +516,7 @@ test("11a. Empty session (no messages) — compactSession should skip", () => {
     assert.equal(r.skipped, true, "empty session should be skipped");
     assert.equal(r.summary, "");
     assert.equal(r.regionHash, "");
-    assert.equal(s.list("sess_empty_msgs").length, 0);
+    assert.equal(vectorList(s, "sess_empty_msgs").length, 0);
 });
 test("11b. Single message session — should skip or handle gracefully", () => {
     const s = store();
@@ -549,7 +549,7 @@ test("11c. Very large region text — should still compact and store", () => {
     assert.ok(r.checkpointId, "checkpoint created");
     assert.ok(r.summary.length > 0, "summary produced");
     // Verify it's searchable
-    const hits = s.search(SESS, "module feature fix review", 3);
+    const hits = vectorSearch(s, SESS, "module feature fix review", 3);
     assert.ok(hits.length > 0, "large checkpoint is searchable");
 });
 test("11d. Unicode and emoji content — should normalize and hash correctly", () => {
@@ -565,7 +565,7 @@ test("11d. Unicode and emoji content — should normalize and hash correctly", (
     assert.equal(r.skipped, false, "unicode conversation should compact");
     assert.ok(r.regionHash.length > 0, "regionHash computed for unicode content");
     // Verify the checkpoint exists and is searchable
-    const hits = s.search(SESS, "中文 translation 本地化", 3);
+    const hits = vectorSearch(s, SESS, "中文 translation 本地化", 3);
     assert.ok(hits.length > 0, "unicode checkpoint is searchable");
     // Verify regionHash is deterministic for the same unicode content
     const r2 = compactSession({ sessionId: SESS, messages, keepFrom: 4, timestamp: 2 }, s);
@@ -588,7 +588,7 @@ test("11e. All messages in preserve-recent window — nothing to compact", () =>
         timestamp: 1,
     }, s);
     assert.equal(r.skipped, true, "should skip when keepFrom=0 (nothing to compact)");
-    assert.equal(s.list("sess_all_preserved").length, 0, "no checkpoints stored");
+    assert.equal(vectorList(s, "sess_all_preserved").length, 0, "no checkpoints stored");
 });
 // ---------------------------------------------------------------------------
 // 12. Feature Flag Toggling
@@ -616,7 +616,7 @@ test("12a. L0_ENABLED=false — L0 does not collapse exact dups", () => {
     assert.equal(r1.deduped, false);
     // With L0 off (and L1/L2 off too), near-dup should NOT be collapsed
     assert.equal(r2.deduped, false, "L0 disabled → near-dup not collapsed");
-    assert.equal(s.list(SESS).length, 2, "both checkpoints stored when L0 is off");
+    assert.equal(vectorList(s, SESS).length, 2, "both checkpoints stored when L0 is off");
 });
 test("12b. MARK_ONLY_L1=true — L1 records but does not collapse", () => {
     // Disable L2 to isolate L1 behavior
@@ -637,9 +637,9 @@ test("12b. MARK_ONLY_L1=true — L1 records but does not collapse", () => {
     assert.equal(r1.deduped, false);
     // MARK_ONLY_L1 → L1 detects the near-dup but does NOT collapse
     assert.equal(r2.deduped, false, "MARK_ONLY_L1 → not collapsed");
-    assert.equal(s.list(SESS).length, 2, "both checkpoints stored (mark only)");
+    assert.equal(vectorList(s, SESS).length, 2, "both checkpoints stored (mark only)");
     // Both should be active (not removed)
-    const all = s.list(SESS);
+    const all = vectorList(s, SESS);
     assert.ok(all.every((c) => c.dedupStatus === "active"), "both rows active under MARK_ONLY");
 });
 test("12c. L2_ENABLED=false — L2 skipped but L0/L1 still work", () => {
@@ -688,7 +688,7 @@ test("12d. All tiers disabled — nothing deduped, everything stored", () => {
     });
     assert.equal(r1.deduped, false);
     assert.equal(r2.deduped, false, "all tiers off → nothing deduped");
-    assert.equal(s.list(SESS).length, 2, "both stored");
+    assert.equal(vectorList(s, SESS).length, 2, "both stored");
 });
 // ---------------------------------------------------------------------------
 // Cleanup

package/dist/src/engine.js

@@ -15,7 +15,7 @@ import { findSuperseded, supersede } from "./supersede.js";
 import { summarizeMessages, mergeCompactSummaries, formatCompactSummary } from "./compact.js";
 import { extractiveSummarize } from "./extractive.js";
 import { estimateSessionTokens, estimateBlockTokens } from "./tokens.js";
-import { computeRegionHash, VectorStore } from "./vectorStore.js";
+import { computeRegionHash, vectorWasInjected, vectorSearch, VectorStore } from "./vectorStore.js";
 /** Default store used by the convenience `compactSession`. */
 let defaultStore;
 export function getDefaultStore(stateDir) {
@@ -125,8 +125,8 @@ export function compactSession(input, store = getDefaultStore()) {
  * inject (Sprint 4 wires injection); this module only does the deduped search.
  */
 export function recall(input, store = getDefaultStore()) {
-    const hits = store.search(input.sessionId, input.query, input.limit ?? 3);
-    const newHits = input.skipInjected === false ? hits : hits.filter((h) => !store.wasInjected(input.sessionId, h.checkpoint.checkpointId));
+    const hits = vectorSearch(store, input.sessionId, input.query, input.limit ?? 3);
+    const newHits = input.skipInjected === false ? hits : hits.filter((h) => !vectorWasInjected(store, input.sessionId, h.checkpoint.checkpointId));
     return { hits, newHits };
 }
 /** Merge a freshly compacted summary into the prior persisted summary text. */

package/dist/src/engine.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { VectorStore } from "./vectorStore.js";
+import { VectorStore, vectorMarkInjected, vectorSearch } from "./vectorStore.js";
 import { compactSession, recall, mergeSummary, supersededCount } from "./engine.js";
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-engine-"));
 let counter = 0;
@@ -35,7 +35,7 @@ test("compactSession supersedes then persists a checkpoint", () => {
     assert.equal(supersededCount(messages.slice(0, 4)), 1);
     assert.equal(r.compactedFrom, 4);
     // The persisted checkpoint is searchable.
-    assert.equal(s.search(SESS, "bug src/server.ts", 5).length, 1);
+    assert.equal(vectorSearch(s, SESS, "bug src/server.ts", 5).length, 1);
 });
 test("compactSession is idempotent on identical region (dedup sentinel)", () => {
     const s = store();
@@ -50,20 +50,20 @@ test("compactSession is idempotent on identical region (dedup sentinel)", () =>
     assert.equal(r1.deduped, false);
     assert.equal(r2.deduped, true);
     assert.equal(r1.checkpointId, r2.checkpointId);
-    assert.equal(s.search(SESS, "parser", 10).length, 1);
+    assert.equal(vectorSearch(s, SESS, "parser", 10).length, 1);
 });
 test("compactSession skipped when slice is empty", () => {
     const s = store();
     const r = compactSession({ sessionId: SESS, messages: [msg("user", "only tail")], keepFrom: 0 }, s);
     assert.equal(r.skipped, true);
-    assert.equal(s.search(SESS, "x", 5).length, 0);
+    assert.equal(vectorSearch(s, SESS, "x", 5).length, 0);
 });
 test("recall drops already-injected checkpoints", () => {
     const s = store();
     compactSession({ sessionId: SESS, messages: [msg("user", "investigated src/vectorStore.ts"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
     const first = recall({ sessionId: SESS, query: "vectorStore", limit: 5, skipInjected: true }, s);
     assert.equal(first.newHits.length, 1);
-    s.markInjected(SESS, first.hits[0].checkpoint.checkpointId);
+    vectorMarkInjected(s, SESS, first.hits[0].checkpoint.checkpointId);
     const second = recall({ sessionId: SESS, query: "vectorStore", limit: 5, skipInjected: true }, s);
     assert.equal(second.newHits.length, 0);
     // Without the skip flag, both hits still surface.
@@ -100,7 +100,7 @@ test("compactSession with useExtractive produces topicSummary on checkpoint", ()
     assert.equal(r.skipped, false);
     assert.ok(r.checkpointId, "checkpoint created");
     // The checkpoint should have topicSummary populated
-    const hits = s.search("sess_extr", "auth refactor", 5);
+    const hits = vectorSearch(s, "sess_extr", "auth refactor", 5);
     assert.ok(hits.length > 0);
     // topicSummary should be present on the stored checkpoint (via extractive path)
     assert.ok(hits[0].checkpoint.topicSummary, "topicSummary should be populated when useExtractive is true");