@modusensus/dsh-mneme 0.8.0 → 0.8.2

package/test/llm-message-source.test.js

@@ -0,0 +1,177 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+import { createSummarizer } from "../src/summarize.js";
+import { runSleep } from "../src/dream/sleep.js";
+import { extractEntities } from "../src/entities/extractor.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+// 回归：dsh-llm 的消息契约要求每条消息带 source。provider 适配器会直接读
+// message.source.kind 来区分用户内容与工具结果（例如
+// @mars-sea/dsh-commandcode-provider 的 messagesToCC），缺字段时请求在序列化
+// 阶段就抛 "Cannot read properties of undefined (reading 'kind')"，四条 LLM 管线
+// （dream / sleep / summarize / entity extraction）全军覆没、耗时 0ms。
+// 这里用同等严格的桩驱动真实管线，任何新加的消息漏了 source 都会失败。
+function assertMessageSources(options) {
+  for (const message of options.messages ?? []) {
+    assert.equal(
+      message.source?.kind,
+      "plugin",
+      `LLM 消息缺 source（provider 会抛 TypeError）: ${message.role} / ${String(message.content?.[0]?.text ?? "").slice(0, 40)}`
+    );
+  }
+}
+
+const logger = { warn: () => {}, info: () => {} };
+
+function makeService() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+// dsh-llm chunk 形状与真实 provider 对齐：文本增量 + 终止 chunk。
+function reply(text, finish = { reason: { kind: "stop" } }) {
+  return (async function* () {
+    yield { type: "text-delta", index: 0, text };
+    yield { type: "finish", ...finish };
+  })();
+}
+
+// ---------------------------------------------------------------- dream
+
+test("dream: consolidation and summary messages carry source", async () => {
+  const { store, service } = makeService();
+  service.saveWithDedupe({ type: "project", title: "主题01", content: "规范内容", importance: 5 });
+  service.saveWithDedupe({ type: "project", title: "主题01·变体", content: "旧变体", importance: 3 });
+
+  const calls = [];
+  const ctx = {
+    logger,
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "source-model" }) },
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        assertMessageSources(options);
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        yield* reply(userText.startsWith("id=") ? "[]" : "记忆库总览：已巩固。");
+      }
+    }
+  };
+
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const run = await dream.runDream(ctx, service, {});
+  assert.equal(run.ok, true, "dream run succeeds against the strict provider stub");
+  assert.ok(calls.some((c) => c.purpose === "compaction"), "consolidation called the LLM");
+  assert.ok(calls.length >= 2, "consolidation + summary both called");
+  store.close();
+});
+
+// ---------------------------------------------------------------- summarize
+
+test("summarize: distilled transcript and prompt messages carry source", async () => {
+  const { store, service } = makeService();
+  const events = [];
+  const calls = [];
+  const ctx = {
+    on(name, fn) {
+      events.push({ name, fn });
+      return () => {};
+    },
+    logger,
+    llm: {
+      stream(options) {
+        calls.push(options);
+        assertMessageSources(options);
+        return reply("[]", { kind: "ok" });
+      }
+    }
+  };
+  createSummarizer(ctx, service, { autoSummarize: true });
+
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-source",
+    requestHeader: () => ({ config: { provider: "mock", model: "source-model" } }),
+    events: [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "帮我选型" }] } },
+      { seq: 2, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(calls.length, 1, "summarization called the LLM");
+  store.close();
+});
+
+// ---------------------------------------------------------------- sleep
+
+test("sleep: conflict and pattern messages carry source", async () => {
+  const { store, service } = makeService();
+  const vectorIndex = createVectorIndex({ store });
+  const embedder = {
+    embedSingle: async () => [1, 0, 0],
+    embed: async () => [1, 0, 0],
+    schedule: () => {},
+    modelHash: "mock#1",
+    dimension: 3
+  };
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vectorIndex);
+  // 冲突候选要在向量索引里真有向量（同 sleep.test.js 的 seedConflictPair）；
+  // 同时给 pattern 阶段留下 2 条素材。
+  const a = service.saveWithDedupe({ type: "project", title: "主题X", content: "内容A 关于主题X", importance: 3 }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "主题X副本", content: "内容B 关于主题X", importance: 3 }).memory;
+  vectorIndex.saveEmbedding(a.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(b.id, [1, 0, 0]);
+
+  const calls = [];
+  const ctx = {
+    logger,
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        assertMessageSources(options);
+        yield* reply("[]");
+      }
+    }
+  };
+  const config = {
+    sleepModeEnabled: true,
+    sleepIdleMinutes: 5,
+    sleepMinIntervalHours: 8,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 2,
+    sleepMaxPatternPerRun: 3
+  };
+  const result = await runSleep(ctx, service, config, logger, { embedder, vectorIndex }, null);
+
+  assert.ok(calls.some((c) => c.purpose === "sleep-conflict"), "conflict phase called the LLM");
+  assert.ok(calls.some((c) => c.purpose === "sleep-pattern"), "pattern phase called the LLM");
+  assert.ok(result.runId, "sleep run produced a receipt");
+  store.close();
+});
+
+// ---------------------------------------------------------------- entity extraction
+
+test("entity extraction: messages handed to the llm adapter carry source", async () => {
+  const { store, service } = makeService();
+  const memory = service.saveWithDedupe({ type: "project", title: "协作", content: "Alpha 与 Beta 一起干活", importance: 3 }).memory;
+
+  const calls = [];
+  const callLLM = async (messages) => {
+    calls.push(messages);
+    assertMessageSources({ messages });
+    return "[]";
+  };
+
+  await extractEntities(memory, { store, config: {}, callLLM, logger });
+
+  assert.equal(calls.length, 1, "extraction called the LLM adapter");
+  store.close();
+});

