recallnest 2.3.0 → 2.5.4

package/src/__tests__/ingest-chunking.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "bun:test";
+
+import { groupTurnsIntoChunks } from "../ingest.js";
+import { isNoise } from "../noise-filter.js";
+
+// P1 defence-in-depth: groupTurnsIntoChunks pre-filters whole turns via
+// filterNoiseTurns BEFORE chunking, but long turns then get split — and the
+// split fragments were never re-checked. A long turn whose tail is orphaned
+// context-JSON therefore leaks severed JSON field-lines as standalone chunks.
+// This guards that no chunk survives as noise, without over-deleting real talk.
+
+function userTurn(text: string) {
+  return { role: "user" as const, text, timestamp: "2026-05-21T00:00:00Z", sessionId: "s1" };
+}
+function assistantTurn(text: string) {
+  return { role: "assistant" as const, text, timestamp: "2026-05-21T00:00:01Z", sessionId: "s1" };
+}
+
+describe("groupTurnsIntoChunks — post-split noise filtering (P1)", () => {
+  it("drops severed context-JSON fragments produced by splitting a long turn", () => {
+    // Real-content opener (passes turn-level filterNoiseTurns), then a long tail
+    // of orphaned JSON field-lines that chunking peels into standalone chunks.
+    const opener = "我们今天把记忆系统这周的进展过一遍，重点是噪声治理和召回质量的提升。".repeat(8);
+    const jsonTail = Array.from(
+      { length: 60 },
+      (_, i) => `"time": "2026-05-21T15:${String(i).padStart(2, "0")}:03.796Z",`,
+    ).join("\n");
+    const chunks = groupTurnsIntoChunks([userTurn(`${opener}\n${jsonTail}`)]);
+
+    expect(chunks.length).toBeGreaterThan(0); // real content survives
+    // No chunk may survive as a recognizable noise fragment.
+    expect(chunks.every((c) => !isNoise(c.text))).toBe(true);
+  });
+
+  it("keeps a normal long Q&A conversation intact (no over-deletion)", () => {
+    const longQuestion = "你帮我想想这个方案怎么落地，我担心几个点没考虑周全，得一起捋一捋。".repeat(20);
+    const longAnswer = "可以分三步走，先做最小验证看效果，再逐步扩展覆盖面，最后补回归测试兜底。".repeat(20);
+    const chunks = groupTurnsIntoChunks([userTurn(longQuestion), assistantTurn(longAnswer)]);
+
+    expect(chunks.length).toBeGreaterThan(0);
+    expect(chunks.every((c) => !isNoise(c.text))).toBe(true); // real talk not deleted
+    expect(chunks.some((c) => c.text.includes("最小验证"))).toBe(true); // content retained
+  });
+});

package/src/__tests__/ingest.test.ts

