recallnest 3.0.0 → 3.0.1

package/src/__tests__/preference-matcher.test.ts

@@ -1,282 +0,0 @@
-/**
- * Tests for Tier 3.6: Preference Pattern Quick Matching
- *
- * Validates:
- * 1. matchPreference returns "create" when no similar preferences exist
- * 2. matchPreference returns "skip" for near-duplicate preferences (no LLM)
- * 3. matchPreference uses LLM when available for decision
- * 4. matchPreference returns "merge" with merged text from LLM
- * 5. matchPreference handles LLM failure gracefully
- * 6. applyPreferenceMatch handles merge and skip correctly
- * 7. Non-preference categories are not filtered
- */
-import { describe, expect, it } from "bun:test";
-import {
-  matchPreference,
-  applyPreferenceMatch,
-  DEFAULT_PREFERENCE_MATCHER_CONFIG,
-} from "../preference-matcher.js";
-import type { MemoryEntry, MemorySearchResult } from "../store.js";
-import type { LLMClient, DedupDecision } from "../llm-client.js";
-import { parseEvolution } from "../memory-evolution.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEntry(id: string, text: string, category = "preferences"): MemoryEntry {
-  return {
-    id,
-    text,
-    vector: [1, 0, 0],
-    category,
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: "{}",
-  };
-}
-
-function createMockStore(searchResults: MemorySearchResult[] = []) {
-  const updates: Array<{ id: string; text?: string; metadata?: string }> = [];
-  const archived: MemoryEntry[] = [];
-  const data = new Map<string, MemoryEntry>();
-  for (const r of searchResults) {
-    data.set(r.entry.id, { ...r.entry });
-  }
-
-  return {
-    updates,
-    archived,
-    data,
-    async vectorSearch(
-      _vector: number[],
-      _limit: number,
-      _minScore: number,
-      _scopeFilter?: string[],
-    ) {
-      return searchResults;
-    },
-    async getById(id: string) {
-      return data.get(id) ?? null;
-    },
-    // Belief-history rows land here rather than in `data` — merging must archive the
-    // version it replaces, so tests need to see what was written.
-    async upsert(entry: MemoryEntry) {
-      archived.push(entry);
-      return entry;
-    },
-    async store(entry: MemoryEntry) {
-      archived.push(entry);
-      return entry;
-    },
-    async update(id: string, upd: { text?: string; metadata?: string }, _scope?: string[]) {
-      const entry = data.get(id);
-      if (!entry) return null;
-      if (upd.text) {
-        entry.text = upd.text;
-      }
-      if (upd.metadata) {
-        entry.metadata = upd.metadata;
-      }
-      updates.push({ id, text: upd.text, metadata: upd.metadata });
-      return entry;
-    },
-  };
-}
-
-const mockDeps = {
-  embedder: {
-    async embedPassage(text: string) {
-      return [text.length, 1, 0];
-    },
-  },
-};
-
-function createMockLLM(dedupResult: DedupDecision, synthResult: string | null = "merged preference text"): LLMClient {
-  return {
-    async dedupDecision(_newText: string, _existingText: string) {
-      return dedupResult;
-    },
-    async synthesizeFragments(_fragments: string[], _query: string) {
-      return synthResult;
-    },
-  } as any;
-}
-
-// ---------------------------------------------------------------------------
-// matchPreference tests
-// ---------------------------------------------------------------------------
-
-describe("matchPreference", () => {
-  const vector = [1, 0, 0];
-  const scope = "project:test";
-
-  it("returns create when no similar preferences found", async () => {
-    const store = createMockStore([]);
-    const result = await matchPreference("I prefer dark mode", vector, scope, store as any, null);
-
-    expect(result.action).toBe("create");
-    expect(result.reason).toBe("no-similar-preferences");
-  });
-
-  it("ignores superseded belief-history rows as match candidates", async () => {
-    // store.vectorSearch() filters by scope only, so archived versions of a preference
-    // surface here alongside live ones. Matching against one would drop the incoming
-    // preference as a duplicate of a belief that is no longer held.
-    const archivedRow = makeEntry("p-old", "I prefer dark mode");
-    archivedRow.metadata = JSON.stringify({
-      evolution: { status: "superseded", validUntil: Date.now(), supersededBy: "p-live" },
-    });
-    const store = createMockStore([{ entry: archivedRow, score: 0.99 }]);
-
-    const result = await matchPreference("I prefer dark mode", vector, scope, store as any, null);
-
-    expect(result.action).toBe("create");
-    expect(result.reason).toBe("no-similar-preferences");
-  });
-
-  it("returns create when matches are non-preference category", async () => {
-    const store = createMockStore([
-      { entry: makeEntry("e1", "some entity", "entities"), score: 0.85 },
-    ]);
-    const result = await matchPreference("I prefer dark mode", vector, scope, store as any, null);
-
-    expect(result.action).toBe("create");
-    expect(result.reason).toBe("no-similar-preferences");
-  });
-
-  it("returns skip for high similarity without LLM", async () => {
-    const store = createMockStore([
-      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.95 },
-    ]);
-    const result = await matchPreference("I like dark mode", vector, scope, store as any, null);
-
-    expect(result.action).toBe("skip");
-    expect(result.reason).toContain("no-llm");
-  });
-
-  it("returns create for moderate similarity without LLM", async () => {
-    const store = createMockStore([
-      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.82 },
-    ]);
-    const result = await matchPreference("I like vim keybindings", vector, scope, store as any, null);
-
-    expect(result.action).toBe("create");
-    expect(result.reason).toContain("no-llm");
-  });
-
-  it("uses LLM to decide SKIP", async () => {
-    const store = createMockStore([
-      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.85 },
-    ]);
-    const llm = createMockLLM({ action: "SKIP", reason: "same preference" });
-
-    const result = await matchPreference("I like dark mode", vector, scope, store as any, llm);
-
-    expect(result.action).toBe("skip");
-    expect(result.reason).toContain("llm-skip");
-  });
-
-  it("uses LLM to decide MERGE and generates merged text", async () => {
-    const store = createMockStore([
-      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.85 },
-    ]);
-    const llm = createMockLLM(
-      { action: "MERGE", reason: "compatible preferences" },
-      "User prefers dark mode and compact layout",
-    );
-
-    const result = await matchPreference("I also like compact layout", vector, scope, store as any, llm);
-
-    expect(result.action).toBe("merge");
-    expect(result.mergeTargetId).toBe("p1");
-    expect(result.mergedText).toBe("User prefers dark mode and compact layout");
-  });
-
-  it("uses LLM to decide CREATE", async () => {
-    const store = createMockStore([
-      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.80 },
-    ]);
-    const llm = createMockLLM({ action: "CREATE", reason: "different preference" });
-
-    const result = await matchPreference("I prefer vim keybindings", vector, scope, store as any, llm);
-
-    expect(result.action).toBe("create");
-    expect(result.reason).toContain("llm-create");
-  });
-
-  it("falls back to create on LLM failure", async () => {
-    const store = createMockStore([
-      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.85 },
-    ]);
-    const llm = {
-      async dedupDecision() { throw new Error("LLM down"); },
-      async synthesizeFragments() { return null; },
-    } as any;
-
-    const result = await matchPreference("test pref", vector, scope, store as any, llm);
-
-    expect(result.action).toBe("create");
-    expect(result.reason).toBe("llm-error");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// applyPreferenceMatch tests
-// ---------------------------------------------------------------------------
-
-describe("applyPreferenceMatch", () => {
-  it("handles skip action", async () => {
-    const store = createMockStore([]);
-    const result = await applyPreferenceMatch(
-      { action: "skip", reason: "duplicate" },
-      store as any,
-      "project:test",
-      mockDeps,
-    );
-
-    expect(result.handled).toBe(true);
-    expect(result.entry).toBeUndefined();
-  });
-
-  it("handles merge action — updates existing entry text", async () => {
-    const existing = makeEntry("p1", "old preference text");
-    const store = createMockStore([{ entry: existing, score: 0.9 }]);
-
-    const result = await applyPreferenceMatch(
-      {
-        action: "merge",
-        mergeTargetId: "p1",
-        mergedText: "merged preference text",
-        reason: "llm-merge",
-      },
-      store as any,
-      "project:test",
-      mockDeps,
-    );
-
-    expect(result.handled).toBe(true);
-    expect(result.entry).toBeDefined();
-    expect(store.updates.length).toBe(1);
-    expect(store.updates[0].text).toBe("merged preference text");
-
-    // Merging replaces the target's wording — the pre-merge version must survive.
-    expect(store.archived).toHaveLength(1);
-    expect(store.archived[0].text).toBe("old preference text");
-    expect(parseEvolution(store.archived[0].metadata).status).toBe("superseded");
-    expect(parseEvolution(store.updates[0].metadata).supersedes).toBe(store.archived[0].id);
-  });
-
-  it("returns not handled for create action", async () => {
-    const store = createMockStore([]);
-    const result = await applyPreferenceMatch(
-      { action: "create", reason: "new" },
-      store as any,
-      "project:test",
-      mockDeps,
-    );
-
-    expect(result.handled).toBe(false);
-  });
-});

package/src/__tests__/preference-slots.test.ts

@@ -1,205 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  inferPreferenceSlot,
-  inferAtomicBrandItemPreferenceSlot,
-  parseBrandItemPreference,
-  inferReplyStylePreferenceSlot,
-  inferToolChoicePreferenceSlot,
-  inferImplicitUsageSlot,
-  samePreferenceSlot,
-} from "../preference-slots.js";
-
-describe("preference slots", () => {
-  it("parses Chinese and English brand-item preferences", () => {
-    expect(parseBrandItemPreference("我喜欢喝星巴克的抹茶拿铁")).toEqual({
-      brand: "星巴克",
-      items: ["抹茶拿铁"],
-      aggregate: false,
-    });
-
-    expect(parseBrandItemPreference("我喜欢吃麦当劳的麦旋风、板烧鸡腿堡和藤椒鸡派")).toEqual({
-      brand: "麦当劳",
-      items: ["麦旋风", "板烧鸡腿堡", "藤椒鸡派"],
-      aggregate: true,
-    });
-
-    expect(parseBrandItemPreference("I like the Big Mac from McDonald's")).toEqual({
-      brand: "mcdonald's",
-      items: ["bigmac"],
-      aggregate: false,
-    });
-
-    expect(parseBrandItemPreference("我们刚讨论过星巴克的抹茶拿铁做法")).toBeNull();
-  });
-
-  it("infers atomic brand-item slots and skips aggregate preferences", () => {
-    expect(inferAtomicBrandItemPreferenceSlot("我喜欢喝星巴克的抹茶拿铁")).toEqual({
-      type: "brand-item",
-      brand: "星巴克",
-      item: "抹茶拿铁",
-    });
-
-    expect(inferAtomicBrandItemPreferenceSlot("I like Big Mac from McDonald's")).toEqual({
-      type: "brand-item",
-      brand: "mcdonald's",
-      item: "bigmac",
-    });
-
-    expect(samePreferenceSlot(
-      inferAtomicBrandItemPreferenceSlot("I like the Big Mac from McDonald's"),
-      inferAtomicBrandItemPreferenceSlot("I like Big Mac from McDonald's"),
-    )).toBe(true);
-
-    expect(inferAtomicBrandItemPreferenceSlot("我喜欢吃麦当劳的麦旋风、板烧鸡腿堡")).toBeNull();
-  });
-
-  it("infers reply-style traits from explicit reply-style preferences", () => {
-    expect(inferReplyStylePreferenceSlot("User prefers concise, direct replies.")).toEqual({
-      type: "reply-style",
-      traits: ["concise", "direct"],
-    });
-
-    expect(inferReplyStylePreferenceSlot("用户不接受浮夸/营销腔，语气要口语化、不端着。")).toEqual({
-      type: "reply-style",
-      traits: ["colloquial", "grounded"],
-    });
-  });
-
-  it("can infer reply-style slots from compact trait phrases", () => {
-    expect(inferPreferenceSlot("用户偏好短句直说。")).toEqual({
-      type: "reply-style",
-      traits: ["concise", "direct"],
-    });
-  });
-
-  it("ignores descriptive non-preference text for reply-style and tool-choice parsing", () => {
-    expect(inferReplyStylePreferenceSlot("这段文案简洁直接，先别改。")).toBeNull();
-    expect(inferReplyStylePreferenceSlot("这段文案挺口语化，先别改。")).toBeNull();
-    expect(inferToolChoicePreferenceSlot("文档里写了 uses Bun over Node 的迁移说明。")).toBeNull();
-  });
-
-  it("compares reply-style slots by normalized trait sets", () => {
-    expect(samePreferenceSlot(
-      inferReplyStylePreferenceSlot("User prefers concise, direct replies."),
-      inferReplyStylePreferenceSlot("User prefers direct concise responses."),
-    )).toBe(true);
-
-    expect(samePreferenceSlot(
-      inferReplyStylePreferenceSlot("User prefers concise, direct replies."),
-      inferReplyStylePreferenceSlot("User prefers colloquial grounded replies."),
-    )).toBe(false);
-  });
-
-  it("infers tool-choice slots from explicit comparative preferences", () => {
-    expect(inferToolChoicePreferenceSlot("Uses Bun over Node.")).toEqual({
-      type: "tool-choice",
-      preferredTool: "bun",
-      avoidedTool: "node",
-    });
-
-    expect(inferToolChoicePreferenceSlot("更喜欢用 rg 而不是 grep")).toEqual({
-      type: "tool-choice",
-      preferredTool: "rg",
-      avoidedTool: "grep",
-    });
-  });
-
-  it("detects implicit usage preferences from 'I use X' patterns", () => {
-    expect(inferImplicitUsageSlot("I use Adobe Premiere Pro for video editing.")).toEqual({
-      type: "implicit-usage",
-      subject: "adobepremierepro",
-    });
-
-    expect(inferImplicitUsageSlot("User uses Python for data analysis.")).toEqual({
-      type: "implicit-usage",
-      subject: "python",
-    });
-
-    expect(inferImplicitUsageSlot("I have been using VS Code.")).toEqual({
-      type: "implicit-usage",
-      subject: "vscode",
-    });
-  });
-
-  it("detects implicit ownership preferences from 'I have X' patterns", () => {
-    expect(inferImplicitUsageSlot("I have a Sony A7III camera")).toEqual({
-      type: "implicit-usage",
-      subject: "sonya7iii",
-    });
-
-    expect(inferImplicitUsageSlot("User bought a Canon EOS R5 camera")).toEqual({
-      type: "implicit-usage",
-      subject: "canoneosr5",
-    });
-  });
-
-  it("detects implicit activity preferences from 'I enjoy X' patterns", () => {
-    expect(inferImplicitUsageSlot("I enjoy hiking.")).toEqual({
-      type: "implicit-usage",
-      subject: "hiking",
-    });
-
-    expect(inferImplicitUsageSlot("User loves ocean views.")).toEqual({
-      type: "implicit-usage",
-      subject: "oceanviews",
-    });
-
-    expect(inferImplicitUsageSlot("I really like photography.")).toEqual({
-      type: "implicit-usage",
-      subject: "photography",
-    });
-  });
-
-  it("detects implicit interest preferences from 'I'm learning X' patterns", () => {
-    expect(inferImplicitUsageSlot("I'm learning Spanish.")).toEqual({
-      type: "implicit-usage",
-      subject: "spanish",
-    });
-
-    expect(inferImplicitUsageSlot("User is interested in machine learning.")).toEqual({
-      type: "implicit-usage",
-      subject: "machinelearning",
-    });
-  });
-
-  it("detects Chinese implicit usage preferences", () => {
-    expect(inferImplicitUsageSlot("我在用Figma做设计。")).toEqual({
-      type: "implicit-usage",
-      subject: "figma",
-    });
-
-    expect(inferImplicitUsageSlot("我在学西班牙语。")).toEqual({
-      type: "implicit-usage",
-      subject: "西班牙语",
-    });
-  });
-
-  it("rejects short/empty implicit usage subjects", () => {
-    // "I use it" → subject "it" normalizes to 2 chars — at threshold
-    expect(inferImplicitUsageSlot("I use a.")).toBeNull();
-  });
-
-  it("explicit patterns take priority over implicit in inferPreferenceSlot", () => {
-    // "I like Big Mac from McDonald's" → brand-item, not implicit-usage
-    expect(inferPreferenceSlot("I like Big Mac from McDonald's")?.type).toBe("brand-item");
-
-    // "Uses Bun over Node." → tool-choice, not implicit-usage
-    expect(inferPreferenceSlot("Uses Bun over Node.")?.type).toBe("tool-choice");
-
-    // "I use Adobe Premiere Pro for video editing." → implicit-usage (no explicit pattern matches)
-    expect(inferPreferenceSlot("I use Adobe Premiere Pro for video editing.")?.type).toBe("implicit-usage");
-  });
-
-  it("compares implicit-usage slots by normalized subject", () => {
-    expect(samePreferenceSlot(
-      inferImplicitUsageSlot("I use Adobe Premiere Pro."),
-      inferImplicitUsageSlot("User uses Adobe Premiere Pro for editing."),
-    )).toBe(true);
-
-    expect(samePreferenceSlot(
-      inferImplicitUsageSlot("I use Premiere Pro."),
-      inferImplicitUsageSlot("I use DaVinci Resolve."),
-    )).toBe(false);
-  });
-});

