recallnest 2.5.4 → 2.6.0

package/src/__tests__/belief-history.test.ts

@@ -0,0 +1,220 @@
+import { describe, expect, it } from "bun:test";
+
+import { archiveBeliefVersion } from "../belief-history.js";
+import { persistMemory } from "../capture-engine.js";
+import { isActiveMemory, parseEvolution, traceEvolution } from "../memory-evolution.js";
+
+const TEST_SCOPE = "project:test";
+const CANONICAL_KEY = "user.reply.style";
+
+/**
+ * Store double that mirrors the real MemoryStore where belief history depends on it:
+ * store() stamps its own id/timestamp, upsert() honours both, and list() strips vectors
+ * (which is why archiving has to re-read or re-embed).
+ */
+function createDeps(options: { withUpsert?: boolean; withGetById?: boolean } = {}) {
+  const { withUpsert = true, withGetById = true } = options;
+  const storedEntries: any[] = [];
+  const embedCalls: string[] = [];
+  let seq = 1;
+
+  const store: Record<string, unknown> = {
+    async store(entry: any) {
+      const stored = {
+        ...entry,
+        id: entry.id ?? `00000000-0000-0000-0000-${String(seq).padStart(12, "0")}`,
+        timestamp: 1_700_000_000_000 + seq,
+      };
+      seq += 1;
+      // The real store() routes through upsert (mergeInsert on id), so writing a known id
+      // replaces that row rather than adding a second one with the same id.
+      const index = storedEntries.findIndex((item) => item.id === stored.id);
+      if (index >= 0) storedEntries[index] = stored;
+      else storedEntries.push(stored);
+      return stored;
+    },
+    async list(_scopeFilter?: string[], category?: string, limit = 20, offset = 0) {
+      return storedEntries
+        .filter((entry) => !category || entry.category === category)
+        // The real store drops vectors from list results for performance.
+        .map((entry) => ({ ...entry, vector: [] }))
+        .slice(offset, offset + limit);
+    },
+    async update(id: string, updates: any) {
+      const index = storedEntries.findIndex((entry) => entry.id === id);
+      if (index < 0) return null;
+      storedEntries[index] = {
+        ...storedEntries[index],
+        ...updates,
+        timestamp: updates.timestamp ?? storedEntries[index].timestamp,
+      };
+      return storedEntries[index];
+    },
+  };
+
+  if (withUpsert) {
+    store.upsert = async (entry: any) => {
+      const index = storedEntries.findIndex((item) => item.id === entry.id);
+      if (index >= 0) storedEntries[index] = { ...entry };
+      else storedEntries.push({ ...entry });
+      return entry;
+    };
+  }
+  if (withGetById) {
+    store.getById = async (id: string) => storedEntries.find((entry) => entry.id === id) || null;
+  }
+
+  return {
+    storedEntries,
+    embedCalls,
+    deps: {
+      store,
+      embedder: {
+        async embedPassage(text: string) {
+          embedCalls.push(text);
+          return [text.length, 1, 0];
+        },
+      },
+    },
+  };
+}
+
+async function writeBelief(deps: unknown, text: string) {
+  return await persistMemory(deps as any, {
+    text,
+    category: "preferences",
+    scope: TEST_SCOPE,
+    source: "manual",
+    canonicalKey: CANONICAL_KEY,
+  });
+}
+
+describe("belief history", () => {
+  it("keeps every superseded version when a belief changes repeatedly", async () => {
+    const { deps, storedEntries } = createDeps();
+
+    const first = await writeBelief(deps, "User prefers long, thorough replies");
+    await writeBelief(deps, "User prefers concise replies");
+    await writeBelief(deps, "User prefers concise, code-first replies");
+
+    // One live canonical row + two archived versions — nothing was overwritten away.
+    expect(storedEntries).toHaveLength(3);
+
+    const canonical = storedEntries.find((entry) => entry.id === first.id);
+    expect(canonical.text).toBe("User prefers concise, code-first replies");
+    expect(parseEvolution(canonical.metadata).status).toBe("active");
+
+    const archived = storedEntries.filter((entry) => entry.id !== first.id);
+    expect(archived.map((entry) => entry.text).sort()).toEqual([
+      "User prefers concise replies",
+      "User prefers long, thorough replies",
+    ].sort());
+
+    for (const row of archived) {
+      const evo = parseEvolution(row.metadata);
+      expect(evo.status).toBe("superseded");
+      expect(evo.supersededBy).toBe(first.id);
+      // A closed interval is what makes an as-of query possible at all.
+      expect(evo.validUntil).toBeGreaterThan(0);
+      expect(evo.validUntil).toBeGreaterThanOrEqual(evo.validFrom);
+    }
+  });
+
+  it("links versions into a chain that traceEvolution can walk back through", async () => {
+    const { deps, storedEntries } = createDeps();
+
+    const first = await writeBelief(deps, "Belief version one about reply style");
+    await writeBelief(deps, "Belief version two about reply style");
+    await writeBelief(deps, "Belief version three about reply style");
+
+    const byId = new Map(storedEntries.map((entry) => [entry.id, entry]));
+    const trace = await traceEvolution(first.id, async (id) => byId.get(id) ?? null);
+
+    const texts = trace.map((entry) => byId.get(entry.id)?.text);
+    expect(texts).toEqual([
+      "Belief version one about reply style",
+      "Belief version two about reply style",
+      "Belief version three about reply style",
+    ]);
+    expect(trace[trace.length - 1].direction).toBe("self");
+  });
+
+  it("keeps archived versions out of default retrieval", async () => {
+    const { deps, storedEntries } = createDeps();
+
+    await writeBelief(deps, "User is based in Guangzhou");
+    await writeBelief(deps, "User is based in Singapore");
+
+    const visibleByDefault = storedEntries.filter((entry) => isActiveMemory(entry.metadata));
+    expect(visibleByDefault).toHaveLength(1);
+    expect(visibleByDefault[0].text).toBe("User is based in Singapore");
+  });
+
+  it("treats a revert to an earlier wording as a real change, not a duplicate", async () => {
+    const { deps, storedEntries } = createDeps();
+
+    await writeBelief(deps, "User prefers dark mode");
+    await writeBelief(deps, "User prefers light mode");
+    // Changing back: the archived row still carries the same canonicalKey, so without a
+    // status filter on canonical matching this would be misread as a duplicate write.
+    const third = await writeBelief(deps, "User prefers dark mode");
+
+    expect(third.disposition).toBe("updated");
+
+    const canonical = storedEntries.find((entry) => isActiveMemory(entry.metadata));
+    expect(canonical.text).toBe("User prefers dark mode");
+    expect(parseEvolution(canonical.metadata).version).toBe(3);
+  });
+
+  it("archives even when the canonical row has fallen out of the scan window", async () => {
+    // findCanonicalMatches only sees the most recent CANONICAL_SCAN_LIMIT rows. Past that,
+    // the write falls through to store(), which upserts on the deterministic canonical id —
+    // historically an unguarded overwrite. Simulate the miss by blinding list().
+    const { deps, storedEntries } = createDeps();
+    await writeBelief(deps, "User works from the Guangzhou office");
+
+    (deps.store as any).list = async () => [];
+
+    await writeBelief(deps, "User works from the Singapore office");
+
+    expect(storedEntries).toHaveLength(2);
+    const archived = storedEntries.find((entry) => !isActiveMemory(entry.metadata));
+    expect(archived).toBeDefined();
+    expect(archived.text).toBe("User works from the Guangzhou office");
+    expect(parseEvolution(archived.metadata).validUntil).toBeGreaterThan(0);
+  });
+
+  it("re-embeds the archived text when the store cannot return the original vector", async () => {
+    const { deps, embedCalls, storedEntries } = createDeps({ withGetById: false });
+
+    await writeBelief(deps, "Vectorless original");
+    await writeBelief(deps, "Replacement belief");
+
+    const archived = storedEntries.find((entry) => !isActiveMemory(entry.metadata));
+    expect(archived.vector.length).toBeGreaterThan(0);
+    expect(embedCalls).toContain("Vectorless original");
+  });
+
+  it("fails loudly rather than silently dropping history it cannot archive", async () => {
+    const { deps } = createDeps();
+    const failing = {
+      store: {
+        ...(deps.store as Record<string, unknown>),
+        upsert: async () => { throw new Error("disk full"); },
+        store: async () => { throw new Error("disk full"); },
+      },
+      embedder: deps.embedder,
+    };
+
+    await expect(archiveBeliefVersion(failing as any, {
+      id: "00000000-0000-0000-0000-000000000001",
+      text: "Belief that must not vanish",
+      vector: [1, 2, 3],
+      category: "preferences",
+      scope: TEST_SCOPE,
+      importance: 0.8,
+      timestamp: 1_700_000_000_001,
+      metadata: "{}",
+    })).rejects.toThrow("disk full");
+  });
+});

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

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "bun:test";
 
 import { persistCaseMemory, persistMemory, persistMemoryBatch, persistWorkflowPattern, promoteMemory } from "../capture-engine.js";