@@ -0,0 +1,360 @@
+import { describe, expect, it } from "bun:test";
+
+import { dedupCheck } from "../ingest.js";
+
+function buildSearchResult(text: string, score: number) {
+  return {
+    score,
+    entry: {
+      id: `memory-${score}`,
+      text,
+      vector: [score],
+      category: "events",
+      scope: "cc:test-session",
+      importance: 0.6,
+      timestamp: 1_700_000_000_000,
+      metadata: "{}",
+    },
+  };
+}
+
+describe("dedupCheck", () => {
+  it("stores a new same-brand item preference instead of treating it as a duplicate topic", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult("喜欢吃麦当劳的麦旋风", 0.92),
+          buildSearchResult("喜欢吃麦当劳的板烧鸡腿堡", 0.89),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "SKIP" as const, reason: "same topic" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "我喜欢吃麦当劳的麦辣鸡翅",
+      llm as any,
+    );
+
+    expect(result.action).toBe("store");
+    expect(result.reason).toBe("unique");
+    expect(result.existingText).toBe("喜欢吃麦当劳的板烧鸡腿堡");
+    expect(llmCalls).toBe(0);
+  });
+
+  it("stores a new atomic preference even when the closest match is an aggregate summary", async () => {
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult("喜欢吃麦当劳的麦旋风、板烧鸡腿堡和藤椒鸡派", 0.94),
+        ];
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "我喜欢吃麦当劳的麦辣鸡翅",
+    );
+
+    expect(result.action).toBe("store");
+    expect(result.reason).toBe("unique");
+    expect(result.existingText).toContain("麦旋风");
+  });
+
+  it("still skips when an exact atomic preference already exists among the candidates", async () => {
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult("喜欢吃麦当劳的麦旋风、板烧鸡腿堡和藤椒鸡派", 0.94),
+          buildSearchResult("我喜欢吃麦当劳的麦辣鸡翅", 0.82),
+        ];
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "我喜欢吃麦当劳的麦辣鸡翅",
+    );
+
+    expect(result.action).toBe("skip");
+    expect(result.reason).toBe("exact");
+    expect(result.existingText).toBe("我喜欢吃麦当劳的麦辣鸡翅");
+  });
+
+  it("does not force-create when the same brand-item preference is only rephrased", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult("我喜欢吃麦当劳的麦辣鸡翅", 0.75),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "SKIP" as const, reason: "same item, rephrased" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "用户喜欢麦当劳的麦辣鸡翅",
+      llm as any,
+    );
+
+    expect(result.action).toBe("skip");
+    expect(result.reason).toBe("llm-skip");
+    expect(result.existingText).toBe("我喜欢吃麦当劳的麦辣鸡翅");
+    expect(llmCalls).toBe(1);
+  });
+
+  it("does not trigger the brand-item guard for non-preference text that mentions the same brand and item", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult("我喜欢喝星巴克的抹茶拿铁", 0.75),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "SKIP" as const, reason: "same context, not a new preference" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "我们刚讨论过星巴克的抹茶拿铁做法",
+      llm as any,
+    );
+
+    expect(result.action).toBe("skip");
+    expect(result.reason).toBe("llm-skip");
+    expect(result.existingText).toBe("我喜欢喝星巴克的抹茶拿铁");
+    expect(llmCalls).toBe(1);
+  });
+
+  it("stores a new reply-style preference instead of collapsing different style traits into one topic", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult("User prefers concise, direct replies.", 0.91),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "SKIP" as const, reason: "same topic" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "User prefers colloquial, grounded replies.",
+      llm as any,
+    );
+
+    expect(result.action).toBe("store");
+    expect(result.reason).toBe("unique");
+    expect(result.existingText).toBe("User prefers concise, direct replies.");
+    expect(llmCalls).toBe(0);
+  });
+
+  it("does not trigger the reply-style guard for descriptive text about a draft", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult("User prefers colloquial, grounded replies.", 0.75),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "SKIP" as const, reason: "draft note, not a user preference" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "这段文案简洁直接，先别改。",
+      llm as any,
+    );
+
+    expect(result.action).toBe("skip");
+    expect(result.reason).toBe("llm-skip");
+    expect(result.existingText).toBe("User prefers colloquial, grounded replies.");
+    expect(llmCalls).toBe(1);
+  });
+
+  it("stores a new tool-choice preference instead of collapsing different tool choices into one topic", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult("Uses Bun over Node.", 0.91),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "SKIP" as const, reason: "same topic" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "Prefers rg over grep.",
+      llm as any,
+    );
+
+    expect(result.action).toBe("store");
+    expect(result.reason).toBe("unique");
+    expect(result.existingText).toBe("Uses Bun over Node.");
+    expect(llmCalls).toBe(0);
+  });
+
+  it("does not trigger the tool-choice guard for narrative migration text", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult("Prefers rg over grep.", 0.75),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "SKIP" as const, reason: "migration note, not a tool preference" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "文档里写了 uses Bun over Node 的迁移说明。",
+      llm as any,
+    );
+
+    expect(result.action).toBe("skip");
+    expect(result.reason).toBe("llm-skip");
+    expect(result.existingText).toBe("Prefers rg over grep.");
+    expect(llmCalls).toBe(1);
+  });
+
+  it("stores a borderline chunk when LLM says it should CREATE", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult(
+            "A2A gateway 之前是先本地 smoke，再补 Claude SDK 配置。",
+            0.74,
+          ),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "CREATE" as const, reason: "new implementation branch" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "A2A gateway 升级后要补 MCP transport 配置和 LaunchAgent 环境变量，不是原来的 smoke 流程。",
+      llm as any,
+    );
+
+    expect(result.action).toBe("store");
+    expect(result.reason).toBe("unique");
+    expect(llmCalls).toBe(1);
+  });
+
+  it("stores a borderline chunk when LLM says it adds new information and should MERGE", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult(
+            "A2A 调 Claude SDK 时，可以先看 `adapters/claude.js` 里的权限相关配置。",
+            0.77,
+          ),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "MERGE" as const, reason: "same topic but new implementation detail" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "给 A2A 调用传 permissionMode: \"dontAsk\" + allowedTools，避免 Claude SDK 在后台 HTTP handler 里卡死等权限确认。",
+      llm as any,
+    );
+
+    expect(result.action).toBe("store");
+    expect(result.reason).toBe("llm-merge");
+    expect(result.existingText).toContain("权限相关配置");
+    expect(llmCalls).toBe(1);
+  });
+
+  it("skips a hard-threshold duplicate without calling the LLM", async () => {
+    let llmCalls = 0;
+    const store = {
+      async vectorSearch() {
+        return [
+          buildSearchResult(
+            "OpenClaw provider 配置里已经写过 `ANTHROPIC_BASE_URL` 和 `ANTHROPIC_AUTH_TOKEN` 的设置方法。",
+            0.95,
+          ),
+        ];
+      },
+    };
+    const llm = {
+      async dedupDecision() {
+        llmCalls += 1;
+        return { action: "MERGE" as const, reason: "should never be called" };
+      },
+    };
+
+    const result = await dedupCheck(
+      store as any,
+      [1, 0, 0],
+      "OpenClaw provider 配置里已经写过 `ANTHROPIC_BASE_URL` 和 `ANTHROPIC_AUTH_TOKEN` 的设置方法，但这里重复了一遍。",
+      llm as any,
+    );
+
+    expect(result.action).toBe("skip");
+    expect(result.reason).toBe("hard");
+    expect(llmCalls).toBe(0);
+  });
+});

