recallnest 2.6.0 → 3.0.0

package/src/__tests__/activity-counter.test.ts

@@ -20,7 +20,7 @@ const testConfig: Partial<ActivityCounterConfig> = {
 const A = "cc:project:a";
 const B = "cc:project:b";
 
-describe("activity-counter (HP-3, per-scope)", () => {
+describe("activity-counter (HP-3, per-scope)", async () => {
   beforeEach(() => {
     mkdirSync(TMP_DIR, { recursive: true });
     const p = testConfig.statsPath!;
@@ -31,95 +31,95 @@ describe("activity-counter (HP-3, per-scope)", () => {
     rmSync(TMP_DIR, { recursive: true, force: true });
   });
 
-  describe("incrementWriteCount", () => {
-    it("starts at 0 and increments by 1 for a scope", () => {
+  describe("incrementWriteCount", async () => {
+    it("starts at 0 and increments by 1 for a scope", async () => {
       expect(getWriteCount(A, testConfig)).toBe(0);
-      expect(incrementWriteCount(A, 1, testConfig)).toBe(1);
-      expect(incrementWriteCount(A, 1, testConfig)).toBe(2);
+      expect(await incrementWriteCount(A, 1, testConfig)).toBe(1);
+      expect(await incrementWriteCount(A, 1, testConfig)).toBe(2);
       expect(getWriteCount(A, testConfig)).toBe(2);
     });
 
-    it("increments by arbitrary n", () => {
-      incrementWriteCount(A, 5, testConfig);
+    it("increments by arbitrary n", async () => {
+      await incrementWriteCount(A, 5, testConfig);
       expect(getWriteCount(A, testConfig)).toBe(5);
-      incrementWriteCount(A, 3, testConfig);
+      await incrementWriteCount(A, 3, testConfig);
       expect(getWriteCount(A, testConfig)).toBe(8);
     });
 
-    it("counts each scope independently", () => {
-      incrementWriteCount(A, 4, testConfig);
-      incrementWriteCount(B, 1, testConfig);
+    it("counts each scope independently", async () => {
+      await incrementWriteCount(A, 4, testConfig);
+      await incrementWriteCount(B, 1, testConfig);
       expect(getWriteCount(A, testConfig)).toBe(4);
       expect(getWriteCount(B, testConfig)).toBe(1);
     });
   });
 
-  describe("resetWriteCount", () => {
-    it("resets only the given scope, leaving others intact", () => {
-      incrementWriteCount(A, 7, testConfig);
-      incrementWriteCount(B, 5, testConfig);
-      resetWriteCount(A, testConfig);
+  describe("resetWriteCount", async () => {
+    it("resets only the given scope, leaving others intact", async () => {
+      await incrementWriteCount(A, 7, testConfig);
+      await incrementWriteCount(B, 5, testConfig);
+      await resetWriteCount(A, testConfig);
       expect(getWriteCount(A, testConfig)).toBe(0);
       expect(getWriteCount(B, testConfig)).toBe(5); // not starved by A's reset
     });
   });
 
-  describe("listScopesAboveThreshold", () => {
-    it("returns scopes at or above the threshold only", () => {
-      incrementWriteCount(A, 12, testConfig);
-      incrementWriteCount(B, 4, testConfig);
-      incrementWriteCount("cc:project:c", 10, testConfig);
+  describe("listScopesAboveThreshold", async () => {
+    it("returns scopes at or above the threshold only", async () => {
+      await incrementWriteCount(A, 12, testConfig);
+      await incrementWriteCount(B, 4, testConfig);
+      await incrementWriteCount("cc:project:c", 10, testConfig);
       const above = listScopesAboveThreshold(10, testConfig).sort();
       expect(above).toEqual(["cc:project:a", "cc:project:c"]);
     });
 
-    it("returns empty when no scope qualifies", () => {
-      incrementWriteCount(A, 2, testConfig);
+    it("returns empty when no scope qualifies", async () => {
+      await incrementWriteCount(A, 2, testConfig);
       expect(listScopesAboveThreshold(10, testConfig)).toEqual([]);
     });
   });
 
-  describe("getDistillTier", () => {
-    it("returns 'none' when below light threshold", () => {
-      incrementWriteCount(A, 2, testConfig);
+  describe("getDistillTier", async () => {
+    it("returns 'none' when below light threshold", async () => {
+      await incrementWriteCount(A, 2, testConfig);
       expect(getDistillTier(A, testConfig)).toBe("none");
     });
 
-    it("returns 'light' at light threshold", () => {
-      incrementWriteCount(A, 3, testConfig);
+    it("returns 'light' at light threshold", async () => {
+      await incrementWriteCount(A, 3, testConfig);
       expect(getDistillTier(A, testConfig)).toBe("light");
     });
 
-    it("returns 'standard' at standard threshold", () => {
-      incrementWriteCount(A, 10, testConfig);
+    it("returns 'standard' at standard threshold", async () => {
+      await incrementWriteCount(A, 10, testConfig);
       expect(getDistillTier(A, testConfig)).toBe("standard");
     });
 
-    it("returns 'deep' at and above deep threshold", () => {
-      incrementWriteCount(A, 20, testConfig);
+    it("returns 'deep' at and above deep threshold", async () => {
+      await incrementWriteCount(A, 20, testConfig);
       expect(getDistillTier(A, testConfig)).toBe("deep");
-      incrementWriteCount(A, 100, testConfig);
+      await incrementWriteCount(A, 100, testConfig);
       expect(getDistillTier(A, testConfig)).toBe("deep");
     });
   });
 
-  describe("resilience", () => {
-    it("handles missing stats file gracefully", () => {
+  describe("resilience", async () => {
+    it("handles missing stats file gracefully", async () => {
       expect(getWriteCount(A, testConfig)).toBe(0);
       expect(getDistillTier(A, testConfig)).toBe("none");
       expect(listScopesAboveThreshold(1, testConfig)).toEqual([]);
     });
 
-    it("handles corrupt stats file gracefully", () => {
+    it("handles corrupt stats file gracefully", async () => {
       writeFileSync(testConfig.statsPath!, "not-json{{{");
       expect(getWriteCount(A, testConfig)).toBe(0);
     });
 
-    it("treats the legacy global format as empty (no migration)", () => {
+    it("treats the legacy global format as empty (no migration)", async () => {
       writeFileSync(testConfig.statsPath!, JSON.stringify({ writesSinceLastDistill: 42, lastResetAt: 1 }));
       expect(getWriteCount(A, testConfig)).toBe(0);
       // first increment starts a fresh per-scope map
-      expect(incrementWriteCount(A, 1, testConfig)).toBe(1);
+      expect(await incrementWriteCount(A, 1, testConfig)).toBe(1);
     });
   });
 });

package/src/__tests__/age-label.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "bun:test";
+
+import { AGE_UNKNOWN, formatAgeLabel, formatIsoAgeLabel } from "../age-label.js";
+
+const DAY = 86_400_000;
+const NOW = Date.parse("2026-08-17T12:00:00.000Z");
+
+describe("age label", () => {
+  it("renders whole days, floored", () => {
+    expect(formatAgeLabel(NOW, NOW)).toBe("0d");
+    expect(formatAgeLabel(NOW - 23 * 3_600_000, NOW)).toBe("0d");
+    expect(formatAgeLabel(NOW - 1 * DAY, NOW)).toBe("1d");
+    expect(formatAgeLabel(NOW - 14 * DAY - 5 * 3_600_000, NOW)).toBe("14d");
+    expect(formatAgeLabel(NOW - 400 * DAY, NOW)).toBe("400d");
+  });
+
+  it("reads a future stamp as today, not a negative age", () => {
+    expect(formatAgeLabel(NOW + 3 * DAY, NOW)).toBe("0d");
+  });
+
+  it("does not fabricate an age for unusable stamps", () => {
+    expect(formatAgeLabel(0, NOW)).toBe(AGE_UNKNOWN);
+    expect(formatAgeLabel(undefined, NOW)).toBe(AGE_UNKNOWN);
+    expect(formatAgeLabel(Number.NaN, NOW)).toBe(AGE_UNKNOWN);
+    expect(formatIsoAgeLabel("not-a-date", NOW)).toBe(AGE_UNKNOWN);
+    expect(formatIsoAgeLabel("", NOW)).toBe(AGE_UNKNOWN);
+  });
+
+  it("accepts ISO strings the same way", () => {
+    expect(formatIsoAgeLabel("2026-08-03T09:30:00.000Z", NOW)).toBe("14d");
+    expect(formatIsoAgeLabel("2026-08-17T00:00:00.000Z", NOW)).toBe("0d");
+  });
+});

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

@@ -3,10 +3,13 @@ import { describe, expect, it } from "bun:test";
 import {
   clusterAndConsolidate,
   deduplicateByClusterInsight,
+  SYNTHESIS_CONTRACT_VERSION,
   type ClusterConsolidationResult,
 } from "../consolidation-engine.js";
+import { extractBoundaryMetadata } from "../memory-boundaries.js";
 import type { MemoryEntry, MemoryStore } from "../store.js";
 import type { LLMClient } from "../llm-client.js";
+import type { SynthesisVerdict } from "../synthesis-contract.js";
 import type { Embedder } from "../embedder.js";
 import { cosineSimilarity } from "../multi-vector.js";
 
@@ -38,13 +41,21 @@ function makeEntry(overrides: Partial<MemoryEntry> & { id: string; text: string
   };
 }
 
-/** Create a mock store that tracks store() and update() calls */
-function createMockStore() {
+/** Create a mock store that tracks store() and update() calls.
+ *  可选 seed：模拟"库中已有行"的 metadata（patchMetadataBatch 的生产语义是以库中
+ *  最新行起底应用 patchFn——不给 seed 时起底为空对象）。 */
+function createMockStore(seed: MemoryEntry[] = []) {
   const stored: MemoryEntry[] = [];
   const updates: Array<{ id: string; metadata: string }> = [];
+  // 2026-08-14: patchMetadataBatch 的最新态表 —— patchFn 以上一批的结果起底，
+  // 忠实模拟生产语义（锁内最新行起底、批间叠加而非互抹）。
+  const metaById = new Map<string, Record<string, unknown>>();
+  for (const e of seed) {
+    try { metaById.set(e.id, JSON.parse(e.metadata || "{}") as Record<string, unknown>); } catch { /* skip bad seed */ }
+  }
   let storeCounter = 0;
 
-  const store: Pick<MemoryStore, "store" | "update"> = {
+  const store: Pick<MemoryStore, "store" | "update" | "patchMetadataBatch"> = {
     async store(entry) {
       const full: MemoryEntry = {
         ...entry,
@@ -61,24 +72,47 @@ function createMockStore() {
       }
       return { id, text: "", vector: [], category: "events", scope: "project:test", importance: 0.5, timestamp: Date.now(), metadata: upd.metadata || "{}" } as MemoryEntry;
     },
+    async patchMetadataBatch(patches, _scopeFilter?) {
+      for (const { id, patchFn } of patches) {
+        const current = metaById.get(id) ?? {};
+        const entry = { id, text: "", vector: [], category: "events", scope: "project:test", importance: 0.5, timestamp: Date.now(), metadata: JSON.stringify(current) } as MemoryEntry;
+        const patched = patchFn(current, entry);
+        metaById.set(id, patched);
+        updates.push({ id, metadata: JSON.stringify(patched) });
+      }
+      return patches.length;
+    },
   };
 
-  return { store, stored, updates };
+  return { store, stored, updates, metaById };
+}
+
+/**
+ * Create a mock LLM that returns a fixed insight string (or null to simulate abstention).
+ *
+ * 2026-08-23：合成接口从「返回 string|null」换成 `SynthesisVerdict`（产出 / 弃权 /
+ * 校验不过三态）。这个 helper 保留旧的字符串签名，把 null 映射成 `abstained` ——
+ * 既有 30 多条断言测的是聚类与写库行为，不该因为合成签名换代而全部重写。
+ * 三态本身另有直接断言（见文件末尾「合成契约」一节）。
+ */
+function synthOk(text: string, evidence: number[] = [1, 2]): SynthesisVerdict {
+  return { status: "ok", output: { text, evidence } };
 }
 
-/** Create a mock LLM that returns a fixed insight string (or null to simulate failure) */
 function createMockLLM(
   insightFn: (text: string) => string | null,
   patternFn?: (texts: string[]) => string | null,
-): Pick<LLMClient, "generateL0" | "extractPattern"> {
+): Pick<LLMClient, "synthesizeClusterInsight" | "synthesizeClusterPattern"> {
   return {
-    async generateL0(text: string) {
-      return insightFn(text);
+    async synthesizeClusterInsight(texts: string[]) {
+      const out = insightFn(texts.join("\n---\n"));
+      return out === null ? { status: "abstained" } : synthOk(out);
     },
-    async extractPattern(texts: string[]) {
-      return patternFn ? patternFn(texts) : null;
+    async synthesizeClusterPattern(texts: string[]) {
+      const out = patternFn ? patternFn(texts) : null;
+      return out === null ? { status: "abstained" } : synthOk(out);
     },
-  } as Pick<LLMClient, "generateL0" | "extractPattern">;
+  } as Pick<LLMClient, "synthesizeClusterInsight" | "synthesizeClusterPattern">;
 }
 
 /** Create a mock embedder that returns a fixed vector */
@@ -147,7 +181,7 @@ describe("clusterAndConsolidate", () => {
       makeEntry({ id: "c", text: "TypeScript improves developer experience", vector: [0.92, 0.08, 0], importance: 0.6 }),
     ];
 
-    const { store, stored, updates } = createMockStore();
+    const { store, stored, updates } = createMockStore(entries);
     const llm = createMockLLM(() => "TypeScript benefits for development");
     const embedder = createMockEmbedder([0.5, 0.5, 0]);
 
@@ -187,6 +221,37 @@ describe("clusterAndConsolidate", () => {
     }
   });
 
+  // 2026-08-14 Bug-2 回归：旧路径 insight 源回写与 pattern 源回写都从同一个旧内存串
+  // 起底 patch，后者会把前者刚写库的 consolidatedInto 抹掉——凡走到 pattern 抽取的
+  // cluster，源条目的 consolidatedInto 全丢。新路径两段批量都以最新态起底，叠加共存。
+  it("Bug-2 回归：pattern 源回写后 consolidatedInto 与 contributedToPattern 并存（最终态）", async () => {
+    const entries = [
+      makeEntry({ id: "a", text: "TypeScript is great", vector: [0.9, 0.1, 0], importance: 0.8 }),
+      makeEntry({ id: "b", text: "TypeScript is safe", vector: [0.88, 0.12, 0], importance: 0.7 }),
+      makeEntry({ id: "c", text: "TypeScript is productive", vector: [0.92, 0.08, 0], importance: 0.6 }),
+    ];
+    const { store, stored, metaById } = createMockStore(entries);
+    const llm = createMockLLM(() => "TS insight", () => "TS pattern");
+    const embedder = createMockEmbedder([0.5, 0.5, 0]);
+
+    const result = await clusterAndConsolidate({
+      entries, embedder, llm: llm as unknown as LLMClient, store,
+      scope: "project:test", minClusterSize: 3, clusterThreshold: 0.75,
+      extractPatterns: true,
+    });
+
+    expect(result.insightsGenerated).toBe(1);
+    expect(result.patternsExtracted).toBe(1);
+    const insight = stored.find(e => JSON.parse(e.metadata!).cluster_insight === true)!;
+    const pattern = stored.find(e => JSON.parse(e.metadata!).cross_memory_pattern === true)!;
+    for (const id of ["a", "b", "c"]) {
+      const final = metaById.get(id) as { evolution: Record<string, unknown> };
+      expect(final.evolution.consolidatedInto).toBe(insight.id); // 旧路径这里被 pattern 批抹成 undefined
+      expect(final.evolution.contributedToPattern).toBe(pattern.id);
+      expect(final.evolution.status).toBe("active"); // 3b 不动 status
+    }
+  });
+
   // P0-2/P1-2: insight/pattern idempotency — deterministic id from source cluster ids.
   it("re-running on the same cluster yields a stable, deterministic insight id", async () => {
     const entries = [
@@ -238,6 +303,9 @@ describe("clusterAndConsolidate", () => {
       async update(id, upd) {
         return { id, text: "", vector: [], category: "events", scope: "project:test", importance: 0.5, timestamp: Date.now(), metadata: upd.metadata || "{}" } as MemoryEntry;
       },
+      async patchMetadataBatch(patches: Array<{ id: string; patchFn: (meta: Record<string, unknown>, entry: MemoryEntry) => Record<string, unknown> }>) {
+        return patches.length; // 本用例只断言 insight 幂等，源回写记录不参与断言
+      },
     };
 
     const params = {
@@ -326,11 +394,11 @@ describe("clusterAndConsolidate", () => {
 
     const { store, stored } = createMockStore();
     const llm = {
-      async generateL0(_text: string): Promise<string | null> {
+      async synthesizeClusterInsight(_texts: string[]): Promise<SynthesisVerdict> {
         throw new Error("Request was aborted.");
       },
-      async extractPattern(_texts: string[]): Promise<string | null> {
-        return null;
+      async synthesizeClusterPattern(_texts: string[]): Promise<SynthesisVerdict> {
+        return { status: "abstained" };
       },
     };
     const embedder = createMockEmbedder();
@@ -368,13 +436,13 @@ describe("clusterAndConsolidate", () => {
     const { store, stored } = createMockStore();
     let call = 0;
     const llm = {
-      async generateL0(_text: string): Promise<string | null> {
+      async synthesizeClusterInsight(_texts: string[]): Promise<SynthesisVerdict> {
         call++;
         if (call === 1) throw new Error("Request was aborted.");
-        return "第二个簇的 insight";
+        return synthOk("第二个簇的 insight");
       },
-      async extractPattern(_texts: string[]): Promise<string | null> {
-        return null;
+      async synthesizeClusterPattern(_texts: string[]): Promise<SynthesisVerdict> {
+        return { status: "abstained" };
       },
     };
     const embedder = createMockEmbedder();
@@ -406,10 +474,10 @@ describe("clusterAndConsolidate", () => {
 
     const { store, stored } = createMockStore();
     const llm = {
-      async generateL0(_text: string): Promise<string | null> {
-        return "insight 正常产出";
+      async synthesizeClusterInsight(_texts: string[]): Promise<SynthesisVerdict> {
+        return synthOk("insight 正常产出");
       },
-      async extractPattern(_texts: string[]): Promise<string | null> {
+      async synthesizeClusterPattern(_texts: string[]): Promise<SynthesisVerdict> {
         throw new Error("Request was aborted.");
       },
     };
@@ -943,3 +1011,226 @@ describe("deduplicateByClusterInsight (LC-P2)", () => {
     expect(deduped.length).toBe(2); // Both pass through
   });
 });
+
+// ---------------------------------------------------------------------------
+// 2026-08-23 合成契约上线带来的三件行为改动
+// ---------------------------------------------------------------------------
+
+/** 造一个三成员簇（向量足够接近，一定聚成一簇）。 */
+function trioEntries(): MemoryEntry[] {
+  return [
+    makeEntry({ id: "a", text: "记录 A", vector: [0.9, 0.1, 0], importance: 0.8 }),
+    makeEntry({ id: "b", text: "记录 B", vector: [0.88, 0.12, 0], importance: 0.7 }),
+    makeEntry({ id: "c", text: "记录 C", vector: [0.92, 0.08, 0], importance: 0.6 }),
+  ];
+}
+
+const trioParams = { minClusterSize: 3, clusterThreshold: 0.75 };
+
+describe("合成弃权路径（老 generateL0 完全没有这条路）", () => {
+  it("模型判定「没料可炼」时不写库，且记进 synthesisAbstained", async () => {
+    const { store, stored } = createMockStore();
+    const llm = {
+      async synthesizeClusterInsight(): Promise<SynthesisVerdict> { return { status: "abstained" }; },
+      async synthesizeClusterPattern(): Promise<SynthesisVerdict> { return { status: "abstained" }; },
+    };
+
+    const result = await clusterAndConsolidate({
+      entries: trioEntries(),
+      embedder: createMockEmbedder(),
+      llm: llm as unknown as LLMClient,
+      store,
+      scope: "project:test",
+      extractPatterns: true,
+      ...trioParams,
+    });
+
+    expect(stored.length).toBe(0);
+    expect(result.insightsGenerated).toBe(0);
+    expect(result.patternsExtracted).toBe(0);
+    expect(result.synthesisAbstained).toBe(2); // insight + pattern 各一次
+    expect(result.synthesisRejected).toBe(0);
+    expect(result.llmFailures).toBe(0); // 弃权不是失败
+    expect(result.clustersConsolidated).toBe(1); // 簇确实处理过
+  });
+
+  it("校验不过的输出不写库，且与弃权分开计数", async () => {
+    const { store, stored } = createMockStore();
+    const llm = {
+      async synthesizeClusterInsight(): Promise<SynthesisVerdict> {
+        return { status: "rejected", reason: "prompt-echo" };
+      },
+      async synthesizeClusterPattern(): Promise<SynthesisVerdict> {
+        return { status: "rejected", reason: "evidence-too-few" };
+      },
+    };
+
+    const result = await clusterAndConsolidate({
+      entries: trioEntries(),
+      embedder: createMockEmbedder(),
+      llm: llm as unknown as LLMClient,
+      store,
+      scope: "project:test",
+      extractPatterns: true,
+      ...trioParams,
+    });
+
+    expect(stored.length).toBe(0);
+    expect(result.synthesisRejected).toBe(2);
+    expect(result.synthesisAbstained).toBe(0);
+    expect(result.llmFailures).toBe(0); // 拿到回复了，只是不合契约——不是调用失败
+  });
+});
+
+describe("pattern 与 insight 解耦（R5）", () => {
+  it("insight 弃权时 pattern 照常抽取——改前这簇的 pattern 根本不会被执行", async () => {
+    const { store, stored } = createMockStore();
+    const llm = {
+      async synthesizeClusterInsight(): Promise<SynthesisVerdict> { return { status: "abstained" }; },
+      async synthesizeClusterPattern(): Promise<SynthesisVerdict> {
+        return { status: "ok", output: { text: "跨条目结论", evidence: [1, 2] } };
+      },
+    };
+
+    const result = await clusterAndConsolidate({
+      entries: trioEntries(),
+      embedder: createMockEmbedder(),
+      llm: llm as unknown as LLMClient,
+      store,
+      scope: "project:test",
+      extractPatterns: true,
+      ...trioParams,
+    });
+
+    expect(result.insightsGenerated).toBe(0);
+    expect(result.patternsExtracted).toBe(1);
+    expect(stored.length).toBe(1);
+    expect(stored[0].text).toBe("跨条目结论");
+  });
+
+  it("insight 抛异常时 pattern 仍然跑（两者独立失败）", async () => {
+    const { store } = createMockStore();
+    const llm = {
+      async synthesizeClusterInsight(): Promise<SynthesisVerdict> { throw new Error("Request was aborted."); },
+      async synthesizeClusterPattern(): Promise<SynthesisVerdict> {
+        return { status: "ok", output: { text: "跨条目结论", evidence: [1, 2] } };
+      },
+    };
+
+    const result = await clusterAndConsolidate({
+      entries: trioEntries(),
+      embedder: createMockEmbedder(),
+      llm: llm as unknown as LLMClient,
+      store,
+      scope: "project:test",
+      extractPatterns: true,
+      ...trioParams,
+    });
+
+    expect(result.llmFailures).toBe(1);
+    expect(result.insightsGenerated).toBe(0);
+    expect(result.patternsExtracted).toBe(1);
+  });
+
+  it("只有 pattern 产出的一轮不算零产出轮次（否则早停会提前触发）", async () => {
+    // 6 个成员分成两簇，insight 全弃权、pattern 全产出。
+    // 若沿用旧判据（没有 insight = 零产出），连续两簇就会触发 diminishing_returns 早停。
+    const entries = [
+      makeEntry({ id: "a1", text: "簇一 A", vector: [0.9, 0.1, 0] }),
+      makeEntry({ id: "a2", text: "簇一 B", vector: [0.88, 0.12, 0] }),
+      makeEntry({ id: "a3", text: "簇一 C", vector: [0.92, 0.08, 0] }),
+      makeEntry({ id: "b1", text: "簇二 A", vector: [0, 0.9, 0.1] }),
+      makeEntry({ id: "b2", text: "簇二 B", vector: [0, 0.88, 0.12] }),
+      makeEntry({ id: "b3", text: "簇二 C", vector: [0, 0.92, 0.08] }),
+    ];
+    const { store } = createMockStore();
+    const llm = {
+      async synthesizeClusterInsight(): Promise<SynthesisVerdict> { return { status: "abstained" }; },
+      async synthesizeClusterPattern(): Promise<SynthesisVerdict> {
+        return { status: "ok", output: { text: "跨条目结论", evidence: [1, 2] } };
+      },
+    };
+
+    const result = await clusterAndConsolidate({
+      entries,
+      embedder: createMockEmbedder(),
+      llm: llm as unknown as LLMClient,
+      store,
+      scope: "project:test",
+      extractPatterns: true,
+      ...trioParams,
+    });
+
+    expect(result.clustersFound).toBe(2);
+    expect(result.patternsExtracted).toBe(2);
+    expect(result.earlyStop).toBeUndefined();
+  });
+});
+
+describe("派生物的 boundary 层级（补的是「靠 scope 命名侥幸判对」那一刀）", () => {
+  it("insight 与 pattern 都显式落 evidence 层，不靠 scope 名字推断", async () => {
+    const { store, stored } = createMockStore();
+    const llm = createMockLLM(() => "一条结论", () => "一条跨条目结论");
+
+    await clusterAndConsolidate({
+      entries: trioEntries(),
+      embedder: createMockEmbedder(),
+      llm: llm as unknown as LLMClient,
+      store,
+      // 刻意用非 transcript scope：改前这里会静默拿到 durable 权威
+      scope: "project:test",
+      extractPatterns: true,
+      ...trioParams,
+    });
+
+    expect(stored.length).toBe(2);
+    for (const row of stored) {
+      const meta = JSON.parse(row.metadata!) as { boundary?: { layer?: string; authority?: string } };
+      expect(meta.boundary?.layer).toBe("evidence");
+      expect(meta.boundary?.authority).toBe("distillation");
+    }
+  });
+
+  it("检索侧读得到这个 boundary（与 extractBoundaryMetadata 对得上，不是写了个没人认的字段）", async () => {
+    const { store, stored } = createMockStore();
+    const llm = createMockLLM(() => "一条结论");
+
+    await clusterAndConsolidate({
+      entries: trioEntries(),
+      embedder: createMockEmbedder(),
+      llm: llm as unknown as LLMClient,
+      store,
+      scope: "project:test",
+      ...trioParams,
+    });
+
+    // coerceBoundaryMetadata 对 layer/authority/conflictPolicy 三项都做白名单校验，
+    // 任一项写错就整个返回 null —— 所以这条断言同时验了三项都合法。
+    const boundary = extractBoundaryMetadata(stored[0].metadata);
+    expect(boundary).not.toBeNull();
+    expect(boundary!.layer).toBe("evidence");
+  });
+
+  it("evidence 编号被翻译成真实的源记忆 id 存下来", async () => {
+    const { store, stored } = createMockStore();
+    const llm = {
+      async synthesizeClusterInsight(): Promise<SynthesisVerdict> {
+        return { status: "ok", output: { text: "一条结论", evidence: [1, 3] } };
+      },
+      async synthesizeClusterPattern(): Promise<SynthesisVerdict> { return { status: "abstained" }; },
+    };
+
+    await clusterAndConsolidate({
+      entries: trioEntries(),
+      embedder: createMockEmbedder(),
+      llm: llm as unknown as LLMClient,
+      store,
+      scope: "project:test",
+      ...trioParams,
+    });
+
+    const meta = JSON.parse(stored[0].metadata!) as { evidenceMemories?: string[]; synthesis_contract?: number };
+    expect(meta.evidenceMemories).toEqual(["a", "c"]); // 1-based → 第 1、第 3 个成员
+    expect(meta.synthesis_contract).toBe(SYNTHESIS_CONTRACT_VERSION);
+  });
+});