package/test/reranker-single-logit.test.js

@@ -0,0 +1,73 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { LocalReranker } from "../src/reranker.js";
+
+// 回归（issue #188）：Xenova/bge-reranker-base 是单 logit 交叉编码器——每个
+// (query, passage) 对只输出 1 个 logit。tc 策略此前在 cols===1 时把 l1 退化成
+// l0，sigmoid(l0 - l1) = sigmoid(0) = 0.5：所有候选分数恒为常量，重排静默失效
+// （不抛错、日志照常 ready、语义状态照常 reranker="ready"，只有分数是死的）。
+// 单 logit 头的正类概率是 sigmoid(logit)；sigmoid(l1 - l0) 只对双 logit 头
+// （num_labels=2 的导出，如 bge-reranker-v2-m3）成立。修复后按 cols 分支，
+// 两路各有回归；另加「分数全等 → warn 一次」的静默失效绊线。
+
+function sigmoid(x) {
+  return 1 / (1 + Math.exp(-x));
+}
+
+function candidates(ids) {
+  return ids.map((id) => ({ id, title: `T-${id}`, content: `C-${id}` }));
+}
+
+// 只支持 text-classification 的假引擎：cascade 先试 "rerank"（transformers
+// 4.2.0 无此任务，真机上也必然先失败），随后落到 tc。
+function makeTcFactory(dims, data) {
+  return async (task) => {
+    if (task === "rerank") throw new Error("unsupported task: rerank");
+    assert.equal(task, "text-classification");
+    return {
+      tokenizer: (texts, _opts) => ({ texts }),
+      model: async (inputs) => ({ logits: { dims, data: Float64Array.from(data.slice(0, inputs.texts.length * dims[1])) } })
+    };
+  };
+}
+
+test("#188: single-logit head scores sigmoid(logit) instead of constant 0.5", async () => {
+  // 报告的实测 logits：相关 -0.556、无关 -10.193，区分度近 10——模型判断得
+  // 很好，只是旧公式把它们全抹成 0.5000。
+  const r = new LocalReranker({
+    engineFactory: makeTcFactory([3, 1], [-0.5561, -10.193, 8.7])
+  });
+  await r.init();
+  const out = await r.rerank("查询", candidates(["rel", "noise", "hit"]));
+  // sigmoid(-0.5561)≈0.3645 保留；sigmoid(-10.193)≈3.7e-5 被 0.1 阈值滤掉；
+  // sigmoid(8.7)≈0.9998 居首。修复前三者全 0.5、顺序不变。
+  assert.deepEqual(out.map((x) => x.id), ["hit", "rel"]);
+  assert.ok(Math.abs(out[0].score - sigmoid(8.7)) < 1e-6, "hit = sigmoid(logit)");
+  assert.ok(Math.abs(out[1].score - sigmoid(-0.5561)) < 1e-6, "rel = sigmoid(logit)");
+  r.dispose();
+});
+
+test("#188: dual-logit head keeps softmax-positive-class semantics", async () => {
+  // l0=-2,l1=2 → sigmoid(4)；l0=1,l1=1.5 → sigmoid(0.5)——与原实现逐字节等价。
+  const r = new LocalReranker({
+    engineFactory: makeTcFactory([2, 2], [-2, 2, 1, 1.5])
+  });
+  await r.init();
+  const out = await r.rerank("查询", candidates(["a", "b"]));
+  assert.deepEqual(out.map((x) => x.id), ["a", "b"]);
+  assert.ok(Math.abs(out[0].score - sigmoid(4)) < 1e-6);
+  assert.ok(Math.abs(out[1].score - sigmoid(0.5)) < 1e-6);
+  r.dispose();
+});
+
+test("#188: constant-score batch warns once (silent-failure tripwire)", async () => {
+  const warns = [];
+  const r = new LocalReranker({
+    scorePair: async () => 0.5,
+    logger: { warn: (m) => warns.push(m), info: () => {} }
+  });
+  await r.rerank("查询", candidates(["a", "b", "c"]));
+  await r.rerank("查询", candidates(["a", "b", "c"]));
+  assert.equal(warns.length, 1, "constant-score batch warns exactly once across calls");
+  r.dispose();
+});