package/src/__tests__/interference-detector.test.ts

@@ -0,0 +1,203 @@
+/**
+ * F2: Interference Detection + Active Forgetting Gate — tests for
+ * cluster detection, density measurement, RIF enhancement, and checkup.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  detectInterference,
+  measureInterferenceDensity,
+  type InterferenceResult,
+} from "../interference-detector.js";
+import { filterInterference } from "../rif.js";
+import type { MemoryEntry } from "../store.js";
+import type { RetrievalResult } from "../retriever.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Create a memory entry with a specific vector for clustering. */
+function makeMemory(id: string, vector: number[], importance = 0.7): MemoryEntry {
+  return {
+    id,
+    text: `memory ${id}`,
+    vector,
+    category: "events",
+    scope: "test",
+    importance,
+    timestamp: Date.now(),
+    metadata: JSON.stringify({ confidence: 0.7 }),
+  };
+}
+
+/** Create a unit vector in the given direction (for predictable cosine sim). */
+function unitVec(direction: number[], dims = 4): number[] {
+  const v = Array(dims).fill(0);
+  for (let i = 0; i < direction.length && i < dims; i++) v[i] = direction[i];
+  const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0));
+  return norm > 0 ? v.map(x => x / norm) : v;
+}
+
+function makeRetrievalResult(id: string, vector: number[], score: number): RetrievalResult {
+  return {
+    entry: makeMemory(id, vector),
+    score,
+    sources: {},
+  };
+}
+
+// ---------------------------------------------------------------------------
+// detectInterference
+// ---------------------------------------------------------------------------
+
+describe("F2: detectInterference", () => {
+  test("empty input returns empty array", () => {
+    expect(detectInterference([])).toEqual([]);
+  });
+
+  test("singleton memories have low risk", () => {
+    const m1 = makeMemory("a", unitVec([1, 0, 0, 0]));
+    const m2 = makeMemory("b", unitVec([0, 1, 0, 0])); // orthogonal — different cluster
+    const results = detectInterference([m1, m2]);
+    expect(results.length).toBe(2);
+    expect(results.every(r => r.interferenceRisk === "low")).toBe(true);
+  });
+
+  test("similar vectors form a cluster", () => {
+    const base = [1, 0.1, 0, 0];
+    const similar = [1, 0.15, 0, 0]; // very similar to base
+    const m1 = makeMemory("a", unitVec(base));
+    const m2 = makeMemory("b", unitVec(similar));
+    const m3 = makeMemory("c", unitVec([0, 0, 1, 0])); // different cluster
+    const results = detectInterference([m1, m2, m3]);
+    // m1 and m2 should be in same cluster, m3 alone
+    const clusterIds = new Set(results.map(r => r.clusterId));
+    expect(clusterIds.size).toBe(2); // 2 clusters
+  });
+
+  test("cluster rank 0 has low risk, rank 3+ has high risk", () => {
+    const v = unitVec([1, 0, 0, 0]);
+    const memories = [
+      makeMemory("a", v, 0.9),
+      makeMemory("b", v, 0.8),
+      makeMemory("c", v, 0.7),
+      makeMemory("d", v, 0.3), // weakest — should be high risk
+    ];
+    const results = detectInterference(memories);
+    // All in one cluster
+    const clusterIds = new Set(results.map(r => r.clusterId));
+    expect(clusterIds.size).toBe(1);
+    // Rank 0 is low risk
+    const topRanked = results.find(r => r.clusterRank === 0);
+    expect(topRanked?.interferenceRisk).toBe("low");
+    // Rank 3 is high risk
+    const bottomRanked = results.find(r => r.clusterRank === 3);
+    expect(bottomRanked?.interferenceRisk).toBe("high");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// measureInterferenceDensity
+// ---------------------------------------------------------------------------
+
+describe("F2: measureInterferenceDensity", () => {
+  test("no clusters → zero density", () => {
+    const memories = [
+      makeMemory("a", unitVec([1, 0, 0, 0])),
+      makeMemory("b", unitVec([0, 1, 0, 0])),
+      makeMemory("c", unitVec([0, 0, 1, 0])),
+    ];
+    const density = measureInterferenceDensity(memories);
+    expect(density.clusterCount).toBe(0);
+    expect(density.highRiskCount).toBe(0);
+    expect(density.avgClusterSize).toBe(0);
+  });
+
+  test("one cluster → density reflects cluster size", () => {
+    const v = unitVec([1, 0, 0, 0]);
+    const memories = [
+      makeMemory("a", v, 0.9),
+      makeMemory("b", v, 0.7),
+      makeMemory("c", v, 0.5),
+      makeMemory("d", v, 0.3),
+    ];
+    const density = measureInterferenceDensity(memories);
+    expect(density.clusterCount).toBe(1);
+    expect(density.avgClusterSize).toBe(4);
+    expect(density.highRiskCount).toBe(1); // rank 3 = high
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Enhanced RIF (cluster top-K)
+// ---------------------------------------------------------------------------
+
+describe("F2: Enhanced RIF with cluster top-K", () => {
+  test("cluster within top-K not demoted", () => {
+    const v = unitVec([1, 0, 0, 0]);
+    const results = [
+      makeRetrievalResult("a", v, 0.9),
+      makeRetrievalResult("b", v, 0.85),
+      makeRetrievalResult("c", v, 0.80),
+    ];
+    const filtered = filterInterference(results, 0.85, 0.80, 3);
+    // All 3 should be kept (within top-K=3)
+    expect(filtered.length).toBe(3);
+    expect(filtered[0].entry.id).toBe("a");
+  });
+
+  test("4th cluster member gets 50% score demotion", () => {
+    const v = unitVec([1, 0, 0, 0]);
+    const results = [
+      makeRetrievalResult("a", v, 0.9),
+      makeRetrievalResult("b", v, 0.85),
+      makeRetrievalResult("c", v, 0.80),
+      makeRetrievalResult("d", v, 0.75), // 4th member
+    ];
+    const filtered = filterInterference(results, 0.85, 0.80, 3);
+    // d should be at the end with 50% score
+    const d = filtered.find(r => r.entry.id === "d");
+    expect(d).toBeDefined();
+    expect(d!.score).toBeCloseTo(0.375, 2); // 0.75 * 0.5
+  });
+
+  test("diverse results unaffected by cluster top-K", () => {
+    const results = [
+      makeRetrievalResult("a", unitVec([1, 0, 0, 0]), 0.9),
+      makeRetrievalResult("b", unitVec([0, 1, 0, 0]), 0.85),
+      makeRetrievalResult("c", unitVec([0, 0, 1, 0]), 0.80),
+      makeRetrievalResult("d", unitVec([0, 0, 0, 1]), 0.75),
+    ];
+    const filtered = filterInterference(results, 0.85, 0.80, 3);
+    // All diverse — no demotion
+    expect(filtered.length).toBe(4);
+    expect(filtered.map(r => r.entry.id)).toEqual(["a", "b", "c", "d"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// data-checkup integration
+// ---------------------------------------------------------------------------
+
+describe("F2: data-checkup interference check", () => {
+  // We test the check function indirectly through measureInterferenceDensity
+  test("healthy density has low high-risk ratio", () => {
+    const memories = [
+      makeMemory("a", unitVec([1, 0, 0, 0])),
+      makeMemory("b", unitVec([0, 1, 0, 0])),
+      makeMemory("c", unitVec([0, 0, 1, 0])),
+    ];
+    const density = measureInterferenceDensity(memories);
+    // high-risk should be < 20% of total
+    expect(density.highRiskCount / density.totalMemories).toBeLessThan(0.2);
+  });
+
+  test("unhealthy density detected in identical vectors", () => {
+    const v = unitVec([1, 0, 0, 0]);
+    const memories = Array.from({ length: 10 }, (_, i) => makeMemory(`m${i}`, v, 0.5 - i * 0.01));
+    const density = measureInterferenceDensity(memories);
+    expect(density.clusterCount).toBe(1);
+    expect(density.highRiskCount).toBeGreaterThan(0);
+  });
+});