pi-mega-compact 0.8.21 → 0.8.22

package/extensions/mega-commands.ts

@@ -14,6 +14,7 @@ import { decompressSmart } from "../src/store/compression.js";
 import { loadMetrics, fpRate, p95, defaultMetricsPath } from "../src/monitoring.js";
 import { type MegaRuntime, C, recentUserQuery } from "./mega-runtime.js";
 import { runCompact, doRecall, doRecallAsync } from "./mega-pipeline.js";
+import { vectorStats, vectorRepoStats, vectorDataInvariant } from "../src/vectorStore.js";
 import type { MegaConfig } from "./mega-config.js";
 
 /** Resolve a checkpoint by id (or "recent"/"last") from this session's store. */
@@ -95,9 +96,9 @@ export function registerCommands(pi: ExtensionAPI, runtime: MegaRuntime, 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: number) =>
         b >= 1_048_576 ? `${(b / 1_048_576).toFixed(1)} MiB` :
           b >= 1024 ? `${(b / 1024).toFixed(1)} KiB` : `${b} B`;

package/extensions/mega-events/agent-handlers.ts

@@ -20,6 +20,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(
@@ -244,7 +245,7 @@ export function registerAgentHandlers(
 		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/extensions/mega-events/compact-handlers.ts

@@ -110,6 +110,34 @@ export function registerCompactHandlers(
 				activeAgents: runtime.activeAgents,
 			});
 			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/extensions/mega-events/session-handlers.ts

@@ -17,6 +17,7 @@ import {
 	doRecallAsync,
 } from "../mega-pipeline.js";
 import { recallMemoriesAndInline } from "../../src/recall.js";
+import { vectorStats } from "../../src/vectorStore.js";
 import type { MegaConfig } from "../mega-config.js";
 
 /** Register session lifecycle event handlers. */
@@ -50,7 +51,7 @@ export function registerSessionHandlers(
 		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/extensions/mega-pipeline/compact.ts

@@ -27,6 +27,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";
 
 export type RunCompactResult =
   | { skipped: true }
@@ -212,7 +213,7 @@ function doCompact(
   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: [],
@@ -248,7 +249,7 @@ function doCompact(
   // 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(

package/extensions/mega-runtime/state.ts

@@ -14,7 +14,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 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";
@@ -365,8 +365,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,
@@ -404,9 +404,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);
@@ -555,7 +555,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/extensions/openclaw-mega-compact.ts

@@ -22,7 +22,7 @@ import {
   type CompactResult,
 } from "../src/engine.js";
 import { recallAndInline, recallMemoriesAndInline, type RecallInjectResult } from "../src/recall.js";
-import { VectorStore } from "../src/vectorStore.js";
+import { VectorStore, vectorStats } from "../src/vectorStore.js";
 import type { EngineMessage } from "../src/types.js";
 
 // ---------------------------------------------------------------------------
@@ -260,7 +260,7 @@ export default definePluginEntry({
         const sessionId = (args as Record<string, string>)?.sessionId ?? "global";
 
         try {
-          const stats = store.stats(sessionId);
+          const stats = vectorStats(store, sessionId);
           const parts: string[] = [
             `**Mega Compact Status**`,
             `Session: ${sessionId}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.8.21",
+  "version": "0.8.22",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",

package/src/dedup/raptor/promote.test.ts

@@ -12,7 +12,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";
@@ -44,11 +44,11 @@ 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: [],
@@ -60,7 +60,7 @@ test("Fix D: vectorStore.search serves a persisted RAPTOR tree (broader recall)"
 
   // 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) {
@@ -72,7 +72,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/src/dedup/sprint12.test.ts

@@ -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";
@@ -79,7 +79,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);
 });
 
@@ -122,14 +122,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);
 });
 
@@ -140,8 +140,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/src/dedup-engine.test.ts

@@ -17,7 +17,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";
@@ -181,7 +181,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", () => {
@@ -194,7 +194,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", () => {
@@ -209,11 +209,11 @@ describe("Dedupe Levels", () => {
 
     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", () => {
@@ -233,11 +233,11 @@ describe("Dedupe Levels", () => {
 
     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", () => {
@@ -254,7 +254,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", () => {
@@ -284,8 +284,8 @@ describe("Dedupe Levels", () => {
       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");
   });
 });
 
@@ -354,18 +354,18 @@ describe("Compression / Store Stats", () => {
     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(
@@ -387,10 +387,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;
-    if (first) s.markInjected(SESS, first);
+    const first = vectorSearch(s, SESS, base, 1)[0]?.checkpoint.checkpointId;
+    if (first) vectorMarkInjected(s,SESS, first);
 
-    const stats = s.stats(SESS);
+    const stats = vectorStats(s,SESS);
     assert.ok(stats.checkpointCount >= 1);
     assert.ok(
       stats.dedupHitRate > 0 || stats.checkpointCount === 1,
@@ -444,16 +444,16 @@ describe("Recall & Dedup Sentinel", () => {
     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");
+    assert.equal(vectorWasInjected(s,SESS, cpId), false, "not yet injected");
 
-    s.markInjected(SESS, cpId);
-    assert.equal(s.wasInjected(SESS, cpId), true, "markInjected recorded");
+    vectorMarkInjected(s,SESS, cpId);
+    assert.equal(vectorWasInjected(s,SESS, cpId), true, "markInjected recorded");
 
-    const hits2 = s.search(SESS, "manual sentinel", 3).filter(
-      (h) => !s.wasInjected(SESS, h.checkpoint.checkpointId),
+    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");
   });
@@ -469,7 +469,7 @@ 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", () => {
@@ -479,7 +479,7 @@ describe("Edge Cases", () => {
       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)", () => {
@@ -491,7 +491,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", () => {
@@ -501,7 +501,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(
@@ -518,8 +518,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);
   });
 
@@ -542,7 +542,7 @@ describe("Edge Cases", () => {
         r.summary.includes("assistant"),
       "summary should reference roles or tools",
     );
-    assert.equal(s.list(SESS).length, 1);
+    assert.equal(vectorList(s,SESS).length, 1);
   });
 });