recallnest 2.3.0 → 2.5.4

package/src/__tests__/llm-consolidation.test.ts

@@ -0,0 +1,226 @@
+/**
+ * Tests for Tier 3.7: LLM-Driven Consolidation
+ *
+ * Validates:
+ * 1. evaluateCluster returns merge decisions from LLM
+ * 2. evaluateCluster falls back conservatively on LLM failure
+ * 3. executeMergeDecisions creates version groups for merge groups
+ * 4. executeMergeDecisions handles empty merge groups
+ * 5. isLLMConsolidationEnabled respects env var
+ */
+import { describe, expect, it, afterEach } from "bun:test";
+import {
+  evaluateCluster,
+  executeMergeDecisions,
+  isLLMConsolidationEnabled,
+} from "../llm-consolidation.js";
+import type { MemoryEntry } from "../store.js";
+import type { LLMClient } from "../llm-client.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeEntry(id: string, text: string, importance = 0.7): MemoryEntry {
+  return {
+    id,
+    text,
+    vector: [1, 0, 0],
+    category: "preferences",
+    scope: "project:test",
+    importance,
+    timestamp: Date.now(),
+    metadata: JSON.stringify({ confidence: 0.7, accessCount: 0 }),
+  };
+}
+
+function createMockStore(entries: MemoryEntry[]) {
+  const data = new Map(entries.map(e => [e.id, { ...e }]));
+  const updates: Array<{ id: string; metadata: string }> = [];
+
+  return {
+    data,
+    updates,
+    async getById(id: string) { return data.get(id) ?? null; },
+    async update(id: string, upd: { metadata?: string }, _scope?: string[]) {
+      const entry = data.get(id);
+      if (!entry) return null;
+      if (upd.metadata) {
+        entry.metadata = upd.metadata;
+        updates.push({ id, metadata: upd.metadata });
+      }
+      return entry;
+    },
+  };
+}
+
+function createMockLLM(response: string): LLMClient {
+  return {
+    async synthesizeFragments() {
+      return response;
+    },
+  } as any;
+}
+
+// ---------------------------------------------------------------------------
+// evaluateCluster
+// ---------------------------------------------------------------------------
+
+describe("evaluateCluster", () => {
+  it("returns merge groups from LLM response", async () => {
+    const entries = [
+      makeEntry("a", "User prefers dark mode"),
+      makeEntry("b", "User likes dark theme"),
+      makeEntry("c", "User uses vim keybindings"),
+    ];
+
+    const llm = createMockLLM(JSON.stringify({
+      mergeGroups: [[0, 1]],
+      keepSeparate: [2],
+      reasoning: "0 and 1 express same preference, 2 is different",
+    }));
+
+    const decision = await evaluateCluster(llm, entries);
+
+    expect(decision.mergeGroups.length).toBe(1);
+    expect(decision.mergeGroups[0]).toEqual([0, 1]);
+    expect(decision.keepSeparate).toEqual([2]);
+  });
+
+  it("returns conservative fallback on LLM failure", async () => {
+    const entries = [makeEntry("a", "text a"), makeEntry("b", "text b")];
+    const llm = {
+      async synthesizeFragments() { throw new Error("LLM down"); },
+    } as any;
+
+    const decision = await evaluateCluster(llm, entries);
+
+    expect(decision.mergeGroups.length).toBe(0);
+    expect(decision.keepSeparate.length).toBe(2);
+  });
+
+  it("returns conservative fallback on null response", async () => {
+    const entries = [makeEntry("a", "text a"), makeEntry("b", "text b")];
+    const llm = createMockLLM("");
+
+    // Empty string → null synthesis → fallback
+    const decision = await evaluateCluster({ async synthesizeFragments() { return null; } } as any, entries);
+
+    expect(decision.mergeGroups.length).toBe(0);
+  });
+
+  it("handles single entry", async () => {
+    const entries = [makeEntry("a", "only one")];
+    const llm = createMockLLM("{}");
+
+    const decision = await evaluateCluster(llm, entries);
+
+    expect(decision.mergeGroups.length).toBe(0);
+    expect(decision.keepSeparate).toEqual([0]);
+  });
+
+  it("filters invalid indices from LLM response", async () => {
+    const entries = [makeEntry("a", "text a"), makeEntry("b", "text b")];
+    const llm = createMockLLM(JSON.stringify({
+      mergeGroups: [[0, 5]], // index 5 out of range
+      keepSeparate: [0, 1],
+      reasoning: "test",
+    }));
+
+    const decision = await evaluateCluster(llm, entries);
+
+    // Invalid group should be filtered out
+    expect(decision.mergeGroups.length).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// executeMergeDecisions
+// ---------------------------------------------------------------------------
+
+describe("executeMergeDecisions", () => {
+  it("creates version groups for merge groups", async () => {
+    const entries = [
+      makeEntry("a", "dark mode pref", 0.9),
+      makeEntry("b", "dark theme pref", 0.5),
+      makeEntry("c", "vim pref", 0.7),
+    ];
+    const store = createMockStore(entries);
+
+    const decision = {
+      mergeGroups: [[0, 1]],
+      keepSeparate: [2],
+      reasoning: "similar preferences",
+    };
+
+    const mergeCount = await executeMergeDecisions(store as any, entries, decision, "project:test");
+
+    expect(mergeCount).toBe(1);
+    // Both a and b should now have version_group
+    const metaA = JSON.parse(store.data.get("a")!.metadata);
+    const metaB = JSON.parse(store.data.get("b")!.metadata);
+    expect(metaA.version_group).toBeTruthy();
+    expect(metaB.version_group).toBe(metaA.version_group);
+  });
+
+  it("handles empty merge groups", async () => {
+    const entries = [makeEntry("a", "text a")];
+    const store = createMockStore(entries);
+
+    const decision = {
+      mergeGroups: [],
+      keepSeparate: [0],
+      reasoning: "nothing to merge",
+    };
+
+    const mergeCount = await executeMergeDecisions(store as any, entries, decision, "project:test");
+
+    expect(mergeCount).toBe(0);
+  });
+
+  it("handles multi-entry merge group", async () => {
+    const entries = [
+      makeEntry("a", "pref 1", 0.9),
+      makeEntry("b", "pref 2", 0.7),
+      makeEntry("c", "pref 3", 0.5),
+    ];
+    const store = createMockStore(entries);
+
+    const decision = {
+      mergeGroups: [[0, 1, 2]],
+      keepSeparate: [],
+      reasoning: "all same",
+    };
+
+    const mergeCount = await executeMergeDecisions(store as any, entries, decision, "project:test");
+
+    // a is canonical, b and c are members → 2 merges
+    expect(mergeCount).toBe(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isLLMConsolidationEnabled
+// ---------------------------------------------------------------------------
+
+describe("isLLMConsolidationEnabled", () => {
+  const originalEnv = process.env.RECALLNEST_LLM_CONSOLIDATION;
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.RECALLNEST_LLM_CONSOLIDATION = originalEnv;
+    } else {
+      delete process.env.RECALLNEST_LLM_CONSOLIDATION;
+    }
+  });
+
+  it("returns false when not set", () => {
+    delete process.env.RECALLNEST_LLM_CONSOLIDATION;
+    expect(isLLMConsolidationEnabled()).toBe(false);
+  });
+
+  it("returns true when set to 'true'", () => {
+    process.env.RECALLNEST_LLM_CONSOLIDATION = "true";
+    expect(isLLMConsolidationEnabled()).toBe(true);
+  });
+});

package/src/__tests__/maintenance-locks.test.ts

@@ -0,0 +1,174 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { runDream } from "../dream-pipeline.js";
+import { maybeRunGc, resetGcTimestamp, type AutoGcConfig, DEFAULT_AUTO_GC_CONFIG } from "../auto-gc.js";
+import { lockPathForKey } from "../distill-lock.js";
+import { incrementWriteCount, getWriteCount } from "../activity-counter.js";
+
+// Isolate dream's activity-counter reads/writes to a temp file so tests never touch the
+// repo's data/activity-stats.json (which the production dream scheduler reads).
+const DREAM_STATS = join(mkdtempSync(join(tmpdir(), "rn-dream-stats-")), "activity-stats.json");
+
+/**
+ * P0-1 接线回归：dream/gc 维护入口接了跨进程锁。用「预写一个当前进程 PID 的锁文件」
+ * 模拟「另一进程持有锁」（同进程 PID 恒活，acquireLock 判定为被占）。
+ */
+
+const createdLocks: string[] = [];
+function holdLock(key: string): string {
+  const p = lockPathForKey(key);
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, String(process.pid), "utf-8"); // current pid ⇒ acquireLock sees it as a live holder
+  createdLocks.push(p);
+  return p;
+}
+
+afterEach(() => {
+  while (createdLocks.length > 0) {
+    try {
+      rmSync(createdLocks.pop()!, { force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+  resetGcTimestamp();
+});
+
+describe("runDream cross-process lock", () => {
+  it("skips (ran:false, locked) and does not run the body when the scope lock is held", async () => {
+    const scope = "project:dream-lock-test";
+    holdLock(`dream-${scope}`);
+
+    let bodyRan = false;
+    const store = {
+      stats: async () => {
+        bodyRan = true;
+        return { totalCount: 100, scopeCounts: {}, categoryCounts: {} };
+      },
+      list: async () => [],
+      listPage: async () => [],
+      update: async () => null,
+      patchMetadata: async () => null,
+    };
+
+    const result = await runDream({
+      store: store as any,
+      llm: null,
+      embedder: { embedPassage: async () => [0, 0, 0] },
+      scope,
+      force: true,
+      activityStatsPath: DREAM_STATS,
+    });
+
+    expect(result.ran).toBe(false);
+    expect(result.reason).toBe("locked_by_another_process");
+    expect(bodyRan).toBe(false); // runDreamInner never entered
+  });
+
+  it("skips its consolidation phase when the scope's consolidate lock is held", async () => {
+    const scope = "project:dream-consolidate-test";
+    holdLock(`consolidate-${scope}`); // simulate a standalone consolidate_memories running
+
+    const activeMeta = JSON.stringify({
+      evolution: { status: "active", version: 1, accessCount: 0, lastAccessedAt: null, validFrom: Date.now(), validUntil: null },
+    });
+    const entries = [1, 2, 3].map((i) => ({
+      id: `dc-e${i}`, text: `t${i}`, vector: [1, 0, 0], category: "events", scope,
+      importance: 0.5, timestamp: Date.now(), metadata: activeMeta, language: "en", fts_text: `t${i}`,
+    }));
+    const store = {
+      stats: async () => ({ totalCount: 100, scopeCounts: {}, categoryCounts: {} }),
+      list: async () => entries,
+      listPage: async () => [],
+      update: async () => null,
+      patchMetadata: async () => null,
+      getById: async () => null,
+      vectorSearch: async () => [],
+    };
+
+    const result = await runDream({
+      store: store as any,
+      llm: null,
+      embedder: { embedPassage: async () => [0, 0, 0] },
+      scope,
+      force: true,
+      activityStatsPath: DREAM_STATS,
+    });
+
+    // Dream itself ran (its own dream lock was free), but the consolidation phase saw the
+    // held consolidate lock and skipped rather than running concurrently.
+    expect(result.ran).toBe(true);
+    const consolidatePhase = result.phases.find((p) => p.phase === "consolidate");
+    expect(consolidatePhase?.detail).toContain("skipped");
+  });
+
+  it("resets the scope's write counter after a run (no perpetual self-triggering)", async () => {
+    const scope = "project:dream-reset-test";
+    const statsPath = join(mkdtempSync(join(tmpdir(), "rn-reset-")), "activity-stats.json");
+    // Pre-load above threshold, standing in for accumulated writes (incl. any dream self-writes).
+    incrementWriteCount(scope, 15, { statsPath });
+    expect(getWriteCount(scope, { statsPath })).toBe(15);
+
+    const store = {
+      stats: async () => ({ totalCount: 5, scopeCounts: {}, categoryCounts: {} }),
+      list: async () => [], // no active entries → completed_early path (still resets)
+      listPage: async () => [],
+      update: async () => null,
+      patchMetadata: async () => null,
+      getById: async () => null,
+      vectorSearch: async () => [],
+    };
+    const result = await runDream({
+      store: store as any,
+      llm: null,
+      embedder: { embedPassage: async () => [0, 0, 0] },
+      scope,
+      force: true,
+      activityStatsPath: statsPath,
+    });
+
+    expect(result.ran).toBe(true);
+    // Reset at dream's end clears the counter, so dream won't immediately self-retrigger —
+    // fresh external writes must accumulate past the threshold again.
+    expect(getWriteCount(scope, { statsPath })).toBe(0);
+  });
+});
+
+describe("maybeRunGc cross-process lock + throttle", () => {
+  function makeStore(totalCount: number) {
+    return {
+      stats: async () => ({ totalCount, scopeCounts: {}, categoryCounts: {} }),
+      listPage: async () => [] as unknown[],
+      update: async () => null,
+      list: async () => [],
+    } as any;
+  }
+
+  it("skips (locked) when another process holds the gc run lock", async () => {
+    resetGcTimestamp();
+    holdLock("gc-run");
+    const config: AutoGcConfig = { ...DEFAULT_AUTO_GC_CONFIG, minMemoryCount: 1, minHoursSinceLastGc: 24 };
+    const result = await maybeRunGc(makeStore(10), config);
+    expect(result.triggered).toBe(false);
+    expect(result.reason).toBe("locked_by_another_process");
+  });
+
+  it("throttles a second run within the window, then runs again after reset", async () => {
+    resetGcTimestamp();
+    const config: AutoGcConfig = { ...DEFAULT_AUTO_GC_CONFIG, minMemoryCount: 1, minHoursSinceLastGc: 24 };
+
+    const first = await maybeRunGc(makeStore(10), config);
+    expect(first.triggered).toBe(true);
+
+    const second = await maybeRunGc(makeStore(10), config);
+    expect(second.triggered).toBe(false);
+    expect(second.reason).toBe("too_soon");
+
+    resetGcTimestamp();
+    const third = await maybeRunGc(makeStore(10), config);
+    expect(third.triggered).toBe(true);
+  });
+});

package/src/__tests__/mcp-efficiency.test.ts

@@ -0,0 +1,288 @@
+import { describe, expect, it } from "bun:test";
+
+import type { RetrievalResult } from "../retriever.js";
+import { formatBriefResults, formatFullResults } from "../memory-output.js";
+import { persistMemoryBatch } from "../capture-engine.js";
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+function makeResult(overrides: {
+  id?: string;
+  text?: string;
+  score?: number;
+  metadata?: string;
+  category?: string;
+  importance?: number;
+  timestamp?: number;
+} = {}): RetrievalResult {
+  return {
+    entry: {
+      id: overrides.id ?? "abcdef12-3456-7890-abcd-ef1234567890",
+      text: overrides.text ?? "Default memory text for testing purposes",
+      vector: [0.1, 0.2, 0.3],
+      category: overrides.category ?? "events",
+      scope: "project:test",
+      importance: overrides.importance ?? 0.7,
+      timestamp: overrides.timestamp ?? 1_700_000_000_000,
+      metadata: overrides.metadata,
+    },
+    score: overrides.score ?? 0.85,
+    sources: {
+      vector: { score: 0.8, rank: 1 },
+      fused: { score: overrides.score ?? 0.85 },
+    },
+  };
+}
+
+function createDeps() {
+  const storedEntries: Record<string, unknown>[] = [];
+  const conflicts: Record<string, unknown>[] = [];
+  let seq = 1;
+
+  return {
+    storedEntries,
+    conflicts,
+    deps: {
+      embedder: {
+        async embedPassage(_text: string) {
+          return [1, 0, 0];
+        },
+      },
+      store: {
+        async store(entry: Record<string, unknown>) {
+          const stored = {
+            ...entry,
+            id: `00000000-0000-0000-0000-${String(seq).padStart(12, "0")}`,
+            timestamp: 1_700_000_000_000 + seq,
+          };
+          seq += 1;
+          storedEntries.push(stored);
+          return stored;
+        },
+        async search(_params: Record<string, unknown>) {
+          return [];
+        },
+        async getByScope(_scope: string) {
+          return [];
+        },
+      },
+      conflictStore: {
+        async save(record: Record<string, unknown>) {
+          conflicts.push(record);
+          return record;
+        },
+      },
+      kgExtractor: null,
+    },
+  };
+}
+
+// ============================================================================
+// MCP-1: list_tools
+// ============================================================================
+
+describe("MCP-1: list_tools tier discovery", () => {
+  // We test the tier filtering logic directly since we can't easily instantiate the MCP server.
+  // The TOOL_TIERS map and tier logic is exercised here.
+
+  const TOOL_TIERS: Record<string, string> = {
+    resume_context: "core",
+    search_memory: "core",
+    store_memory: "core",
+    checkpoint_session: "core",
+    latest_checkpoint: "core",
+    list_tools: "core",
+    set_reminder: "core",
+    batch_store: "advanced",
+    auto_capture: "advanced",
+    store_case: "advanced",
+    store_workflow_pattern: "advanced",
+    promote_memory: "advanced",
+    explain_memory: "advanced",
+    distill_memory: "advanced",
+    brief_memory: "advanced",
+    pin_memory: "advanced",
+    list_assets: "advanced",
+    list_pins: "advanced",
+    memory_stats: "advanced",
+    memory_drill_down: "advanced",
+    export_memory: "advanced",
+    store_skill: "advanced",
+    retrieve_skill: "advanced",
+    scan_skill_promotions: "governance",
+    workflow_observe: "governance",
+    workflow_health: "governance",
+  };
+
+  function listToolsForTier(requestedTier: "core" | "advanced" | "full"): string[] {
+    const tierOrder: Record<string, number> = { core: 0, advanced: 1, governance: 2 };
+    const maxOrder = requestedTier === "full" ? 2 : tierOrder[requestedTier] ?? 1;
+    return Object.entries(TOOL_TIERS)
+      .filter(([, toolTier]) => (tierOrder[toolTier] ?? 999) <= maxOrder)
+      .map(([name]) => name);
+  }
+
+  it("returns only core tier tools when tier=core", () => {
+    const tools = listToolsForTier("core");
+    expect(tools).toContain("resume_context");
+    expect(tools).toContain("search_memory");
+    expect(tools).toContain("list_tools");
+    expect(tools).not.toContain("auto_capture");
+    expect(tools).not.toContain("workflow_observe");
+    // Core should have exactly our known core tools
+    for (const t of tools) {
+      expect(TOOL_TIERS[t]).toBe("core");
+    }
+  });
+
+  it("returns core + advanced tools when tier=advanced", () => {
+    const tools = listToolsForTier("advanced");
+    // Should include core
+    expect(tools).toContain("resume_context");
+    expect(tools).toContain("search_memory");
+    expect(tools).toContain("list_tools");
+    // Should include advanced
+    expect(tools).toContain("auto_capture");
+    expect(tools).toContain("batch_store");
+    expect(tools).toContain("explain_memory");
+    // Should NOT include governance
+    expect(tools).not.toContain("workflow_observe");
+    expect(tools).not.toContain("scan_skill_promotions");
+  });
+
+  it("returns all tools when tier=full", () => {
+    const tools = listToolsForTier("full");
+    expect(tools).toContain("resume_context");
+    expect(tools).toContain("auto_capture");
+    expect(tools).toContain("workflow_observe");
+    expect(tools).toContain("scan_skill_promotions");
+    expect(tools.length).toBe(Object.keys(TOOL_TIERS).length);
+  });
+});
+
+// ============================================================================
+// MCP-2: formatBriefResults and formatFullResults
+// ============================================================================
+
+describe("MCP-2: formatBriefResults", () => {
+  it("returns no results message for empty array", () => {
+    const result = formatBriefResults([], { query: "test" });
+    expect(result).toBe("No results found.");
+  });
+
+  it("renders correct brief format", () => {
+    const results = [
+      makeResult({ id: "aabbccdd-1111-2222-3333-444455556666", score: 0.92, text: "User prefers TypeScript for all projects" }),
+      makeResult({ id: "11223344-aaaa-bbbb-cccc-ddddeeeeffff", score: 0.78, text: "Project RecallNest uses LanceDB" }),
+    ];
+    const output = formatBriefResults(results, { query: "typescript" });
+    expect(output).toContain("Query: typescript");
+    expect(output).toContain("Hits: 2");
+    expect(output).toContain("#1 aabbccdd 92.0%");
+    expect(output).toContain("#2 11223344 78.0%");
+    expect(output).toContain("User prefers TypeScript");
+  });
+
+  it("uses l0_abstract from metadata when available", () => {
+    const meta = JSON.stringify({ l0_abstract: "Short L0 summary for this memory" });
+    const results = [
+      makeResult({ metadata: meta, text: "Very long original text that should not appear in brief mode because the l0_abstract is available" }),
+    ];
+    const output = formatBriefResults(results, { query: "test" });
+    expect(output).toContain("Short L0 summary");
+    expect(output).not.toContain("Very long original text");
+  });
+
+  it("each brief result line is at most 120 characters", () => {
+    const results = [
+      makeResult({ text: "A".repeat(200) }),
+      makeResult({ id: "zzzzzzzz-0000-0000-0000-000000000000", text: "Short text" }),
+    ];
+    const output = formatBriefResults(results, { query: "q" });
+    const lines = output.split("\n");
+    // Only check result lines (starting with #)
+    for (const line of lines) {
+      if (line.startsWith("#")) {
+        expect(line.length).toBeLessThanOrEqual(120);
+      }
+    }
+  });
+});
+
+describe("MCP-2: formatFullResults", () => {
+  it("includes metadata details in full mode", () => {
+    const meta = JSON.stringify({ evolutionStatus: "stable", accessCount: 5, tags: ["ts", "dev"] });
+    const results = [
+      makeResult({ metadata: meta, importance: 0.85 }),
+    ];
+    const output = formatFullResults(results, { query: "test", profile: "default" });
+    expect(output).toContain("meta :");
+    expect(output).toContain("evolution=stable");
+    expect(output).toContain("accessCount=5");
+    expect(output).toContain("importance=0.85");
+    expect(output).toContain("tags=[ts, dev]");
+  });
+
+  it("shows dash for missing metadata fields", () => {
+    const results = [makeResult({})];
+    const output = formatFullResults(results, { query: "q", profile: "default" });
+    expect(output).toContain("evolution=-");
+    expect(output).toContain("accessCount=-");
+    expect(output).toContain("tags=[-]");
+  });
+});
+
+// ============================================================================
+// MCP-3: batch_store via persistMemoryBatch
+// ============================================================================
+
+describe("MCP-3: batch_store", () => {
+  it("stores multiple memories and returns all records", async () => {
+    const { deps, storedEntries } = createDeps();
+    const stored = await persistMemoryBatch(deps as Parameters<typeof persistMemoryBatch>[0], {
+      scope: "project:test",
+      source: "agent",
+      defaultImportance: 0.7,
+      memories: [
+        { text: "Memory one about TypeScript preferences", category: "preferences" },
+        { text: "Memory two about project structure", category: "entities" },
+        { text: "Memory three about debugging workflow", category: "patterns" },
+      ],
+    });
+
+    expect(stored).toHaveLength(3);
+    expect(storedEntries).toHaveLength(3);
+    expect(stored[0].disposition).toBe("stored");
+    expect(stored[1].disposition).toBe("stored");
+    expect(stored[2].disposition).toBe("stored");
+  });
+
+  it("returns correct disposition counts", async () => {
+    const { deps } = createDeps();
+    const stored = await persistMemoryBatch(deps as Parameters<typeof persistMemoryBatch>[0], {
+      scope: "project:test",
+      source: "agent",
+      defaultImportance: 0.7,
+      memories: [
+        { text: "First memory item" },
+        { text: "Second memory item" },
+      ],
+    });
+
+    // Count dispositions the same way the MCP handler does
+    const counts = { new: 0, deduped: 0, updated: 0 };
+    for (const r of stored) {
+      if (r.disposition === "deduped") counts.deduped++;
+      else if (r.disposition === "updated") counts.updated++;
+      else counts.new++;
+    }
+
+    expect(counts.new).toBe(2);
+    expect(counts.deduped).toBe(0);
+    expect(counts.updated).toBe(0);
+    expect(`Stored ${stored.length} memories (${counts.new} new, ${counts.deduped} deduped, ${counts.updated} updated)`)
+      .toBe("Stored 2 memories (2 new, 0 deduped, 0 updated)");
+  });
+});