package/test/scope-candidates.test.js

@@ -0,0 +1,239 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runSleep } from "../src/dream/sleep.js";
+import { createDreamScheduler } from "../src/dream.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+// v0.8.1（issue #170 第 2 步）：sleep 冲突阶段的跨 scope 分流。
+// 同一内容落在两个归属下（任一维标注键不等，含「一侧未标注=全局」）时，
+// 不允许自动裁决（freeze 或 LLM）——归档败者可能销毁某归属下的唯一副本，
+// 归属裁决是用户的决定。跨 scope 对一律停车到 conflict_pending（专属 reason），
+// 同 scope 对维持既有路径。夹具为中性主题（构建笔记/编辑器主题）。
+
+const embedder = {
+  embedSingle: async () => [1, 0, 0],
+  // 契约形状：按输入条数返回等长向量数组。update 会失效缓存并调度重嵌入，
+  // sleep 的回填走 embed()——返回单向量会让回填静默失败（no usable vectors）。
+  embed: async (texts) => (Array.isArray(texts) ? texts : [texts]).map(() => [1, 0, 0]),
+  schedule: () => {},
+  modelHash: "mock#1",
+  dimension: 3
+};
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const vectorIndex = createVectorIndex({ store });
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vectorIndex);
+  return { store, service, vectorIndex };
+}
+
+function baseConfig(overrides = {}) {
+  return {
+    sleepModeEnabled: true,
+    sleepIdleMinutes: 5,
+    sleepMinIntervalHours: 8,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 10,
+    sleepMaxPatternPerRun: 3,
+    ...overrides
+  };
+}
+
+function llmCtx(captured = [], selection = { provider: "mock", model: "sleep-model" }) {
+  return {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => selection },
+    llm: {
+      async *stream(options) {
+        captured.push(options);
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        yield { type: "text-delta", index: 0, text: userText.startsWith("候选冲突") || userText.startsWith("Candidate conflicts") ? "[]" : "[]" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+function noRouteCtx() {
+  return { logger: { warn: () => {}, info: () => {} } };
+}
+
+/** 保存一对高相似记忆并预填向量。返回 [新, 旧]（updated_at DESC 序）。 */
+function savePair(service, vectorIndex, titleA, titleB, scopeA, scopeB) {
+  const a = service.saveWithDedupe({
+    type: "project", title: titleA, content: `${titleA} 的正文`,
+    ...(scopeA?.agent ? { agent_scope: scopeA.agent } : {}),
+    ...(scopeA?.workspace ? { workspace_scope: scopeA.workspace } : {})
+  }).memory;
+  const b = service.saveWithDedupe({
+    type: "project", title: titleB, content: `${titleB} 的正文`,
+    ...(scopeB?.agent ? { agent_scope: scopeB.agent } : {}),
+    ...(scopeB?.workspace ? { workspace_scope: scopeB.workspace } : {})
+  }).memory;
+  vectorIndex.saveEmbedding(a.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(b.id, [1, 0, 0]);
+  return [a, b];
+}
+
+test("freeze mode: cross-scope pair parks with the scope-candidate reason; same-scope pair keeps the plain reason", async () => {
+  const { store, service, vectorIndex } = setup();
+  // updated_at DESC 序决定贪心配对：后保存的对先配。x 对=跨 scope，y 对=同 scope。
+  const [yNew, yOld] = savePair(service, vectorIndex, "构建笔记A", "构建笔记B", { agent: "coder" }, { agent: "coder" });
+  const [xNew, xOld] = savePair(service, vectorIndex, "编辑器主题A", "编辑器主题B", { agent: "coder" }, { agent: "writer" });
+
+  const result = await runSleep(llmCtx(), service, baseConfig({ conflictFreezeEnabled: true }), { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null);
+  assert.equal(result.status, "ok");
+
+  const queue = store.listConflictPending();
+  assert.equal(queue.length, 2, "both pairs parked exactly once");
+  const crossRow = queue.find((q) => [q.memory_a, q.memory_b].includes(xNew.id));
+  const sameRow = queue.find((q) => [q.memory_a, q.memory_b].includes(yNew.id));
+  assert.ok(crossRow, "cross-scope pair must be parked");
+  assert.match(crossRow.reason, /跨作用域|cross-scope/, "cross pair carries the dedicated reason");
+  assert.ok(sameRow, "same-scope pair still parked in freeze mode");
+  assert.doesNotMatch(sameRow.reason, /跨作用域|cross-scope/, "same-scope pair keeps the plain similarity reason");
+
+  // 再跑一轮：同一对不去重不重复入队。
+  await runSleep(llmCtx(), service, baseConfig({ conflictFreezeEnabled: true }), { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null);
+  assert.equal(store.countConflictPending(), 2, "pair-level dedupe survives reruns");
+  store.close();
+});
+
+test("NULL (unlabeled) vs labeled counts as a cross-scope pair", async () => {
+  const { store, service, vectorIndex } = setup();
+  savePair(service, vectorIndex, "部署清单A", "部署清单B", {}, { agent: "coder" });
+  const result = await runSleep(llmCtx(), service, baseConfig({ conflictFreezeEnabled: true }), { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null);
+  assert.equal(result.status, "ok");
+  const queue = store.listConflictPending();
+  assert.equal(queue.length, 1);
+  assert.match(queue[0].reason, /跨作用域|cross-scope/, "global(unlabeled) copy vs scoped copy is an ownership decision");
+  store.close();
+});
+
+test("non-freeze without an LLM route: cross-scope pair still parks; nothing is auto-adjudicated", async () => {
+  const { store, service, vectorIndex } = setup();
+  const [newer, older] = savePair(service, vectorIndex, "发布流程A", "发布流程B", { agent: "coder" }, { agent: "writer" });
+  const result = await runSleep(noRouteCtx(), service, baseConfig(), { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null);
+
+  const queue = store.listConflictPending();
+  assert.equal(queue.length, 1, "cross-scope pair parks even with no LLM route");
+  assert.match(queue[0].reason, /跨作用域|cross-scope/);
+  assert.equal(store.getById(newer.id).archived, false, "no side is auto-archived");
+  assert.equal(store.getById(older.id).archived, false);
+  assert.ok(queue[0].resolved_at === undefined);
+  store.close();
+});
+
+test("reviewed pair does not re-queue until one of its sides changes (review item 4)", async () => {
+  const { store, service, vectorIndex } = setup();
+  const [newer, older] = savePair(service, vectorIndex, "备份策略A", "备份策略B", { agent: "coder" }, { agent: "writer" });
+  await runSleep(llmCtx(), service, baseConfig({ conflictFreezeEnabled: true }), { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null);
+  assert.equal(store.countConflictPending(), 1);
+
+  // 人工「保留双方」（winner=null）后，内容未变 → 下一轮不再入队。
+  const row = store.listConflictPending()[0];
+  store.resolveConflictPending(row.id, { winner: null });
+  assert.equal(store.countConflictPending(), 0);
+  const rerun = await runSleep(llmCtx(), service, baseConfig({ conflictFreezeEnabled: true }), { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null);
+  assert.equal(store.countConflictPending(), 0, "unchanged reviewed pair must stay dismissed");
+  assert.equal(rerun.status, "noop", "suppressed parks count as noop");
+
+  // 任一侧被改过（updated_at 晚于裁决）→ 重新入队（新决策）。
+  // 留出真实时间间隔：updated_at/resolved_at 都是毫秒精度，同毫秒内
+  // 「裁决后立即修改」会算作未变（生产中人为修改不可能同毫秒）。
+  await new Promise((resolve) => setTimeout(resolve, 5));
+  service.update(newer.id, { content: "备份策略A 的正文（改）" });
+  await runSleep(llmCtx(), service, baseConfig({ conflictFreezeEnabled: true }), { warn: () => {}, info: () => {} }, { embedder, vectorIndex }, null);
+  assert.equal(store.countConflictPending(), 1, "changed pair is worth a fresh review");
+  store.close();
+});
+
+test("dream (non-freeze): cross-scope conflict parks for review instead of being adjudicated (review item 3)", async () => {
+  const { store, service } = setup();
+  const w = service.saveWithDedupe({ type: "decision", title: "发布时间", content: "8月20日", importance: 4, agent_scope: "coder", agent_scope_source: "explicit" }).memory;
+  const l = service.saveWithDedupe({ type: "decision", title: "发布时间旧", content: "8月15日", importance: 4, agent_scope: "writer", agent_scope_source: "explicit" }).memory;
+  const ctx = {
+    llm: { stream: async function* () {
+      yield { type: "text-delta", text: JSON.stringify([{ action: "conflict", winner: w.id, loser: l.id, reason: "日期更新" }]) };
+      yield { type: "finish", reason: { kind: "ok" } };
+    } },
+    logger: { warn: () => {}, info: () => {} }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "mock", dreamModel: "mock-chat" });
+  assert.equal(result.ok, true);
+  assert.equal(result.applied, 0, "cross-scope conflict is NOT auto-adjudicated");
+  assert.equal(result.frozen, 1, "parked pair shows up in the run summary");
+  const pending = store.listConflictPending();
+  assert.equal(pending.length, 1);
+  assert.match(pending[0].reason, /跨作用域|cross-scope/, "dedicated reason");
+  assert.equal(store.getById(l.id).archived, false, "loser NOT archived");
+  assert.ok(!store.getById(w.id).content.includes("已否决旧信息"), "winner untouched");
+  store.close();
+});
+
+test("dream (non-freeze): same-scope conflict is still auto-adjudicated (regression)", async () => {
+  const { store, service } = setup();
+  const w = service.saveWithDedupe({ type: "decision", title: "发布时间", content: "8月20日", importance: 4, agent_scope: "coder", agent_scope_source: "explicit" }).memory;
+  const l = service.saveWithDedupe({ type: "decision", title: "发布时间旧", content: "8月15日", importance: 4, agent_scope: "coder", agent_scope_source: "explicit" }).memory;
+  const ctx = {
+    llm: { stream: async function* () {
+      yield { type: "text-delta", text: JSON.stringify([{ action: "conflict", winner: w.id, loser: l.id, reason: "日期更新" }]) };
+      yield { type: "finish", reason: { kind: "ok" } };
+    } },
+    logger: { warn: () => {}, info: () => {} }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "mock", dreamModel: "mock-chat" });
+  assert.equal(result.ok, true);
+  assert.equal(result.applied, 1, "same-scope conflict adjudicated as before");
+  assert.equal(result.frozen, 0);
+  assert.equal(store.listConflictPending().length, 0);
+  assert.equal(store.getById(l.id).archived, true);
+  store.close();
+});
+
+test("non-freeze with an LLM: cross-scope pair bypasses adjudication; same-scope pair is adjudicated", async () => {
+  const { store, service, vectorIndex } = setup();
+  const [yNew, yOld] = savePair(service, vectorIndex, "缓存策略A", "缓存策略B", { agent: "coder" }, { agent: "coder" });
+  const [xNew, xOld] = savePair(service, vectorIndex, "编辑器主题A", "编辑器主题B", { agent: "coder" }, { agent: "writer" });
+
+  const captured = [];
+  const ctx = llmCtx(captured);
+  // 同 scope 对由 LLM 裁决：保留 yNew、归档 yOld。跨 scope 对绝不进 prompt。
+  ctx.llm.stream = async function* (options) {
+    captured.push(options);
+    const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+    const isConflictPass = userText.startsWith("候选冲突") || userText.startsWith("Candidate conflicts");
+    const text = isConflictPass
+      ? JSON.stringify([{ action: "conflict", winner: yNew.id, loser: yOld.id, reason: "同归属重复" }])
+      : "[]";
+    yield { type: "text-delta", index: 0, text };
+    yield { type: "finish", reason: { kind: "stop" } };
+  };
+
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.status, "ok");
+
+  const conflictPassTexts = captured
+    .map((o) => o.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "")
+    .filter((t) => t.startsWith("候选冲突") || t.startsWith("Candidate conflicts"));
+  assert.ok(conflictPassTexts.length >= 1, "conflict pass ran for the same-scope pair");
+  for (const t of conflictPassTexts) {
+    assert.ok(!t.includes(xNew.id) && !t.includes(xOld.id), "cross-scope pair must never enter the LLM prompt");
+    assert.ok(t.includes(yNew.id) && t.includes(yOld.id), "same-scope pair is adjudicated");
+  }
+
+  const queue = store.listConflictPending();
+  assert.equal(queue.length, 1);
+  assert.match(queue[0].reason, /跨作用域|cross-scope/);
+  assert.equal(store.getById(xOld.id).archived, false, "cross-scope loser is NOT archived by the LLM");
+  assert.equal(store.getById(yOld.id).archived, true, "same-scope loser is adjudicated as usual");
+  store.close();
+});