pi-mega-compact 0.8.21 → 0.8.23

package/src/dedup/raptor/multilevel.ts

@@ -0,0 +1,246 @@
+/**
+ * multilevel.ts — Multi-level RAPTOR retrieval engine (S42A).
+ *
+ * Upgrades the RAPTOR recall path from flat (leaf-only) to multi-level
+ * retrieval across the entire hierarchical tree. Searches ALL levels with
+ * configurable level weights, supports leaf expansion for cluster hits,
+ * and deduplicates overlapping results.
+ *
+ * PREVENT-PI-004: pure in-process math (cosine, BFS, extractive). No network.
+ * PREVENT-PI-001: produces SearchHit[] that feed into recallAndInline() —
+ * affects which checkpoints are recalled, not how messages are dropped.
+ */
+
+import type { Embedder, Vector } from "../../embedder.js";
+import { cosineSimilarity } from "../../embedder.js";
+import { mmrRerank } from "../mmr.js";
+import type { RaptorTree } from "./tree.js";
+import { leafDescendants } from "./retrieval.js";
+
+// ── S42A-1: Types ──────────────────────────────────────────────────────────
+
+export interface MultilevelRetrieveOptions {
+  embedder: Embedder;
+  /** Weight per tree level (index 0 = leaves, index 1 = level 1, etc.).
+   *  Default: [1.0, 0.9, 0.8, 0.7, 0.5]. Capped at tree depth.
+   *  UNCALIBRATED — requires real-data calibration before stable. */
+  levelWeights?: number[];
+  /** When true, expand cluster hits to include leaf descendants. Default: true. */
+  leafExpansion?: boolean;
+  /** Max leaf descendants to fetch per cluster hit. Default: 10. */
+  maxLeafExpansion?: number;
+  /** Final number of results to return. Default: 5. */
+  k?: number;
+  /** MMR diversity weight. Default: 0.5. */
+  mmrLambda?: number;
+}
+
+export interface MultilevelHit {
+  nodeId: string;
+  level: number;
+  /** Weighted score after level weighting. */
+  score: number;
+  /** Raw cosine similarity before level weighting. */
+  rawScore: number;
+  isLeaf: boolean;
+  /** Leaf ids covered by this node (for leaf expansion). */
+  leafIds: string[];
+  summary: string;
+  embedding: Vector;
+}
+
+const DEFAULT_LEVEL_WEIGHTS = [1.0, 0.9, 0.8, 0.7, 0.5];
+
+// ── S42A-2: Level-weighted scoring ─────────────────────────────────────────
+
+/**
+ * Score all RAPTOR tree nodes by cosine similarity to the query, then apply
+ * level-specific weights. Returns hits sorted by weighted score descending.
+ *
+ * Level weights: leaves (level 0) get weight 1.0, level 1 gets 0.9, etc.
+ * This ensures detailed leaves score highest while still surfacing higher-level
+ * summaries when they're highly relevant.
+ */
+export function scoreTreeLevels(
+  query: string,
+  tree: RaptorTree,
+  opts: Pick<MultilevelRetrieveOptions, "embedder" | "levelWeights">,
+): MultilevelHit[] {
+  const { embedder } = opts;
+  const weights = opts.levelWeights ?? DEFAULT_LEVEL_WEIGHTS;
+  const qv = embedder.embed(query);
+  const hits: MultilevelHit[] = [];
+
+  // 1. Score all internal (summary) nodes.
+  for (const node of tree.nodes.values()) {
+    const rawScore = cosineSimilarity(qv, node.embedding);
+    const levelWeight = weights[Math.min(node.level, weights.length - 1)];
+    hits.push({
+      nodeId: node.id,
+      level: node.level,
+      score: rawScore * levelWeight,
+      rawScore,
+      isLeaf: false,
+      leafIds: node.children,
+      summary: node.summary,
+      embedding: node.embedding,
+    });
+  }
+
+  // 2. Score leaf nodes. Leaf ids are not in tree.nodes — they are children
+  //    referenced by internal nodes. Each leaf's embedding is the level-0
+  //    parent node that wraps it (same approach as stagedExpansion:95–102).
+  const seenLeaves = new Set<string>();
+  for (const node of tree.nodes.values()) {
+    for (const leafId of node.children) {
+      if (seenLeaves.has(leafId) || tree.nodes.has(leafId)) continue;
+      seenLeaves.add(leafId);
+      const rawScore = cosineSimilarity(qv, node.embedding);
+      const leafWeight = weights[0];
+      hits.push({
+        nodeId: leafId,
+        level: 0,
+        score: rawScore * leafWeight,
+        rawScore,
+        isLeaf: true,
+        leafIds: [leafId],
+        summary: "", // leaves have no summary — they are raw checkpoint ids
+        embedding: node.embedding,
+      });
+    }
+  }
+
+  hits.sort((a, b) => b.score - a.score);
+  return hits;
+}
+
+// ── S42A-3: Leaf expansion ─────────────────────────────────────────────────
+
+/**
+ * Given a set of cluster-level hits, expand each one to include its leaf
+ * descendants. Deduplicates: if a leaf is already present as a direct hit,
+ * it is not duplicated. Returns the merged set (original hits + expanded leaves).
+ */
+export function expandLeafDescendants(
+  hits: MultilevelHit[],
+  tree: RaptorTree,
+  maxPerCluster: number,
+  _embedder: Embedder,
+  queryVector: Vector,
+  levelWeights?: number[],
+): MultilevelHit[] {
+  const weights = levelWeights ?? DEFAULT_LEVEL_WEIGHTS;
+  const existingIds = new Set(hits.map((h) => h.nodeId));
+  const expanded: MultilevelHit[] = [];
+
+  for (const hit of hits) {
+    if (hit.isLeaf) {
+      expanded.push(hit);
+      continue;
+    }
+
+    // Get all leaf descendants for this cluster node.
+    const node = tree.nodes.get(hit.nodeId);
+    if (!node) {
+      expanded.push(hit);
+      continue;
+    }
+
+    const rawLeafIds = leafDescendants(node, tree);
+
+    // Sort by cosine similarity to query, cap at maxPerCluster.
+    const leafHits: MultilevelHit[] = rawLeafIds
+      .map((lid) => {
+        // Leaf embedding = its nearest internal parent's embedding.
+        const parent = [...tree.nodes.values()].find((n) =>
+          n.children.includes(lid),
+        );
+        const sim = parent
+          ? cosineSimilarity(queryVector, parent.embedding)
+          : 0;
+        return { lid, sim, parent };
+      })
+      .sort((a, b) => b.sim - a.sim)
+      .slice(0, maxPerCluster)
+      .filter((l) => !existingIds.has(l.lid))
+      .map((l) => {
+        existingIds.add(l.lid);
+        const rawScore = l.sim;
+        return {
+          nodeId: l.lid,
+          level: 0,
+          score: rawScore * weights[0],
+          rawScore,
+          isLeaf: true,
+          leafIds: [l.lid],
+          summary: "",
+          embedding: l.parent?.embedding ?? hit.embedding,
+        } as MultilevelHit;
+      });
+
+    expanded.push(hit, ...leafHits);
+  }
+
+  return expanded;
+}
+
+// ── S42A-4: Result dedup ───────────────────────────────────────────────────
+
+/**
+ * Deduplicate hits: if both a cluster node and its leaf children appear in
+ * results, remove the cluster hit (leaves provide more specific context).
+ * If no leaves are in the set, keep the cluster hit (it provides the abstract view).
+ */
+export function deduplicateMultilevelHits(hits: MultilevelHit[]): MultilevelHit[] {
+  const leafIds = new Set(hits.filter((h) => h.isLeaf).map((h) => h.nodeId));
+  return hits.filter((h) => {
+    if (h.isLeaf) return true;
+    // Cluster hit: keep only if none of its leaf children are present.
+    return !h.leafIds.some((lid) => leafIds.has(lid));
+  });
+}
+
+// ── S42A-5: Top-level pipeline ─────────────────────────────────────────────
+
+/**
+ * Full multi-level retrieval pipeline: score → expand → dedup → MMR → top-K.
+ * Drop-in replacement for `stagedExpansion()` in the RAPTOR recall path.
+ */
+export function multilevelRetrieval(
+  query: string,
+  tree: RaptorTree,
+  opts: MultilevelRetrieveOptions,
+): MultilevelHit[] {
+  if (!tree.rootId) return [];
+
+  const { embedder } = opts;
+  const weights = opts.levelWeights ?? DEFAULT_LEVEL_WEIGHTS;
+  const leafExp = opts.leafExpansion !== false; // default true
+  const maxLeafExp = opts.maxLeafExpansion ?? 10;
+  const k = opts.k ?? 5;
+  const lambda = opts.mmrLambda ?? 0.5;
+
+  const qv = embedder.embed(query);
+
+  // 1. Score all nodes with level weights.
+  const scored = scoreTreeLevels(query, tree, { embedder, levelWeights: weights });
+
+  // 2. Top-N candidates for MMR diversity window.
+  const topN = scored.slice(0, k * 3);
+
+  // 3. Leaf expansion (optional).
+  const expanded = leafExp
+    ? expandLeafDescendants(topN, tree, maxLeafExp, embedder, qv, weights)
+    : topN;
+
+  // 4. Dedup: remove cluster hits when leaf children are present.
+  const deduped = deduplicateMultilevelHits(expanded);
+
+  // 5. MMR rerank to k.
+  const mmrItems = deduped.map((h) => ({
+    item: h,
+    vector: h.embedding as Vector,
+    relevance: h.score,
+  }));
+  return mmrRerank(mmrItems, k, lambda);
+}

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/raptor/retrieval.ts

@@ -33,7 +33,7 @@ function isLeafId(id: string, tree: RaptorTree): boolean {
 }
 
 /** All leaf (raw) ids reachable beneath a node via BFS. */
-function leafDescendants(node: RaptorNode, tree: RaptorTree): string[] {
+export function leafDescendants(node: RaptorNode, tree: RaptorTree): string[] {
   const out: string[] = [];
   const queue = [node];
   while (queue.length) {

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