recallnest 3.0.0 → 3.0.1

package/src/__tests__/access-tracker-novelty.test.ts

@@ -1,324 +0,0 @@
-/**
- * Tests for Tier 3.2: Conditional access reinforcement (prediction error gating).
- *
- * Validates that:
- * 1. High-similarity (low-novelty) results are NOT reinforced
- * 2. Low-similarity (high-novelty) results ARE reinforced
- * 3. Cooldown prevents duplicate reinforcement within the window
- * 4. When no scores provided, all entries are reinforced (backward compat)
- * 5. shouldReinforce() logic is correct in isolation
- */
-import { describe, expect, it, beforeEach } from "bun:test";
-import { AccessTracker, DEFAULT_ACCESS_TRACKER_CONFIG } from "../access-tracker.js";
-import type { MemoryEntry } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEntry(id: string, overrides: Partial<MemoryEntry> = {}): MemoryEntry {
-  return {
-    id,
-    text: `memory-${id}`,
-    vector: [1, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: JSON.stringify({ accessCount: 0, lastAccessedAt: 0 }),
-    ...overrides,
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]) {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  const updates: Array<{ id: string; metadata?: string }> = [];
-
-  // 模拟 store.patchMetadata 单写通道:读最新 metadata → patchFn → 写回。
-  return {
-    updates,
-    data,
-    async patchMetadata(
-      id: string,
-      patchFn: (meta: Record<string, unknown>, entry: MemoryEntry) => Record<string, unknown>,
-      _scopeFilter?: string[],
-    ) {
-      const entry = data.get(id);
-      if (!entry) return null;
-      let meta: Record<string, unknown>;
-      try {
-        const parsed: unknown = JSON.parse(entry.metadata || "{}");
-        meta = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
-          ? (parsed as Record<string, unknown>)
-          : {};
-      } catch {
-        meta = {};
-      }
-      const patched = patchFn(meta, entry);
-      entry.metadata = JSON.stringify(patched);
-      updates.push({ id, metadata: entry.metadata });
-      return entry;
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// shouldReinforce() unit tests
-// ---------------------------------------------------------------------------
-
-describe("shouldReinforce", () => {
-  let tracker: AccessTracker;
-
-  beforeEach(() => {
-    tracker = new AccessTracker(
-      createMockStore([]) as any,
-      { ...DEFAULT_ACCESS_TRACKER_CONFIG, noveltyThreshold: 0.35, cooldownMs: 300_000 },
-    );
-  });
-
-  it("rejects high-similarity (low-novelty) results", () => {
-    // similarity 0.90 → novelty 0.10 < threshold 0.35 → reject
-    expect(tracker.shouldReinforce("a", 0.90)).toBe(false);
-  });
-
-  it("rejects exact match (similarity 1.0)", () => {
-    expect(tracker.shouldReinforce("a", 1.0)).toBe(false);
-  });
-
-  it("accepts low-similarity (high-novelty) results", () => {
-    // similarity 0.50 → novelty 0.50 > threshold 0.35 → accept
-    expect(tracker.shouldReinforce("a", 0.50)).toBe(true);
-  });
-
-  it("accepts borderline novelty (exactly at threshold)", () => {
-    // similarity 0.65 → novelty 0.35 = threshold 0.35 → accept (not strictly less)
-    expect(tracker.shouldReinforce("a", 0.65)).toBe(true);
-  });
-
-  it("rejects same entry within cooldown window", () => {
-    // First call: accepted
-    expect(tracker.shouldReinforce("a", 0.50)).toBe(true);
-    // Simulate recording to set cooldown
-    tracker.recordAccess(["a"], [0.50]);
-    // Second call within cooldown: rejected
-    expect(tracker.shouldReinforce("a", 0.50)).toBe(false);
-  });
-
-  it("accepts different entry even if another is on cooldown", () => {
-    tracker.recordAccess(["a"], [0.50]);
-    expect(tracker.shouldReinforce("b", 0.50)).toBe(true);
-  });
-
-  it("bypasses novelty gate when threshold is 0", () => {
-    const noGateTracker = new AccessTracker(
-      createMockStore([]) as any,
-      { ...DEFAULT_ACCESS_TRACKER_CONFIG, noveltyThreshold: 0, cooldownMs: 0 },
-    );
-    // Even high similarity passes
-    expect(noGateTracker.shouldReinforce("a", 0.99)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// recordAccess() with scores
-// ---------------------------------------------------------------------------
-
-describe("recordAccess with novelty gating", () => {
-  it("only queues novel entries for flush", async () => {
-    const entries = [makeEntry("a"), makeEntry("b"), makeEntry("c")];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 0, // immediate flush for testing
-      noveltyThreshold: 0.35,
-      cooldownMs: 0,
-    });
-
-    // scores: a=0.90 (low novelty, reject), b=0.50 (novel, accept), c=0.40 (novel, accept)
-    tracker.recordAccess(["a", "b", "c"], [0.90, 0.50, 0.40]);
-
-    await tracker.flush();
-
-    // Only b and c should have been updated
-    const updatedIds = store.updates.map(u => u.id);
-    expect(updatedIds).not.toContain("a");
-    expect(updatedIds).toContain("b");
-    expect(updatedIds).toContain("c");
-  });
-
-  it("reinforces all entries when no scores provided (backward compat)", async () => {
-    const entries = [makeEntry("a"), makeEntry("b")];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 0,
-      noveltyThreshold: 0.35,
-      cooldownMs: 0,
-    });
-
-    // No scores → all reinforced
-    tracker.recordAccess(["a", "b"]);
-    await tracker.flush();
-
-    const updatedIds = store.updates.map(u => u.id);
-    expect(updatedIds).toContain("a");
-    expect(updatedIds).toContain("b");
-  });
-
-  it("respects cooldown across multiple recordAccess calls", async () => {
-    const entries = [makeEntry("x")];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 0,
-      noveltyThreshold: 0.35,
-      cooldownMs: 600_000, // 10 min cooldown
-    });
-
-    // First call: novel enough → queued
-    tracker.recordAccess(["x"], [0.50]);
-    await tracker.flush();
-    expect(store.updates.length).toBe(1);
-
-    // Second call: same entry within cooldown → not queued
-    tracker.recordAccess(["x"], [0.50]);
-    await tracker.flush();
-    // Still only 1 update (no new flush)
-    expect(store.updates.length).toBe(1);
-  });
-
-  it("skips flush scheduling when all entries are gated out", () => {
-    const store = createMockStore([]);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 5000,
-      noveltyThreshold: 0.35,
-      cooldownMs: 0,
-    });
-
-    // All scores too high (low novelty) → nothing queued
-    tracker.recordAccess(["a", "b"], [0.95, 0.90]);
-    expect(tracker.pendingCount).toBe(0);
-  });
-
-  it("accessCount increments correctly after novelty-gated flush", async () => {
-    const entries = [makeEntry("m1")];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 0,
-      noveltyThreshold: 0.35,
-      cooldownMs: 0,
-    });
-
-    tracker.recordAccess(["m1"], [0.40]); // novel → accepted
-    await tracker.flush();
-
-    const updated = store.data.get("m1")!;
-    const meta = JSON.parse(updated.metadata);
-    expect(meta.accessCount).toBe(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// destroy() cleans cooldown
-// ---------------------------------------------------------------------------
-
-describe("destroy cleans cooldown", () => {
-  it("clears cooldown map on destroy", () => {
-    const tracker = new AccessTracker(
-      createMockStore([]) as any,
-      { ...DEFAULT_ACCESS_TRACKER_CONFIG, cooldownMs: 600_000 },
-    );
-    tracker.recordAccess(["a"], [0.40]);
-    tracker.destroy();
-    // After destroy, same entry should be reinforceable again
-    expect(tracker.shouldReinforce("a", 0.40)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Distinct-reader bookkeeping (Artel read fan-out) + default-config semantics
-// ---------------------------------------------------------------------------
-
-describe("default config after 2026-07-23 production fix", () => {
-  it("novelty gate is OFF by default (high-similarity hits are reinforced)", () => {
-    const tracker = new AccessTracker(createMockStore([]) as any);
-    // 生产实测修复：真实相关命中 cosine >0.65 也必须打点
-    expect(tracker.shouldReinforce("a", 0.95)).toBe(true);
-  });
-});
-
-describe("distinct-reader bookkeeping", () => {
-  it("writes readerIds and distinctReaderCount on flush", async () => {
-    const entries = [makeEntry("a")];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 1,
-      cooldownMs: 0,
-    });
-    tracker.recordAccess(["a"]);
-    await tracker.flush();
-
-    const meta = JSON.parse(store.data.get("a")!.metadata!) as Record<string, unknown>;
-    expect(meta.accessCount).toBe(1);
-    expect(meta.readerIds).toEqual([tracker.readerId]);
-    expect(meta.distinctReaderCount).toBe(1);
-  });
-
-  it("dedups same reader and unions different readers", async () => {
-    // 2026-08-23 语义订正：同进程内的多个 AccessTracker 现在共享一个 readerId。
-    // 旧版每个实例各随机一个，与本文件测的那句注释（access-tracker.ts:63
-    // "one stdio MCP server process ≈ one CC session"）直接矛盾——components 按
-    // profile 缓存，同一个会话开两个 profile 就凭空多出一个"读者"，
-    // 把 distinctReaderCount 抬高、进而虚抬 skill-promotion 的 readBoost。
-    // 所以「不同读者」这一半改用显式 readerId 表达（跨进程/跨会话的真实形态）。
-    const entries = [makeEntry("a")];
-    const store = createMockStore(entries);
-    const t1 = new AccessTracker(store as any, { ...DEFAULT_ACCESS_TRACKER_CONFIG, flushIntervalMs: 1, cooldownMs: 0 });
-    t1.recordAccess(["a"]);
-    await t1.flush();
-    t1.recordAccess(["a"]);
-    await t1.flush(); // same reader twice → still 1 distinct
-
-    const t2 = new AccessTracker(store as any, { ...DEFAULT_ACCESS_TRACKER_CONFIG, flushIntervalMs: 1, cooldownMs: 0 }, "r-second99");
-    t2.recordAccess(["a"]);
-    await t2.flush(); // genuinely different reader → 2 distinct
-
-    const meta = JSON.parse(store.data.get("a")!.metadata!) as Record<string, unknown>;
-    expect(meta.accessCount).toBe(3);
-    expect((meta.readerIds as string[]).sort()).toEqual([t1.readerId, t2.readerId].sort());
-    expect(meta.distinctReaderCount).toBe(2);
-  });
-
-  it("does not inflate distinct readers when one session builds several trackers", async () => {
-    // 这是上面那条订正保护的东西：同一会话的两个 profile 不该被数成两个读者。
-    const entries = [makeEntry("a")];
-    const store = createMockStore(entries);
-    const cfg = { ...DEFAULT_ACCESS_TRACKER_CONFIG, flushIntervalMs: 1, cooldownMs: 0 };
-    for (const tracker of [new AccessTracker(store as any, cfg), new AccessTracker(store as any, cfg)]) {
-      tracker.recordAccess(["a"]);
-      await tracker.flush();
-    }
-    const meta = JSON.parse(store.data.get("a")!.metadata!) as Record<string, unknown>;
-    expect((meta.readerIds as string[]).length).toBe(1);
-    expect(meta.distinctReaderCount).toBe(1);
-  });
-
-  it("saturates readerIds at READER_ID_CAP without growing the array", async () => {
-    const capped = Array.from({ length: 8 }, (_, i) => `r-cap${i}`);
-    const entries = [makeEntry("a", {
-      metadata: JSON.stringify({ accessCount: 8, readerIds: capped, distinctReaderCount: 8 }),
-    })];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, { ...DEFAULT_ACCESS_TRACKER_CONFIG, flushIntervalMs: 1, cooldownMs: 0 });
-    tracker.recordAccess(["a"]);
-    await tracker.flush();
-
-    const meta = JSON.parse(store.data.get("a")!.metadata!) as Record<string, unknown>;
-    expect((meta.readerIds as string[]).length).toBe(8); // no growth past cap
-    expect(meta.distinctReaderCount).toBe(8);            // saturates, no overcount
-    expect(meta.accessCount).toBe(9);                    // access still counted
-  });
-});

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

@@ -1,125 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { join } from "node:path";
-import { mkdirSync, rmSync, existsSync, writeFileSync } from "node:fs";
-import {
-  incrementWriteCount,
-  getWriteCount,
-  resetWriteCount,
-  listScopesAboveThreshold,
-  getDistillTier,
-  type ActivityCounterConfig,
-} from "../activity-counter.js";
-
-const TMP_DIR = join(import.meta.dir, "../../.tmp-activity-test");
-const testConfig: Partial<ActivityCounterConfig> = {
-  statsPath: join(TMP_DIR, "activity-stats.json"),
-  lightThreshold: 3,
-  standardThreshold: 10,
-  deepThreshold: 20,
-};
-const A = "cc:project:a";
-const B = "cc:project:b";
-
-describe("activity-counter (HP-3, per-scope)", async () => {
-  beforeEach(() => {
-    mkdirSync(TMP_DIR, { recursive: true });
-    const p = testConfig.statsPath!;
-    if (existsSync(p)) rmSync(p);
-  });
-
-  afterEach(() => {
-    rmSync(TMP_DIR, { recursive: true, force: true });
-  });
-
-  describe("incrementWriteCount", async () => {
-    it("starts at 0 and increments by 1 for a scope", async () => {
-      expect(getWriteCount(A, testConfig)).toBe(0);
-      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", async () => {
-      await incrementWriteCount(A, 5, testConfig);
-      expect(getWriteCount(A, testConfig)).toBe(5);
-      await incrementWriteCount(A, 3, testConfig);
-      expect(getWriteCount(A, testConfig)).toBe(8);
-    });
-
-    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", 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", 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", async () => {
-      await incrementWriteCount(A, 2, testConfig);
-      expect(listScopesAboveThreshold(10, testConfig)).toEqual([]);
-    });
-  });
-
-  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", async () => {
-      await incrementWriteCount(A, 3, testConfig);
-      expect(getDistillTier(A, testConfig)).toBe("light");
-    });
-
-    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", async () => {
-      await incrementWriteCount(A, 20, testConfig);
-      expect(getDistillTier(A, testConfig)).toBe("deep");
-      await incrementWriteCount(A, 100, testConfig);
-      expect(getDistillTier(A, testConfig)).toBe("deep");
-    });
-  });
-
-  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", async () => {
-      writeFileSync(testConfig.statsPath!, "not-json{{{");
-      expect(getWriteCount(A, testConfig)).toBe(0);
-    });
-
-    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(await incrementWriteCount(A, 1, testConfig)).toBe(1);
-    });
-  });
-});