+import { parseEvolution } from "../memory-evolution.js";
 
 const TEST_SCOPE = "project:test";
 
@@ -44,6 +45,18 @@ function createDeps() {
           };
           return storedEntries[index];
         },
+        // Mirrors MemoryStore.upsert (mergeInsert on id): honours the caller's id and
+        // timestamp verbatim, unlike store() which stamps its own. Belief-history rows
+        // depend on both being preserved.
+        async upsert(entry: any) {
+          const index = storedEntries.findIndex((item) => item.id === entry.id);
+          if (index >= 0) {
+            storedEntries[index] = { ...entry };
+          } else {
+            storedEntries.push({ ...entry });
+          }
+          return entry;
+        },
         async getById(id: string) {
           return storedEntries.find((entry) => entry.id === id) || null;
         },
@@ -244,8 +257,24 @@ describe("persistMemory", () => {
 
     expect(second.disposition).toBe("updated");
     expect(second.id).toBe(first.id);
-    expect(storedEntries).toHaveLength(1);
-    expect(storedEntries[0].text).toContain("direct technical replies");
+
+    // The canonical row is still updated in place — but the replaced belief is now kept
+    // beside it as a superseded history row instead of being overwritten out of existence.
+    expect(storedEntries).toHaveLength(2);
+
+    const canonical = storedEntries.find((entry) => entry.id === first.id);
+    expect(canonical.text).toContain("direct technical replies");
+
+    const history = storedEntries.find((entry) => entry.id !== first.id);
+    expect(history.text).toBe("User prefers concise replies");
+
+    const historyEvo = parseEvolution(history.metadata);
+    expect(historyEvo.status).toBe("superseded");
+    expect(historyEvo.supersededBy).toBe(first.id);
+    expect(historyEvo.validUntil).toBeGreaterThan(0);
+
+    // Bidirectional link: the live belief points back at the version it replaced.
+    expect(parseEvolution(canonical.metadata).supersedes).toBe(history.id);
   });
 
   it("updates the same durable owner when the same atomic preference slot is rephrased", async () => {
@@ -268,7 +297,13 @@ describe("persistMemory", () => {
     expect(second.canonicalKey).toBe("preferences:brand-item:麦当劳:麦辣鸡翅");
     expect(second.disposition).toBe("updated");
     expect(second.id).toBe(first.id);
-    expect(storedEntries).toHaveLength(1);
+
+    // Rephrasing the same preference slot still lands on one canonical row, plus the
+    // archived copy of the wording it replaced.
+    expect(storedEntries).toHaveLength(2);
+    const history = storedEntries.find((entry) => entry.id !== first.id);
+    expect(history.text).toBe("我喜欢吃麦当劳的麦辣鸡翅");
+    expect(parseEvolution(history.metadata).status).toBe("superseded");
   });
 
   it("creates a conflict when the same canonicalKey is reused across durable categories", async () => {
@@ -1236,3 +1271,58 @@ describe("persistMemory — admission rejection reason passthrough", () => {
     expect(result.rejectionReason).toBeUndefined();
   });
 });
+
+describe("text length contract", () => {
+  // persistMemory validates through StoreMemoryInputSchema, whose text field is
+  // capped at 4000 chars. Pinned here because a lossy branch sits further down
+  // the same function (LC-P5: texts over 8000 get replaced by an LLM summary,
+  // or hard-truncated to 8000 when no LLM is available, with no record of the
+  // original). This cap is the only thing keeping that branch unreachable —
+  // oversized writes are rejected outright rather than silently reduced.
+  //
+  // If this test fails because the cap moved past 8000, that branch has gone
+  // live and originals will start being replaced with nothing to trace them
+  // back to. Sort out the large-text branch before updating this test.
+  const MAX_TEXT = 4000;
+
+  it("rejects oversized text outright rather than silently reducing it", async () => {
+    const { deps, storedEntries } = createDeps();
+
+    await expect(persistMemory(deps as any, {
+      text: "x".repeat(MAX_TEXT + 1),
+      category: "events",
+      scope: TEST_SCOPE,
+      source: "manual",
+    })).rejects.toThrow(/at most 4000 characters/);
+
+    expect(storedEntries.length).toBe(0);
+  });
+
+  it("keeps the lossy large-text branch out of reach", async () => {
+    const { deps } = createDeps();
+
+    // 9000 chars would hit the > 8000 summarise/truncate path if it were
+    // reachable; the schema stops it first.
+    await expect(persistMemory(deps as any, {
+      text: "detail worth keeping. ".repeat(410),
+      category: "events",
+      scope: TEST_SCOPE,
+      source: "manual",
+    })).rejects.toThrow(/at most 4000 characters/);
+  });
+
+  it("accepts text right at the cap", async () => {
+    const { deps } = createDeps();
+    const text = "a sentence that carries some actual meaning. ".repeat(120).slice(0, MAX_TEXT);
+    expect(text.length).toBe(MAX_TEXT);
+
+    // Schema boundary only — whether admission control later judges the content
+    // is a separate concern; this asserts the cap itself does not reject.
+    await expect(persistMemory(deps as any, {
+      text,
+      category: "events",
+      scope: TEST_SCOPE,
+      source: "manual",
+    })).resolves.toBeDefined();
+  });
+});

package/src/__tests__/category-min-scores.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it } from "bun:test";
 
 import { DEFAULT_CATEGORY_MIN_SCORES, DEFAULT_RETRIEVAL_CONFIG } from "../retriever.js";
+import { RETRIEVAL_PROFILES, applyRetrievalProfile } from "../retrieval-profiles.js";
+
+const ALL_CATEGORIES = ["profile", "preferences", "entities", "events", "cases", "patterns"];
 
 describe("DEFAULT_CATEGORY_MIN_SCORES", () => {
   it("has entries for all 6 durable categories", () => {
@@ -31,3 +34,83 @@ describe("DEFAULT_CATEGORY_MIN_SCORES", () => {
     }
   });
 });
+
+describe("retrieval profiles carry scaled category thresholds", () => {
+  const scopedProfiles = ["writing", "debug", "fact-check"] as const;
+
+  it("default profile does not override category thresholds", () => {
+    expect(RETRIEVAL_PROFILES.default.overrides.categoryMinScores).toBeUndefined();
+    const { config } = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "default");
+    expect(config.categoryMinScores).toEqual(DEFAULT_RETRIEVAL_CONFIG.categoryMinScores);
+  });
+
+  // A partial map is the trap here: Retriever.minScoreFor() falls back to
+  // hardMinScore — not to DEFAULT_CATEGORY_MIN_SCORES — for unlisted categories.
+  it("every scoped profile supplies a COMPLETE category map", () => {
+    for (const name of scopedProfiles) {
+      const map = RETRIEVAL_PROFILES[name].overrides.categoryMinScores;
+      expect(map).toBeDefined();
+      expect(Object.keys(map!).sort()).toEqual([...ALL_CATEGORIES].sort());
+    }
+  });
+
+  it("thresholds track each profile's overall looseness", () => {
+    for (const name of scopedProfiles) {
+      const { overrides } = RETRIEVAL_PROFILES[name];
+      const looser = overrides.hardMinScore! < DEFAULT_RETRIEVAL_CONFIG.hardMinScore;
+      for (const category of ALL_CATEGORIES) {
+        const scaled = overrides.categoryMinScores![category];
+        const base = DEFAULT_CATEGORY_MIN_SCORES[category];
+        if (looser) {
+          expect(scaled).toBeLessThan(base);
+        } else {
+          expect(scaled).toBeGreaterThan(base);
+        }
+      }
+    }
+  });
+
+  it("preserves the relative ordering of the default map", () => {
+    const defaultOrder = [...ALL_CATEGORIES].sort(
+      (a, b) => DEFAULT_CATEGORY_MIN_SCORES[a] - DEFAULT_CATEGORY_MIN_SCORES[b],
+    );
+    for (const name of scopedProfiles) {
+      const map = RETRIEVAL_PROFILES[name].overrides.categoryMinScores!;
+      const scaledOrder = [...ALL_CATEGORIES].sort((a, b) => map[a] - map[b]);
+      expect(scaledOrder).toEqual(defaultOrder);
+    }
+  });
+
+  it("keeps every scaled threshold in valid range (0, 1)", () => {
+    for (const name of scopedProfiles) {
+      const map = RETRIEVAL_PROFILES[name].overrides.categoryMinScores!;
+      for (const threshold of Object.values(map)) {
+        expect(threshold).toBeGreaterThan(0);
+        expect(threshold).toBeLessThan(1);
+      }
+    }
+  });
+
+  it("applyRetrievalProfile propagates the map into the resolved config", () => {
+    const { config } = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "debug");
+    expect(config.categoryMinScores).toEqual(
+      RETRIEVAL_PROFILES.debug.overrides.categoryMinScores,
+    );
+  });
+
+  it("loosening and tightening both reach category admission", () => {
+    // debug (0.34) and writing (0.24) are looser than the 0.35 default …
+    const debug = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "debug").config;
+    const writing = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "writing").config;
+    expect(debug.categoryMinScores!.patterns).toBeLessThan(DEFAULT_CATEGORY_MIN_SCORES.patterns);
+    expect(writing.categoryMinScores!.events).toBeLessThan(DEFAULT_CATEGORY_MIN_SCORES.events);
+    // … and writing, being loosest, must admit more than debug.
+    expect(writing.categoryMinScores!.patterns).toBeLessThan(debug.categoryMinScores!.patterns);
+
+    // fact-check (0.38) is the only tighter profile.
+    const factCheck = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "fact-check").config;
+    expect(factCheck.categoryMinScores!.patterns).toBeGreaterThan(
+      DEFAULT_CATEGORY_MIN_SCORES.patterns,
+    );
+  });
+});

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

