recallnest 3.0.0 → 4.0.0

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

@@ -1,520 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { ConsolidationEngine, DEFAULT_CONSOLIDATION_CONFIG, formatConsolidationResult, tripleJaccard, type ConsolidationResult, type ConsolidationTripleEvidence } from "../consolidation-engine.js";
-import type { MemoryEntry, MemorySearchResult } from "../store.js";
-
-function makeEntry(overrides: Partial<MemoryEntry> & { id: string; text: string }): MemoryEntry {
-  return {
-    vector: [1, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: "{}",
-    ...overrides,
-  };
-}
-
-function createMockStore(entries: MemoryEntry[], similarityMap: Map<string, Map<string, number>> = new Map()) {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  const updates: Array<{ id: string; metadata: string }> = [];
-
-  return {
-    updates,
-    store: {
-      async list(scopeFilter?: string[], _category?: string, limit = 500, _offset = 0) {
-        return [...data.values()]
-          .filter(e => !scopeFilter || scopeFilter.some(s => e.scope === s))
-          .slice(0, limit);
-      },
-      async getById(id: string) {
-        return data.get(id) ?? null;
-      },
-      async vectorSearch(vector: number[], limit = 5, minScore = 0.3, scopeFilter?: string[]) {
-        // Use the similarity map to compute fake scores
-        const sourceEntry = [...data.values()].find(e =>
-          e.vector.length === vector.length && e.vector.every((v, i) => v === vector[i])
-        );
-        if (!sourceEntry) return [];
-
-        const sourceMap = similarityMap.get(sourceEntry.id);
-        if (!sourceMap) return [];
-
-        const results: MemorySearchResult[] = [];
-        for (const [targetId, score] of sourceMap) {
-          if (score < minScore) continue;
-          const target = data.get(targetId);
-          if (!target) continue;
-          if (scopeFilter && !scopeFilter.some(s => target.scope === s)) continue;
-          results.push({ entry: target, score });
-        }
-        return results.sort((a, b) => b.score - a.score).slice(0, limit);
-      },
-      async update(id: string, upd: { metadata?: 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;
-      },
-      // 2026-08-14: 忠实模拟生产语义 —— 以 mock 存储的最新行起底应用 patchFn、按序执行、
-      // 就地落库。批量写同样进 updates 数组，既有的 updates.find() 断言无需改动。
-      async patchMetadataBatch(
-        patches: Array<{ id: string; patchFn: (meta: Record<string, unknown>, entry: MemoryEntry) => Record<string, unknown> }>,
-        _scopeFilter?: string[],
-      ) {
-        let written = 0;
-        for (const { id, patchFn } of patches) {
-          const entry = data.get(id);
-          if (!entry) continue;
-          let meta: Record<string, unknown>;
-          try { meta = JSON.parse(entry.metadata || "{}") as Record<string, unknown>; } catch { meta = {}; }
-          const patched = patchFn(meta, entry);
-          entry.metadata = JSON.stringify(patched);
-          updates.push({ id, metadata: entry.metadata });
-          written++;
-        }
-        return written;
-      },
-    },
-  };
-}
-
-describe("ConsolidationEngine", () => {
-  it("returns empty result for empty scope", async () => {
-    const { store } = createMockStore([]);
-    const engine = new ConsolidationEngine(store);
-    const result = await engine.run("project:test");
-    expect(result.originalCount).toBe(0);
-    expect(result.clustersFound).toBe(0);
-  });
-
-  it("skips single-entry categories", async () => {
-    const entries = [makeEntry({ id: "a", text: "only one" })];
-    const { store } = createMockStore(entries);
-    const engine = new ConsolidationEngine(store);
-    const result = await engine.run("project:test");
-    expect(result.originalCount).toBe(1);
-    expect(result.clustersFound).toBe(0);
-  });
-
-  // 2026-08-14 Bug-1 回归：旧逐条写路径里 cluster 循环基于从不刷新的旧内存串 patch，
-  // member 的 consolidatedMeta 写与 canonical 的 sourceMemories 写会把 createVersionGroup
-  // 刚落库的 version_group 抹掉（2 成员 cluster 同样全丢），下一个 member 还会新造 groupId。
-  // 断言口径是**最终存储态**（getById 终值）——旧测试用 updates.find() 只看首写，恰好
-  // 看不见覆盖（互审 C3 指出的断言形态缺陷）。
-  it("Bug-1 回归：2 成员 merge 后双方 version_group 同组共存，sourceMemories/consolidatedInto 齐全", async () => {
-    const entryA = makeEntry({ id: "a", text: "canonical fact", vector: [1, 0, 0], importance: 0.9 });
-    const entryB = makeEntry({ id: "b", text: "duplicate fact", vector: [0.99, 0.1, 0], importance: 0.5 });
-    const simMap = new Map([
-      ["a", new Map([["b", 0.95]])],
-      ["b", new Map([["a", 0.95]])],
-    ]);
-    const { store } = createMockStore([entryA, entryB], simMap);
-    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, mergeThreshold: 0.92 });
-    await engine.run("project:test");
-
-    const finalA = JSON.parse((await store.getById("a"))!.metadata!) as Record<string, any>;
-    const finalB = JSON.parse((await store.getById("b"))!.metadata!) as Record<string, any>;
-    expect(typeof finalA.version_group).toBe("string");
-    expect(finalB.version_group).toBe(finalA.version_group); // 同组，且都没被后续写抹掉
-    expect(typeof finalA.version_rank).toBe("number");
-    expect(typeof finalB.version_rank).toBe("number");
-    expect(finalA.evolution.sourceMemories).toContain("b");
-    expect(finalB.evolution.status).toBe("consolidated");
-    expect(finalB.evolution.consolidatedInto).toBe("a");
-  });
-
-  it("Bug-1 回归：多 member merge 共享同一个 groupId，canonical 的 sourceMemories 不丢前面的 member", async () => {
-    const entryA = makeEntry({ id: "a", text: "fact v1", vector: [1, 0, 0], importance: 0.9 });
-    const entryB = makeEntry({ id: "b", text: "fact v2", vector: [0.99, 0.1, 0], importance: 0.5 });
-    const entryC = makeEntry({ id: "c", text: "fact v3", vector: [0.98, 0.15, 0], importance: 0.4 });
-    const simMap = new Map([
-      ["a", new Map([["b", 0.95], ["c", 0.94]])],
-      ["b", new Map([["a", 0.95], ["c", 0.93]])],
-      ["c", new Map([["a", 0.94], ["b", 0.93]])],
-    ]);
-    const { store } = createMockStore([entryA, entryB, entryC], simMap);
-    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, mergeThreshold: 0.92 });
-    await engine.run("project:test");
-
-    const finalA = JSON.parse((await store.getById("a"))!.metadata!) as Record<string, any>;
-    const finalB = JSON.parse((await store.getById("b"))!.metadata!) as Record<string, any>;
-    const finalC = JSON.parse((await store.getById("c"))!.metadata!) as Record<string, any>;
-    expect(typeof finalA.version_group).toBe("string");
-    expect(finalB.version_group).toBe(finalA.version_group); // 旧路径这里各是一个新组
-    expect(finalC.version_group).toBe(finalA.version_group);
-    expect(finalA.evolution.sourceMemories).toEqual(expect.arrayContaining(["b", "c"])); // 旧路径只剩最后一个
-  });
-
-  it("link 分支回归：多 member 时 canonical 的 cluster_members 累积全部（不再只剩最后一个）", async () => {
-    const entryA = makeEntry({ id: "a", text: "topic center", vector: [1, 0, 0], importance: 0.9 });
-    const entryB = makeEntry({ id: "b", text: "related one", vector: [0.9, 0.3, 0], importance: 0.5 });
-    const entryC = makeEntry({ id: "c", text: "related two", vector: [0.88, 0.35, 0], importance: 0.4 });
-    // 0.85 落在 clusterThreshold(0.82) 与 mergeThreshold(0.92) 之间 → link 分支
-    const simMap = new Map([
-      ["a", new Map([["b", 0.85], ["c", 0.85]])],
-      ["b", new Map([["a", 0.85], ["c", 0.84]])],
-      ["c", new Map([["a", 0.85], ["b", 0.84]])],
-    ]);
-    const { store } = createMockStore([entryA, entryB, entryC], simMap);
-    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, clusterThreshold: 0.82, mergeThreshold: 0.92 });
-    await engine.run("project:test");
-
-    const finalA = JSON.parse((await store.getById("a"))!.metadata!) as Record<string, any>;
-    const finalB = JSON.parse((await store.getById("b"))!.metadata!) as Record<string, any>;
-    const finalC = JSON.parse((await store.getById("c"))!.metadata!) as Record<string, any>;
-    expect(finalA.cluster_members).toEqual(expect.arrayContaining(["b", "c"]));
-    expect(finalB.clustered_with).toBe("a");
-    expect(finalC.clustered_with).toBe("a");
-  });
-
-  it("merges near-duplicates above mergeThreshold", async () => {
-    const entryA = makeEntry({ id: "a", text: "I prefer TypeScript", vector: [1, 0, 0], importance: 0.9 });
-    const entryB = makeEntry({ id: "b", text: "I prefer TypeScript language", vector: [0.99, 0.1, 0], importance: 0.5 });
-
-    const simMap = new Map([
-      ["a", new Map([["b", 0.95]])],
-      ["b", new Map([["a", 0.95]])],
-    ]);
-
-    const { store, updates } = createMockStore([entryA, entryB], simMap);
-    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, mergeThreshold: 0.92 });
-    const result = await engine.run("project:test");
-
-    expect(result.clustersFound).toBe(1);
-    expect(result.mergedCount).toBe(1);
-    // Tier 3.3: Both entries now coexist in a version group instead of archiving.
-    // Both A and B should have version_group metadata.
-    const updateA = updates.find(u => u.id === "a");
-    const updateB = updates.find(u => u.id === "b");
-    expect(updateA).toBeTruthy();
-    expect(updateB).toBeTruthy();
-    const metaA = JSON.parse(updateA!.metadata);
-    const metaB = JSON.parse(updateB!.metadata);
-    expect(metaA.version_group).toBeTruthy();
-    expect(metaB.version_group).toBe(metaA.version_group);
-    // Canonical (A, higher importance) should have higher rank
-    expect(metaA.version_rank).toBeGreaterThan(metaB.version_rank);
-  });
-
-  it("never clusters a live entry with its own superseded belief-history row", async () => {
-    // A rephrased belief sits far above mergeThreshold from its archived version, and
-    // canonicalScore (importance × access count, no recency) ties them exactly — the
-    // history row inherits both. Losing that coin flip would mark the LIVE entry
-    // consolidated, dropping the current belief out of default retrieval while the
-    // abandoned wording stands in as canonical.
-    const live = makeEntry({
-      id: "live",
-      text: "User prefers concise, code-first replies",
-      vector: [1, 0, 0],
-    });
-    // Clustering is skipped outright when a category holds fewer than two ACTIVE entries,
-    // so an unrelated second live entry is what makes this scenario reachable at all.
-    const unrelated = makeEntry({
-      id: "other",
-      text: "Project uses Bun as the runtime",
-      vector: [0, 0, 1],
-    });
-    const history = makeEntry({
-      id: "hist",
-      text: "User prefers concise, direct replies",
-      vector: [0, 1, 0],
-      metadata: JSON.stringify({
-        evolution: { status: "superseded", validUntil: Date.now(), supersededBy: "live" },
-      }),
-    });
-
-    const simMap = new Map([["live", new Map([["hist", 0.98]])]]);
-
-    const { store, updates } = createMockStore([live, unrelated, history], simMap);
-    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, mergeThreshold: 0.92 });
-    const result = await engine.run("project:test");
-
-    expect(result.clustersFound).toBe(0);
-    expect(result.mergedCount).toBe(0);
-    // Above all: the live entry must not have been touched.
-    expect(updates.find(u => u.id === "live")).toBeUndefined();
-  });
-
-  it("links related entries below mergeThreshold but above clusterThreshold", async () => {
-    const entryA = makeEntry({ id: "a", text: "TypeScript config", vector: [1, 0, 0] });
-    const entryB = makeEntry({ id: "b", text: "TypeScript setup", vector: [0.9, 0.1, 0] });
-
-    const simMap = new Map([
-      ["a", new Map([["b", 0.85]])],
-      ["b", new Map([["a", 0.85]])],
-    ]);
-
-    const { store, updates } = createMockStore([entryA, entryB], simMap);
-    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, clusterThreshold: 0.82, mergeThreshold: 0.92 });
-    const result = await engine.run("project:test");
-
-    expect(result.clustersFound).toBe(1);
-    expect(result.mergedCount).toBe(0);
-    expect(result.relationsAdded).toBe(1);
-    // Both should have clustering metadata
-    const linkUpdate = updates.find(u => u.id === "b");
-    expect(linkUpdate).toBeTruthy();
-    const meta = JSON.parse(linkUpdate!.metadata);
-    expect(meta.clustered_with).toBe("a");
-  });
-
-  it("detects heuristic contradictions", async () => {
-    const entryA = makeEntry({ id: "a", text: "Always use strict mode in TypeScript projects", vector: [1, 0, 0] });
-    const entryB = makeEntry({ id: "b", text: "Never use strict mode in TypeScript projects", vector: [0.98, 0.1, 0] });
-
-    const simMap = new Map([
-      ["a", new Map([["b", 0.95]])],
-      ["b", new Map([["a", 0.95]])],
-    ]);
-
-    const { store } = createMockStore([entryA, entryB], simMap);
-    const engine = new ConsolidationEngine(store, DEFAULT_CONSOLIDATION_CONFIG);
-    const result = await engine.run("project:test");
-
-    expect(result.conflictsDetected.length).toBe(1);
-    expect(result.conflictsDetected[0].type).toBe("heuristic_contradiction");
-  });
-
-  it("skips archived entries", async () => {
-    const entryA = makeEntry({ id: "a", text: "active entry here", vector: [1, 0, 0] });
-    const entryB = makeEntry({ id: "b", text: "archived entry here", vector: [0.95, 0.1, 0], metadata: JSON.stringify({ evolution: { status: "archived" } }) });
-
-    const { store } = createMockStore([entryA, entryB]);
-    const engine = new ConsolidationEngine(store);
-    const result = await engine.run("project:test");
-
-    expect(result.originalCount).toBe(1); // only active
-  });
-
-  describe("KG triple evidence (second merge-evidence source)", () => {
-    function createMockKGSource(byMemory: Record<string, ConsolidationTripleEvidence[]>) {
-      return {
-        async getTriplesBySourceMemories(memoryIds: string[]) {
-          const result = new Map<string, ConsolidationTripleEvidence[]>();
-          for (const id of memoryIds) {
-            if (byMemory[id]) result.set(id, byMemory[id]);
-          }
-          return result;
-        },
-      };
-    }
-    const t = (id: string, mention = 1): ConsolidationTripleEvidence => ({ id, mention_count: mention });
-
-    function greyZonePair() {
-      const entryA = makeEntry({ id: "a", text: "Alice's main machine is the MacBook", vector: [1, 0, 0], importance: 0.9 });
-      const entryB = makeEntry({ id: "b", text: "Alice uses a MacBook as her primary computer", vector: [0.9, 0.1, 0], importance: 0.5 });
-      const simMap = new Map([
-        ["a", new Map([["b", 0.85]])], // grey zone: above cluster 0.82, below merge 0.92
-        ["b", new Map([["a", 0.85]])],
-      ]);
-      return { entryA, entryB, simMap };
-    }
-
-    it("merges a grey-zone pair when triple sets overlap", async () => {
-      const { entryA, entryB, simMap } = greyZonePair();
-      const kg = createMockKGSource({
-        a: [t("t1"), t("t2")],
-        b: [t("t1"), t("t2")], // Jaccard 1.0
-      });
-      const { store, updates } = createMockStore([entryA, entryB], simMap);
-      const engine = new ConsolidationEngine(store, DEFAULT_CONSOLIDATION_CONFIG, kg);
-      const result = await engine.run("project:test");
-
-      expect(result.mergedCount).toBe(1);
-      expect(result.tripleEvidenceMerges).toBe(1);
-      expect(result.relationsAdded).toBe(0);
-      const metaB = JSON.parse(updates.find(u => u.id === "b")!.metadata);
-      expect(metaB.version_group).toBeTruthy();
-    });
-
-    it("does not merge a grey-zone pair when triple sets are disjoint", async () => {
-      const { entryA, entryB, simMap } = greyZonePair();
-      const kg = createMockKGSource({
-        a: [t("t1"), t("t2")],
-        b: [t("t3"), t("t4")], // Jaccard 0
-      });
-      const { store } = createMockStore([entryA, entryB], simMap);
-      const engine = new ConsolidationEngine(store, DEFAULT_CONSOLIDATION_CONFIG, kg);
-      const result = await engine.run("project:test");
-
-      expect(result.mergedCount).toBe(0);
-      expect(result.tripleEvidenceMerges).toBe(0);
-      expect(result.relationsAdded).toBe(1); // falls back to link, current behavior
-    });
-
-    it("requires minTriplesForEvidence on both sides — a single shared triple is too weak", async () => {
-      const { entryA, entryB, simMap } = greyZonePair();
-      const kg = createMockKGSource({
-        a: [t("t1")],
-        b: [t("t1")], // overlap 1.0 but only one triple each — below default minTriplesForEvidence 2
-      });
-      const { store } = createMockStore([entryA, entryB], simMap);
-      const engine = new ConsolidationEngine(store, DEFAULT_CONSOLIDATION_CONFIG, kg);
-      const result = await engine.run("project:test");
-
-      expect(result.mergedCount).toBe(0);
-      expect(result.relationsAdded).toBe(1);
-    });
-
-    it("without a kgSource the grey zone links exactly as before", async () => {
-      const { entryA, entryB, simMap } = greyZonePair();
-      const { store } = createMockStore([entryA, entryB], simMap);
-      const engine = new ConsolidationEngine(store, DEFAULT_CONSOLIDATION_CONFIG);
-      const result = await engine.run("project:test");
-
-      expect(result.mergedCount).toBe(0);
-      expect(result.tripleEvidenceMerges).toBe(0);
-      expect(result.relationsAdded).toBe(1);
-    });
-
-    it("mention frequency boosts canonical selection", async () => {
-      // Same importance — the mention boost must be what flips the canonical
-      const entryA = makeEntry({ id: "a", text: "fact mentioned once", vector: [1, 0, 0], importance: 0.7 });
-      const entryB = makeEntry({ id: "b", text: "fact mentioned many times", vector: [0.99, 0.1, 0], importance: 0.7 });
-      const simMap = new Map([
-        ["a", new Map([["b", 0.95]])], // merge zone
-        ["b", new Map([["a", 0.95]])],
-      ]);
-      const kg = createMockKGSource({
-        a: [t("ta", 1), t("tx", 1)],
-        b: [t("tb", 9), t("ty", 1)], // b carries a fact mentioned 9 times → higher canonical score
-      });
-      const { store, updates } = createMockStore([entryA, entryB], simMap);
-      const engine = new ConsolidationEngine(store, DEFAULT_CONSOLIDATION_CONFIG, kg);
-      const result = await engine.run("project:test");
-
-      expect(result.mergedCount).toBe(1);
-      // B is canonical (the boost flipped the tie): A is the member, marked
-      // consolidatedInto B. version_rank can't witness this — computeVersionRank
-      // ignores the engine's canonical pick when importance ties.
-      const finalMetaA = JSON.parse(updates.filter(u => u.id === "a").at(-1)!.metadata);
-      expect(finalMetaA.evolution?.consolidatedInto).toBe("b");
-      // And B was never marked consolidated into anything
-      const bUpdates = updates.filter(u => u.id === "b").map(u => JSON.parse(u.metadata));
-      expect(bUpdates.every(m => !m.evolution?.consolidatedInto)).toBe(true);
-    });
-
-    it("mention boost must NOT override a clear importance gap (tie-breaker only)", async () => {
-      // A is substantially more important; B carries an extremely frequent triple.
-      // The capped boost (≤1.1) must not demote A to consolidated status.
-      const entryA = makeEntry({ id: "a", text: "the important synthesis", vector: [1, 0, 0], importance: 0.9 });
-      const entryB = makeEntry({ id: "b", text: "minor note repeating a hot fact", vector: [0.99, 0.1, 0], importance: 0.5 });
-      const simMap = new Map([
-        ["a", new Map([["b", 0.95]])],
-        ["b", new Map([["a", 0.95]])],
-      ]);
-      const kg = createMockKGSource({
-        a: [],
-        b: [t("hot", 500), t("tb", 1)], // absurdly frequent fact on the weak side
-      });
-      const { store, updates } = createMockStore([entryA, entryB], simMap);
-      const engine = new ConsolidationEngine(store, DEFAULT_CONSOLIDATION_CONFIG, kg);
-      const result = await engine.run("project:test");
-
-      expect(result.mergedCount).toBe(1);
-      // A stays canonical: B is the one marked consolidatedInto A
-      const finalMetaB = JSON.parse(updates.filter(u => u.id === "b").at(-1)!.metadata);
-      expect(finalMetaB.evolution?.consolidatedInto).toBe("a");
-      const aUpdates = updates.filter(u => u.id === "a").map(u => JSON.parse(u.metadata));
-      expect(aUpdates.every(m => !m.evolution?.consolidatedInto)).toBe(true);
-    });
-  });
-});
-
-describe("tripleJaccard", () => {
-  const set = (...ids: string[]) => new Set(ids);
-
-  it("computes intersection over union", () => {
-    expect(tripleJaccard(set("a", "b"), set("a", "b"))).toBe(1);
-    expect(tripleJaccard(set("a", "b"), set("b", "c"))).toBeCloseTo(1 / 3);
-    expect(tripleJaccard(set("a", "b"), set("c", "d"))).toBe(0);
-  });
-
-  it("returns 0 below the min-size floor (either side)", () => {
-    expect(tripleJaccard(set("a"), set("a"))).toBe(0); // default minSize 2
-    expect(tripleJaccard(set("a"), set("a"), 1)).toBe(1);
-    expect(tripleJaccard(undefined, set("a", "b"))).toBe(0);
-    expect(tripleJaccard(set("a", "b"), undefined)).toBe(0);
-  });
-});
-
-describe("formatConsolidationResult", () => {
-  it("formats a result with conflicts", () => {
-    const result: ConsolidationResult = {
-      originalCount: 100,
-      clustersFound: 5,
-      mergedCount: 3,
-      relationsAdded: 7,
-      tripleEvidenceMerges: 1,
-      conflictsDetected: [{ memoryA: "aaaa-bbbb", memoryB: "cccc-dddd", type: "heuristic_contradiction" }],
-      scope: "project:test",
-    };
-    const text = formatConsolidationResult(result);
-    expect(text).toContain("Scanned: 100");
-    expect(text).toContain("Clusters found: 5");
-    expect(text).toContain("Merged (versioned): 3");
-    expect(text).toContain("Conflicts:");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// computeSynthesisUptake (Artel synthesis_uptake_rate 对应物)
-// ---------------------------------------------------------------------------
-
-import { computeSynthesisUptake } from "../consolidation-engine.js";
-import type { MemoryEntry as UptakeEntry } from "../store.js";
-
-function uptakeEntry(id: string, metadata: Record<string, unknown>): UptakeEntry {
-  return {
-    id,
-    text: `t-${id}`,
-    vector: [],
-    category: "patterns",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: JSON.stringify(metadata),
-  } as UptakeEntry;
-}
-
-function pagedStore(all: UptakeEntry[]) {
-  return {
-    async listPage({ limit = 1000, offset = 0 }: { limit?: number; offset?: number; includeVector?: boolean }) {
-      return all.slice(offset, offset + limit);
-    },
-  };
-}
-
-describe("computeSynthesisUptake", () => {
-  it("computes uptake over derived insights only", async () => {
-    const store = pagedStore([
-      uptakeEntry("d1", { cluster_insight: true, accessCount: 2 }),   // derived, read
-      uptakeEntry("d2", { cross_memory_pattern: true }),              // derived, unread
-      uptakeEntry("n1", { accessCount: 5 }),                          // not derived
-    ]);
-    const s = await computeSynthesisUptake(store, 20_000, 2);
-    expect(s.scanned).toBe(3);
-    expect(s.derivedTotal).toBe(2);
-    expect(s.derivedRead).toBe(1);
-    expect(s.uptakeRate).toBeCloseTo(0.5, 5);
-    expect(s.truncated).toBe(false);
-  });
-
-  it("returns null rate when no derived insights exist", async () => {
-    const s = await computeSynthesisUptake(pagedStore([uptakeEntry("n1", {})]));
-    expect(s.derivedTotal).toBe(0);
-    expect(s.uptakeRate).toBeNull();
-  });
-
-  it("respects scan cap and reports truncation", async () => {
-    const all = Array.from({ length: 10 }, (_, i) => uptakeEntry(`e${i}`, { cluster_insight: true, accessCount: 1 }));
-    const s = await computeSynthesisUptake(pagedStore(all), 4, 2);
-    expect(s.scanned).toBe(4);
-    expect(s.truncated).toBe(true);
-    expect(s.derivedTotal).toBe(4);
-  });
-});