package/src/__tests__/adaptive-fidelity.test.ts

@@ -1,102 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { formatCollapsedResults } from "../memory-output.js";
-import type { RetrievalResult } from "../retriever.js";
-
-// P-fidelity (点4): adaptive 档 search-native 实现（CC+Codex 共识 C：不复用 resume 的
-// collapseResults）。借鉴 RepoPrompt CE「保真度阶梯」内核——按相关性分配保真度 + token 预算，
-// 但渲染 query-aware（search 结果是"为什么命中"，必须显示匹配证据）。
-
-function makeResult(id: string, text: string, score: number, metadata = "{}"): RetrievalResult {
-  return {
-    entry: {
-      id,
-      text,
-      vector: [],
-      category: "events",
-      scope: "test",
-      importance: 0.5,
-      timestamp: Date.parse("2026-06-29T00:00:00.000Z"),
-      metadata,
-    },
-    score,
-    sources: {},
-  };
-}
-
-const ctx = { query: "QUERYMATCH", profile: "default" as never };
-
-describe("formatCollapsedResults (adaptive, search-native)", () => {
-  it("returns 'No results found' for empty input", () => {
-    expect(formatCollapsedResults([], ctx)).toBe("No results found.");
-  });
-
-  it("renders high-relevance (score ≥ 0.85) as FULL text", () => {
-    const out = formatCollapsedResults([makeResult("aaaaaaaa", "full detailed QUERYMATCH content here", 0.95)], ctx);
-    expect(out).toContain("[FULL] aaaaaaaa");
-    expect(out).toContain("full detailed QUERYMATCH content here");
-  });
-
-  it("renders lower-relevance as SNIP and keeps the matching evidence even when it's late in the text (P2-3)", () => {
-    const text = "Intro sentence. " + "filler ".repeat(20) + "the QUERYMATCH evidence is right here.";
-    const out = formatCollapsedResults([makeResult("bbbbbbbb", text, 0.60)], ctx);
-    expect(out).toContain("[SNIP] bbbbbbbb");
-    // 关键：query-aware snippet 必须保留匹配证据，而不是只截开头（这正是复用 collapse 时的 P2-3）
-    expect(out).toContain("QUERYMATCH");
-  });
-
-  it("does NOT drop low-score hits — adaptive is display, not a filter (P2-1)", () => {
-    const out = formatCollapsedResults([makeResult("cccccccc", "valid low-score QUERYMATCH hit", 0.30)], ctx);
-    expect(out).toContain("[SNIP] cccccccc");
-    expect(out).not.toContain("No results");
-  });
-
-  it("preserves caller order (e.g. highlight reorder), not raw score order (P2-2)", () => {
-    // 模拟 render:highlight — contextual 最相关但 raw score 较低的排在前。
-    const out = formatCollapsedResults([
-      makeResult("term0000", "term-relevant QUERYMATCH but lower score", 0.55),
-      makeResult("high0000", "higher score but less contextual", 0.95),
-    ], ctx);
-    const idxTerm = out.indexOf("term0000");
-    const idxHigh = out.indexOf("high0000");
-    expect(idxTerm).toBeGreaterThan(-1);
-    expect(idxHigh).toBeGreaterThan(-1);
-    expect(idxTerm).toBeLessThan(idxHigh); // term0000 仍在前
-  });
-
-  it("includes locator info (id / score / category)", () => {
-    const out = formatCollapsedResults([makeResult("dddddddd", "QUERYMATCH content", 0.90)], ctx);
-    expect(out).toContain("dddddddd");
-    expect(out).toContain("90%");
-    expect(out).toContain("events"); // category label
-  });
-
-  it("keeps the match visible for a short acronym query (adaptiveSnippet window, P2)", () => {
-    // pickBestSnippet 对短缩写 query 会退回开头；adaptiveSnippet 用 raw query 定位 + 窗口。
-    const text = "Some long intro line without the keyword. ".repeat(5) + "Finally the CI pipeline broke here.";
-    const out = formatCollapsedResults([makeResult("ffffffff", text, 0.50)], { query: "CI", profile: "default" as never });
-    expect(out).toContain("[SNIP] ffffffff");
-    expect(out.toLowerCase()).toContain("ci pipeline"); // 匹配证据可见，而非只截开头
-  });
-
-  it("windows around a match that is late in a long single line (P2)", () => {
-    // 超长无句读的 log 行：整句截断会丢后段匹配；adaptiveSnippet 取匹配词周围窗口。
-    const text = "prefix ".repeat(50) + "ZEBRAWORD is the late match here" + " suffix".repeat(50);
-    const out = formatCollapsedResults([makeResult("11111111", text, 0.50)], { query: "ZEBRAWORD", profile: "default" as never });
-    expect(out).toContain("ZEBRAWORD"); // 后段匹配仍在窗口内
-  });
-
-  it("does not false-match an acronym inside an unrelated earlier word (word boundary, P2)", () => {
-    // "specific" 含子串 "ci"；裸 substring 会 window 到它、漏掉真的 CI。word boundary 跳过。
-    const text = "This is a specific introduction. " + "filler ".repeat(10) + "Then the CI build failed.";
-    const out = formatCollapsedResults([makeResult("22222222", text, 0.50)], { query: "CI", profile: "default" as never });
-    expect(out).toContain("CI build"); // window 到真 CI，不是 specific 里的 ci
-  });
-
-  it("matches CJK fallback queries via substring (ASCII word boundary doesn't apply, P2-1)", () => {
-    // 中文单字 query：JS \b 只认 ASCII，必须走 substring，否则退回开头丢匹配（Alice 的记忆大量中文）。
-    const text = "开头一些无关的内容。" + "填充内容 ".repeat(10) + "这里才提到猫的关键证据。";
-    const out = formatCollapsedResults([makeResult("33333333", text, 0.50)], { query: "猫", profile: "default" as never });
-    expect(out).toContain("猫"); // 中文匹配证据可见
-  });
-});