@@ -310,6 +310,128 @@ describe("clusterAndConsolidate", () => {
     expect(result.clustersConsolidated).toBe(1); // Still counts as processed
     expect(result.insightsGenerated).toBe(0); // No insight generated
     expect(stored.length).toBe(0); // Nothing stored
+    expect(result.llmFailures).toBe(0); // 返回 null 不是失败，是合法的"没料可炼"
+  });
+
+  // 2026-08-13：上面那条测的是 generateL0 **返回 null**；下面这条测它 **抛异常**。
+  // 两者此前走的是完全不同的路径 —— 返回 null 被消化，抛异常会一路冒出 runDream，
+  // 把整个 scope 的 dream 炸掉（llm-client 的 chat() 在 catch 里是 `throw err`）。
+  // 2026-08-09 memory 周日轮次连挂两次就是这条路径：15s AbortController 超时。
+  it("单个 cluster 的 LLM 抛异常时吸收掉，不炸整轮（2026-08-09 memory 轮次根因）", async () => {
+    const entries = [
+      makeEntry({ id: "a", text: "memory A", vector: [0.9, 0.1, 0] }),
+      makeEntry({ id: "b", text: "memory B", vector: [0.88, 0.12, 0] }),
+      makeEntry({ id: "c", text: "memory C", vector: [0.92, 0.08, 0] }),
+    ];
+
+    const { store, stored } = createMockStore();
+    const llm = {
+      async generateL0(_text: string): Promise<string | null> {
+        throw new Error("Request was aborted.");
+      },
+      async extractPattern(_texts: string[]): Promise<string | null> {
+        return null;
+      },
+    };
+    const embedder = createMockEmbedder();
+
+    const result = await clusterAndConsolidate({
+      entries,
+      embedder,
+      llm: llm as unknown as LLMClient,
+      store,
+      scope: "project:test",
+      minClusterSize: 3,
+      clusterThreshold: 0.75,
+    });
+
+    // 关键断言：函数正常返回而不是抛出。修复前这一行根本到不了 —— 异常直接冒到调用方。
+    expect(result.clustersFound).toBe(1);
+    expect(result.clustersConsolidated).toBe(1);
+    expect(result.insightsGenerated).toBe(0);
+    expect(stored.length).toBe(0);
+    // 吸收 ≠ 静默：失败要计数，否则"LLM 全程不可用"和"今天没料可炼"长得一样。
+    expect(result.llmFailures).toBe(1);
+  });
+
+  it("多个 cluster 时，一个 LLM 抛异常不影响其他 cluster 产出", async () => {
+    // 两个互相正交的簇，各 3 个成员
+    const entries = [
+      makeEntry({ id: "a1", text: "cluster one A", vector: [0.9, 0.1, 0] }),
+      makeEntry({ id: "a2", text: "cluster one B", vector: [0.88, 0.12, 0] }),
+      makeEntry({ id: "a3", text: "cluster one C", vector: [0.92, 0.08, 0] }),
+      makeEntry({ id: "b1", text: "cluster two A", vector: [0, 0.9, 0.1] }),
+      makeEntry({ id: "b2", text: "cluster two B", vector: [0, 0.88, 0.12] }),
+      makeEntry({ id: "b3", text: "cluster two C", vector: [0, 0.92, 0.08] }),
+    ];
+
+    const { store, stored } = createMockStore();
+    let call = 0;
+    const llm = {
+      async generateL0(_text: string): Promise<string | null> {
+        call++;
+        if (call === 1) throw new Error("Request was aborted.");
+        return "第二个簇的 insight";
+      },
+      async extractPattern(_texts: string[]): Promise<string | null> {
+        return null;
+      },
+    };
+    const embedder = createMockEmbedder();
+
+    const result = await clusterAndConsolidate({
+      entries,
+      embedder,
+      llm: llm as unknown as LLMClient,
+      store,
+      scope: "project:test",
+      minClusterSize: 3,
+      clusterThreshold: 0.75,
+    });
+
+    expect(result.clustersFound).toBe(2);
+    expect(result.llmFailures).toBe(1);
+    // 修复前：第一个簇抛异常 → 整个函数炸掉 → 第二个簇永远跑不到，产出为 0。
+    expect(result.insightsGenerated).toBe(1);
+    expect(stored.length).toBe(1);
+    expect(stored[0].text).toBe("第二个簇的 insight");
+  });
+
+  it("pattern 抽取抛异常时只丢这一簇的 pattern，已写好的 insight 不连坐", async () => {
+    const entries = [
+      makeEntry({ id: "a", text: "memory A", vector: [0.9, 0.1, 0] }),
+      makeEntry({ id: "b", text: "memory B", vector: [0.88, 0.12, 0] }),
+      makeEntry({ id: "c", text: "memory C", vector: [0.92, 0.08, 0] }),
+    ];
+
+    const { store, stored } = createMockStore();
+    const llm = {
+      async generateL0(_text: string): Promise<string | null> {
+        return "insight 正常产出";
+      },
+      async extractPattern(_texts: string[]): Promise<string | null> {
+        throw new Error("Request was aborted.");
+      },
+    };
+    const embedder = createMockEmbedder();
+
+    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.llmFailures).toBe(1);
+    expect(result.patternsExtracted).toBe(0);
+    // insight 已经写进去了，不该被 pattern 阶段的失败拖掉
+    expect(result.insightsGenerated).toBe(1);
+    expect(stored.length).toBe(1);
+    expect(stored[0].text).toBe("insight 正常产出");
   });
 
   it("respects maxClusters limit", async () => {
@@ -542,7 +664,7 @@ describe("clusterAndConsolidate — pattern extraction (HP-5)", () => {
     expect(patternEntry).toBeDefined();
     expect(patternEntry!.text).toContain("日料");
     expect(patternEntry!.category).toBe("patterns");
-    expect(patternEntry!.importance).toBeCloseTo(0.9, 5); // max(0.8) + 0.1
+    expect(patternEntry!.importance).toBeCloseTo(0.8, 5); // = max(0.8)，继承不加成
 
     const patternMeta = JSON.parse(patternEntry!.metadata!);
     expect(patternMeta.source_cluster_size).toBe(3);
@@ -615,7 +737,7 @@ describe("clusterAndConsolidate — pattern extraction (HP-5)", () => {
     expect(stored.length).toBe(1); // Only insight stored
   });
 
-  it("caps pattern importance at 1.0", async () => {
+  it("pattern importance 继承源里最高的，不再加成后撞上限", async () => {
     const entries = [
       makeEntry({ id: "a", text: "high importance A", vector: [0.9, 0.1, 0], importance: 0.95 }),
       makeEntry({ id: "b", text: "high importance B", vector: [0.88, 0.12, 0], importance: 0.98 }),
@@ -642,8 +764,49 @@ describe("clusterAndConsolidate — pattern extraction (HP-5)", () => {
 
     expect(result.patternsExtracted).toBe(1);
     const patternEntry = stored.find(s => JSON.parse(s.metadata!).cross_memory_pattern);
-    // max(0.98) + 0.1 = 1.08 → capped at 1.0
-    expect(patternEntry!.importance).toBe(1.0);
+    // 旧行为：max(0.98) + 0.1 = 1.08 → 撞 1.0 上限，派生物顶格。
+    // 现在直接取 max(0.98)，不存在需要 cap 的情形。
+    expect(patternEntry!.importance).toBeCloseTo(0.98, 5);
+    // 注意这里源本身就在 pin 带（0.98 >= 0.95），派生物照样继承进去。
+    // 「派生物不该继承人工 pin 身份」是另一个问题，单独立项，不在本次改动范围。
+  });
+
+  it("源都在 pin 线以下时，pattern 不再被加成推过 0.95", async () => {
+    // 这是加成最有害的形态：源里最高只有 0.85，本不该享有人工 pin 的待遇，
+    // 旧行为 0.85 + 0.1 = 0.95 正好跨进那个频段，于是这条 LLM 抽出来的 pattern
+    // 自动拿到永不归档（auto-gc.ts）和永不衰减（decay-engine.ts）的保护。
+    const entries = [
+      makeEntry({ id: "a", text: "topic A", vector: [0.9, 0.1, 0], importance: 0.85 }),
+      makeEntry({ id: "b", text: "topic B", vector: [0.88, 0.12, 0], importance: 0.8 }),
+      makeEntry({ id: "c", text: "topic C", vector: [0.92, 0.08, 0], importance: 0.75 }),
+    ];
+
+    const { store, stored } = createMockStore();
+    const llm = createMockLLM(
+      () => "insight",
+      () => "discovered pattern",
+    );
+    const embedder = createMockEmbedder();
+
+    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.patternsExtracted).toBe(1);
+    const patternEntry = stored.find(s => JSON.parse(s.metadata!).cross_memory_pattern);
+    expect(patternEntry!.importance).toBeCloseTo(0.85, 5);
+    expect(patternEntry!.importance).toBeLessThan(0.95);
+
+    // 派生物也不该压过它自己的源
+    const maxSource = Math.max(...entries.map(e => e.importance));
+    expect(patternEntry!.importance).toBeLessThanOrEqual(maxSource);
   });
 });