package/src/__tests__/promotion-distinct-sources.test.ts

@@ -1,162 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  countDistinctSources,
-  extractSourceKey,
-  judgeDistinctSources,
-  scanForPromotions,
-  UNKNOWN_SOURCE_PREFIX,
-} from "../skill-promotion.js";
-import type { MemoryEntry, MemorySearchResult } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Mock（与 skill-promotion.test.ts 同款生产语义：listPage 恒无向量，靠 getVectors 回填）
-// ---------------------------------------------------------------------------
-
-let seq = 0;
-function makeCase(srcTag: string | null, sim = 1.0, overrides: Partial<MemoryEntry> = {}): MemoryEntry {
-  seq += 1;
-  const complement = Math.sqrt(1 - sim * sim);
-  return {
-    id: `c-${String(seq).padStart(4, "0")}`,
-    text: `Docker 部署时缺系统库导致构建失败 #${seq}`,
-    vector: [sim, complement, 0],
-    category: "cases",
-    scope: "memory:pivot",
-    importance: 0.7,
-    timestamp: Date.UTC(2026, 7, 20) + seq * 1000,
-    metadata: JSON.stringify({
-      ...(srcTag ? { tags: [srcTag, "pinned"] } : {}),
-      evolution: {
-        status: "active", version: 1, accessCount: 0, lastAccessedAt: null,
-        supersededBy: null, consolidatedInto: null, sourceMemories: [],
-        validFrom: Date.now(), validUntil: null,
-      },
-    }),
-    ...overrides,
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]) {
-  return {
-    async listPage(opts: { category?: string; limit?: number; offset?: number } = {}): Promise<MemoryEntry[]> {
-      const { category, limit = 1000, offset = 0 } = opts;
-      const filtered = category ? entries.filter(e => e.category === category) : entries;
-      return filtered.slice(offset, offset + limit).map(e => ({ ...e, vector: [] }));
-    },
-    async getVectors(ids: string[]): Promise<Map<string, number[]>> {
-      const m = new Map<string, number[]>();
-      for (const id of ids) {
-        const e = entries.find(x => x.id === id);
-        if (e?.vector?.length) m.set(id, e.vector);
-      }
-      return m;
-    },
-    async vectorSearch(): Promise<MemorySearchResult[]> { return []; },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// 来源识别
-// ---------------------------------------------------------------------------
-
-describe("source identity", () => {
-  it("prefers evidenceMemories over the src: tag", () => {
-    const key = extractSourceKey({
-      metadata: JSON.stringify({ evidenceMemories: ["m2", "m1"], tags: ["src:aaaa1111"] }),
-      scope: "memory:pivot",
-      timestamp: Date.now(),
-    });
-    // 同一批源不管顺序都是同一个来源
-    expect(key).toBe("ev:m1|m2");
-  });
-
-  it("falls back to the src: tag that §5.3 requires on pivot writes", () => {
-    const key = extractSourceKey({
-      metadata: JSON.stringify({ tags: ["pinned", "src:cac4f155", "2026-08-23"] }),
-      scope: "memory:pivot",
-      timestamp: Date.now(),
-    });
-    expect(key).toBe("src:cac4f155");
-  });
-
-  it("marks the day-bucket fallback as unknown so callers can abstain", () => {
-    const key = extractSourceKey({ metadata: "{}", scope: "project:x", timestamp: Date.UTC(2026, 7, 23) });
-    expect(key.startsWith(UNKNOWN_SOURCE_PREFIX)).toBe(true);
-    expect(key).toBe("day:project:x:2026-08-23");
-  });
-
-  it("counts three records from one session as one source", () => {
-    const members = [1, 2, 3].map(() => makeCase("src:aaaa1111"));
-    expect(countDistinctSources(members)).toBe(1);
-  });
-});
-
-describe("judgeDistinctSources", () => {
-  it("rejects a cluster that is one experience repeated", () => {
-    const verdict = judgeDistinctSources([1, 2, 3].map(() => makeCase("src:aaaa1111")), 2);
-    expect(verdict.status).toBe("rejected");
-  });
-
-  it("accepts a cluster spanning two different sessions", () => {
-    const verdict = judgeDistinctSources(
-      [makeCase("src:aaaa1111"), makeCase("src:aaaa1111"), makeCase("src:bbbb2222")],
-      2,
-    );
-    expect(verdict).toEqual({ status: "ok", distinctSources: 2 });
-  });
-
-  it("abstains — never rejects — when no record carries a real source pointer", () => {
-    // 全库 cases 只有 1.2% 带 src:，一律硬判会把「同一天解决的三个不同问题」误伤掉。
-    expect(judgeDistinctSources([1, 2, 3].map(() => makeCase(null)), 2)).toEqual({ status: "abstained" });
-  });
-
-  it("is disabled at minDistinctSources=1 (the pre-P2 behaviour)", () => {
-    const verdict = judgeDistinctSources([1, 2, 3].map(() => makeCase("src:aaaa1111")), 1);
-    expect(verdict.status).toBe("ok");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 改前 / 改后对照 —— 「同一个坑踩三次」的具体例子
-// ---------------------------------------------------------------------------
-
-describe("promotion scan: same pothole three times vs two real tasks", () => {
-  it("promotes it under the old rule and rejects it under the new one", async () => {
-    const samePothole = [1, 2, 3].map(() => makeCase("src:aaaa1111", 1.0));
-    const store = createMockStore(samePothole);
-
-    const before = await scanForPromotions(store as never, "memory:pivot", { minDistinctSources: 1 });
-    expect(before.candidates.filter(c => c.type === "case_to_pattern").length).toBe(1);
-    expect(before.rejectedSingleSource).toBe(0);
-
-    const after = await scanForPromotions(store as never, "memory:pivot", { minDistinctSources: 2 });
-    expect(after.candidates.filter(c => c.type === "case_to_pattern").length).toBe(0);
-    expect(after.rejectedSingleSource).toBe(1);
-  });
-
-  it("keeps promoting a cluster that really spans different tasks", async () => {
-    // 审计原话：两个完全不同的任务（Alpine 装 lxml vs Docker 部署 Django）撞上同类子问题
-    // （容器缺系统库），才诱导出一条可迁移的规律。
-    const crossTask = [
-      makeCase("src:aaaa1111", 1.0),
-      makeCase("src:bbbb2222", 1.0),
-      makeCase("src:cccc3333", 1.0),
-    ];
-    const store = createMockStore(crossTask);
-
-    const result = await scanForPromotions(store as never, "memory:pivot", { minDistinctSources: 2 });
-    const candidate = result.candidates.find(c => c.type === "case_to_pattern");
-    expect(candidate).toBeDefined();
-    expect(candidate!.distinctSources).toBe(3);
-    expect(result.rejectedSingleSource).toBe(0);
-  });
-
-  it("abstains (and says so) when the scope has no source pointers at all", async () => {
-    const store = createMockStore([1, 2, 3].map(() => makeCase(null, 1.0)));
-    const result = await scanForPromotions(store as never, "project:legacy", { minDistinctSources: 2 });
-    expect(result.candidates.filter(c => c.type === "case_to_pattern").length).toBe(1);
-    expect(result.abstainedUnknownSource).toBe(1);
-    expect(result.rejectedSingleSource).toBe(0);
-  });
-});