pi-mega-compact 0.8.21 → 0.8.22

package/dist/extensions/mega-commands.js

@@ -12,6 +12,7 @@ import { decompressSmart } from "../src/store/compression.js";
 import { loadMetrics, fpRate, p95, defaultMetricsPath } from "../src/monitoring.js";
 import { C, recentUserQuery } from "./mega-runtime.js";
 import { runCompact, doRecall, doRecallAsync } from "./mega-pipeline.js";
+import { vectorStats, vectorRepoStats, vectorDataInvariant } from "../src/vectorStore.js";
 /** Resolve a checkpoint by id (or "recent"/"last") from this session's store. */
 export function findCheckpoint(runtime, sid, ref) {
     const all = listCheckpoints(sid, runtime.currentStateDir);
@@ -88,9 +89,9 @@ export function registerCommands(pi, runtime, config) {
                 const pct = usage?.percent != null ? `${usage.percent}%` : "n/a";
                 const tokens = usage?.tokens != null ? `${usage.tokens} tok` : "n/a";
                 const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
-                const st = runtime.store.stats(sid);
-                const repo = runtime.store.repoStats();
-                const di = runtime.store.dataInvariant();
+                const st = vectorStats(runtime.store, sid);
+                const repo = vectorRepoStats(runtime.store);
+                const di = vectorDataInvariant(runtime.store);
                 const fmtB = (b) => b >= 1_048_576 ? `${(b / 1_048_576).toFixed(1)} MiB` :
                     b >= 1024 ? `${(b / 1024).toFixed(1)} KiB` : `${b} B`;
                 // Real cost: tokens saved × the captured model's input rate (USD/token),

package/dist/extensions/mega-events/agent-handlers.js

@@ -6,6 +6,7 @@ import { isMegaCache } from "../../src/game/scoring.js";
 import { resolveRepoRoot } from "../mega-config.js";
 import { classifyError } from "./error-classifier.js";
 import { safeSendUserMessage } from "./send-safe.js";
+import { vectorStats } from "../../src/vectorStore.js";
 /** Register agent/turn tracking event handlers. */
 export function registerAgentHandlers(pi, runtime, config) {
     // ---- Agent tracking for real-time widget + status-line updates ---------
@@ -215,7 +216,7 @@ export function registerAgentHandlers(pi, runtime, config) {
         try {
             if (runtime.getCachedGameState().game_mode_on) {
                 const repo = resolveRepoRoot(ctx.cwd) ?? runtime.currentStateDir;
-                const st = runtime.store.stats(runtime.rt.sessionId);
+                const st = vectorStats(runtime.store, runtime.rt.sessionId);
                 const cachePct = st.dedupHitRate * 100;
                 const modelId = runtime.currentModel?.modelId ?? "unknown";
                 recordScore(runtime.currentStateDir, {

package/dist/extensions/mega-events/compact-handlers.js

@@ -79,6 +79,32 @@ export function registerCompactHandlers(pi, runtime, config) {
         });
         if (!config.auto)
             return {}; // let pi run its own native compaction
+        // S38.5: COMPACT-DEDUP RACE GUARD — pi's _runAutoCompaction fires
+        // session_before_compact from within the agent loop (after agent_end,
+        // _handlePostAgentRun → _checkCompaction → _runAutoCompaction). If a
+        // compaction just completed (within the cooldown window), pi's
+        // prepareCompaction may still see the last entry as a compaction but
+        // the extension's session_compact handler hasn't been called yet, OR
+        // the setTimeout deferred ctx.compact() from the agent_end handler is
+        // about to race. Skip the durable trim and let pi run its own compact
+        // (or no-op if the branch is already compacted). Matches the cooldown
+        // in agent-handlers.ts so both call sites are consistent.
+        const cooldownMs = config.raceGuardStrict ? 30_000 : 10_000;
+        const sinceCompact = Date.now() - (runtime.rt.lastNativeCompactAt ?? 0);
+        if (sinceCompact < cooldownMs) {
+            runtime.logger.info("before-compact-skip-recent", {
+                sessionId: runtime.rt.sessionId,
+                reason: event.reason,
+                sinceCompactMs: sinceCompact,
+                cooldownMs,
+            });
+            runtime.diagBeforeCompactSupplied++;
+            const fb = fallbackCompaction(event);
+            if (fb) {
+                return { compaction: fb.compaction };
+            }
+            return {};
+        }
         try {
             const result = driveNativeCompaction(event, runtime, config);
             if (result && result.compaction.summary?.trim()) {

package/dist/extensions/mega-events/session-handlers.js

@@ -3,6 +3,7 @@ import { autoMaintain } from "../../src/store/sqlite.js";
 import { recentUserQuery, WIDGET_KEY, } from "../mega-runtime.js";
 import { doRecall, doRecallAsync, } from "../mega-pipeline.js";
 import { recallMemoriesAndInline } from "../../src/recall.js";
+import { vectorStats } from "../../src/vectorStore.js";
 /** Register session lifecycle event handlers. */
 export function registerSessionHandlers(pi, runtime, config) {
     // Capture model/provider whenever it changes (drives real cost estimation).
@@ -26,7 +27,7 @@ export function registerSessionHandlers(pi, runtime, config) {
         if (config.autoInline) {
             const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
             const query = recentUserQuery(ctx);
-            if (query && runtime.store.stats(sid).checkpointCount > 0) {
+            if (query && vectorStats(runtime.store, sid).checkpointCount > 0) {
                 // S17: use the async variant on resume so cross-repo HNSW recall can
                 // augment when this repo's store is thin. session_start is an async-safe
                 // point (unlike the mid-turn context handler, which stays sync).

package/dist/extensions/mega-pipeline/compact.js

@@ -19,6 +19,7 @@ import { runRaptor } from "../../src/dedup/raptor/index.js";
 import { loadDedupConfig } from "../../src/config/dedup.js";
 import { upsertEmbedding as indexUpsertEmbedding } from "../../src/store/vectorIndex.js";
 import { runMemoryReview } from "./memory-review.js";
+import { vectorList } from "../../src/vectorStore.js";
 /** Run the full compaction pipeline and persist a checkpoint. Returns the result. */
 export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
     runtime.bindRepo(ctx.cwd);
@@ -171,7 +172,7 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     if (config.raptorEnabled && !result.deduped) {
         try {
             const dd = loadDedupConfig();
-            const all = runtime.store.list(sid);
+            const all = vectorList(runtime.store, sid);
             const leaves = all.map((cp) => ({
                 id: cp.checkpointId,
                 messages: [],
@@ -204,7 +205,7 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     // Non-fatal: a WASM init failure degrades to the sync scan silently.
     if (!result.deduped) {
         try {
-            const all = runtime.store.list(sid);
+            const all = vectorList(runtime.store, sid);
             const latest = all.find((cp) => cp.checkpointId === result.checkpointId);
             if (latest?.embedding) {
                 void indexUpsertEmbedding(runtime.currentStateDir, sid, latest.checkpointId, latest.embedding).catch(() => {

package/dist/extensions/mega-runtime/state.js

@@ -11,7 +11,7 @@
  */
 import { join } from "node:path";
 import { appendFileSync, mkdirSync } from "node:fs";
-import { VectorStore } from "../../src/vectorStore.js";
+import { VectorStore, vectorStats, vectorRepoStats, vectorDataInvariant } from "../../src/vectorStore.js";
 import { toEngineMessages } from "../../src/adapt.js";
 import { normalizeSessionId } from "../../src/store.js";
 import { Logger } from "../../src/log.js";
@@ -306,8 +306,8 @@ export class MegaRuntime {
         // never break the per-repo compaction path. Runs only on repo-switch
         // (this branch), so it's infrequent — not per-context-event.
         try {
-            const repo = this.store.repoStats();
-            const di = this.store.dataInvariant();
+            const repo = vectorRepoStats(this.store);
+            const di = vectorDataInvariant(this.store);
             const root = key !== dir ? key : (resolveRepoRoot(cwd ?? dir) ?? dir);
             upsertRepoRegistry({
                 repoRoot: root,
@@ -346,9 +346,9 @@ export class MegaRuntime {
             return;
         }
         const perfT0 = performance.now();
-        const st = this.store.stats(this.rt.sessionId);
-        const repo = this.store.repoStats();
-        const di = this.store.dataInvariant();
+        const st = vectorStats(this.store, this.rt.sessionId);
+        const repo = vectorRepoStats(this.store);
+        const di = vectorDataInvariant(this.store);
         // Live + store-wide cache-hit / compaction counters for the dashboard.
         const ds = getDedupStats(this.currentStateDir);
         const cacheHitsTotal = ds.deduped + getRecallInjected(this.currentStateDir);
@@ -492,7 +492,7 @@ export class MegaRuntime {
                 total: getCompactCount(this.currentStateDir),
             },
             timeSaved: {
-                compact: { sessionSec: sec(this.rt.tokensSaved), totalSec: sec(this.store.repoStats().tokensSaved) },
+                compact: { sessionSec: sec(this.rt.tokensSaved), totalSec: sec(vectorRepoStats(this.store).tokensSaved) },
                 cacheHit: { sessionSec: sec(this.rt.cacheHitTokens), totalSec: sec(cacheHitsTotalTokens) },
             },
             model,

package/dist/src/dedup/raptor/promote.test.js

@@ -11,7 +11,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, vectorList, vectorSearch } from "../../vectorStore.js";
 import { runRaptor } from "./index.js";
 import { compactSession } from "../../engine.js";
 import { Logger } from "../../log.js";
@@ -35,10 +35,10 @@ test("Fix D: vectorStore.search serves a persisted RAPTOR tree (broader recall)"
     }
     // No tree yet → flat search only, returns hits, no RAPTOR coverage.
     assert.equal(listRaptorNodes(SESS, stateDir).length, 0, "no tree initially");
-    const flat = s.search(SESS, "alpha wire bootstrap", 3);
+    const flat = vectorSearch(s, SESS, "alpha wire bootstrap", 3);
     assert.ok(flat.length > 0, "flat search returns hits");
     // Build + persist a RAPTOR tree for the session (mirrors runCompact refresh).
-    const all = s.list(SESS);
+    const all = vectorList(s, SESS);
     const leaves = all.map((cp) => ({
         id: cp.checkpointId,
         messages: [],
@@ -49,7 +49,7 @@ test("Fix D: vectorStore.search serves a persisted RAPTOR tree (broader recall)"
     assert.ok(tree && listRaptorNodes(SESS, stateDir).length > 0, "tree persisted");
     // With the tree live + RAPTOR_ENABLED, search still returns hits and now
     // exercises the RAPTOR-served path without regression.
-    const withTree = s.search(SESS, "alpha wire bootstrap", 3);
+    const withTree = vectorSearch(s, SESS, "alpha wire bootstrap", 3);
     assert.ok(withTree.length > 0, "search returns hits with RAPTOR promoted");
     // Every returned hit is a real checkpoint in the session.
     for (const h of withTree) {
@@ -60,7 +60,7 @@ test("Fix D: search still works for a session with <2 leaves (no tree)", () => {
     const stateDir = join(baseTmp, `run-${counter++}`);
     const s = new VectorStore({ dedupSim: 0.9, stateDir, config: raptorConfig() });
     compactSession({ sessionId: SESS, messages: [msg("only one topic here"), msg("ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
-    const r = s.search(SESS, "only one topic", 3);
+    const r = vectorSearch(s, SESS, "only one topic", 3);
     assert.ok(r.length > 0, "single-checkpoint search still works (no tree)");
     assert.equal(listRaptorNodes(SESS, stateDir).length, 0, "no tree built for <2 leaves");
 });

package/dist/src/dedup/sprint12.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, L2_ENABLED } from "../vectorStore.js";
+import { VectorStore, L2_ENABLED, vectorSemDedup, vectorList, vectorSearch } from "../vectorStore.js";
 import { mmrRerank } from "./mmr.js";
 import { topK } from "./topk.js";
 import { cosineSimilarity, defaultEmbedder } from "../embedder.js";
@@ -67,7 +67,7 @@ test("L2_ENABLED defaults true; search still returns hits", () => {
     assert.equal(L2_ENABLED, true);
     const s = store();
     s.add({ sessionId: "sess_l2", summary: "investigated the parser", regionText: "investigated src/parser.ts and added a tokenizer", timestamp: 1 });
-    const hits = s.search("sess_l2", "src/parser.ts tokenizer", 3);
+    const hits = vectorSearch(s, "sess_l2", "src/parser.ts tokenizer", 3);
     assert.ok(hits.length >= 1);
 });
 test("L2_ENABLED=false skips semantic tier but L0/L1 still work", () => {
@@ -106,14 +106,14 @@ test("semDedup marks redundant near-identical rows 'removed' and search excludes
         { id: "chkpt_001", text: "the cache stores parsed ast nodes for fast lookup", tok: 100 },
         { id: "chkpt_002", text: "the cache stores parsed ast nodes for fast lookup and reuse", tok: 900 },
     ]);
-    const removed = s.semDedup("sess_sd", 0.85);
+    const removed = vectorSemDedup(s, "sess_sd", 0.85);
     assert.equal(removed, 1);
-    const st = s.list("sess_sd");
+    const st = vectorList(s, "sess_sd");
     const dropped = st.find((c) => c.dedupStatus === "removed");
     assert.ok(dropped);
     assert.equal(dropped.checkpointId, "chkpt_001"); // lower tokenEstimate removed
     // Search excludes the removed row (only one active remains).
-    const hits = s.search("sess_sd", "cache parsed ast nodes", 5);
+    const hits = vectorSearch(s, "sess_sd", "cache parsed ast nodes", 5);
     assert.equal(hits.length, 1);
 });
 test("semDedup is idempotent (re-run removes nothing new)", () => {
@@ -123,8 +123,8 @@ test("semDedup is idempotent (re-run removes nothing new)", () => {
         { id: "chkpt_001", text: "identical region text for the dedup job now", tok: 100 },
         { id: "chkpt_002", text: "identical region text for the dedup job right now", tok: 200 },
     ]);
-    const first = s.semDedup("sess_sd2", 0.85);
-    const second = s.semDedup("sess_sd2", 0.85);
+    const first = vectorSemDedup(s, "sess_sd2", 0.85);
+    const second = vectorSemDedup(s, "sess_sd2", 0.85);
     assert.equal(first, 1);
     assert.equal(second, 0);
 });

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) --------------------