@modusensus/dsh-mneme 0.9.4 → 0.10.0

package/test/conflict-reviewed.test.js

@@ -0,0 +1,79 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+
+// Issue #529（B 项）：冲突裁决台账（conflict_reviewed）的存储层契约。
+//
+// 为什么单开一张表而不是复用 conflict_pending：后者是**人工**队列——面板徽标数
+// 就是 countConflictPending()（resolved_at IS NULL 的行数），机器每判一对就写一行
+// 会把那个数字淹掉，人再也看不出"有哪些待我裁决"。台账是机器记账，零用户界面。
+//
+// 这些用例锁三件事，防的回归是：
+//   ① pair 键不归一化 → 同一对（A,B）与（B,A）会记成两行，下一轮照样重送；
+//   ② 重复记账不是幂等 upsert → 同一对判过 N 次就堆 N 行，表无界增长；
+//   ③ 记账误落 conflict_pending → 人工队列被机器行淹没（这是最贵的一种）。
+
+test("issue#529 conflict_reviewed：写入后可读回，键归一化为 (a,b)", () => {
+  const store = createStore(":memory:");
+  store.saveConflictReviewed({
+    run_id: "run-1",
+    memory_a: "b-id",
+    memory_b: "a-id",
+    outcome: "conflict",
+    judged_at: "2026-10-31T00:00:00.000Z"
+  });
+  const all = store.loadConflictReviewed();
+  assert.equal(all.size, 1, "只落一行");
+  const key = [...all.keys()][0];
+  assert.equal(key, "a-id\u0000b-id", "键按字典序归一化——反着传也是同一个键");
+  const row = all.get(key);
+  assert.equal(row.outcome, "conflict");
+  assert.equal(row.run_id, "run-1");
+  assert.equal(row.judged_at, "2026-10-31T00:00:00.000Z");
+  store.close();
+});
+
+test("issue#529 conflict_reviewed：同一对重复记账是 upsert，不堆行", () => {
+  const store = createStore(":memory:");
+  for (let i = 0; i < 3; i++) {
+    store.saveConflictReviewed({
+      run_id: "run-" + i,
+      memory_a: "a-id",
+      memory_b: "b-id",
+      outcome: "keep",
+      judged_at: "2026-10-31T00:00:0" + i + ".000Z"
+    });
+  }
+  const all = store.loadConflictReviewed();
+  assert.equal(all.size, 1, "同一对只留一行");
+  assert.equal(all.get("a-id\u0000b-id").run_id, "run-2", "后写的覆盖先写的");
+  assert.equal(all.get("a-id\u0000b-id").judged_at, "2026-10-31T00:00:02.000Z");
+  store.close();
+});
+
+test("issue#529 conflict_reviewed：记账不进人工待裁决队列", () => {
+  const store = createStore(":memory:");
+  for (let i = 0; i < 5; i++) {
+    store.saveConflictReviewed({
+      run_id: "run-" + i,
+      memory_a: "a-" + i,
+      memory_b: "b-" + i,
+      outcome: "keep",
+      judged_at: "2026-10-31T00:00:00.000Z"
+    });
+  }
+  assert.equal(store.countConflictPending(), 0, "关键：机器记账不涨人工队列的徽标数");
+  assert.deepEqual(store.listConflictPending(), []);
+  assert.equal(store.listConflictReviewed().length, 5, "但台账里确实有 5 行");
+  store.close();
+});
+
+test("issue#529 conflict_reviewed：listConflictReviewed 按判时倒序", () => {
+  const store = createStore(":memory:");
+  store.saveConflictReviewed({ memory_a: "a", memory_b: "b", outcome: "keep", judged_at: "2026-10-30T00:00:00.000Z", run_id: "r1" });
+  store.saveConflictReviewed({ memory_a: "c", memory_b: "d", outcome: "conflict", judged_at: "2026-10-31T00:00:00.000Z", run_id: "r2" });
+  const rows = store.listConflictReviewed();
+  assert.equal(rows[0].judged_at, "2026-10-31T00:00:00.000Z", "最新的在前");
+  assert.equal(rows[1].judged_at, "2026-10-30T00:00:00.000Z");
+  store.close();
+});

package/test/continuity.test.js

@@ -7,6 +7,7 @@ import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createTools } from "../src/tools.js";
 import { Config, applyLightModePreset, injectChildEnabled } from "../src/config.js";
+import { createSessionGate } from "../src/session-gate.js";
 import {
   CONTINUITY_KIND,
   CONTINUITY_NOTICE_PREFIX,
@@ -272,7 +273,7 @@ test("#249 N3：门控不调模型（静态锁）与挂载点的父开关在前"
   // 只剩 Config 里的默认值撑着，接线漏一次没人发现。
   const index = readFileSync(new URL("../src/index.js", import.meta.url), "utf8");
   assert.match(index, /if \(cfg\.autoInject && injectChildEnabled\(cfg, "continuityRescueEnabled"\)\) \{/);
-  assert.match(index, /disposers\.push\(createContinuityRescue\(ctx, store\)\)/);
+  assert.match(index, /disposers\.push\(createContinuityRescue\(ctx, store, sessionGate\)\)/);
 });
 
 test("#249 N3：reject 放行且不消费边缘；缺 session 不抛", async () => {
@@ -295,6 +296,33 @@ test("#249 N3：reject 放行且不消费边缘；缺 session 不抛", async ()
   rescue.dispose();
 });
 
+test("#539：等待 pre-step 期间切到无痕会清除先前边缘，不落提案也不注入", async () => {
+  const store = createStore(":memory:");
+  const ctx = mockCtx();
+  const config = { sessionGateEnabled: false, sessionGateSessions: ["s1"] };
+  const gate = createSessionGate(config);
+  const rescue = createContinuityRescue(ctx, store, gate);
+  const session = fakeSession("s1", [userEvent(1, "私有指令")]);
+
+  ctx.fire("session/event", session, { type: "compaction/end", seq: 7 });
+  const decision = await ctx.fire(
+    "agent/pre-step",
+    { agent: { session } },
+    async () => {
+      config.sessionGateEnabled = true;
+      await Promise.resolve();
+      return { kind: "enter", messages: [] };
+    }
+  );
+  assert.deepEqual(decision.messages, []);
+  assert.equal(store.getContinuityProposal("s1", KIND), null);
+
+  config.sessionGateEnabled = false;
+  const next = await ctx.fire("agent/pre-step", { agent: { session } }, async () => ({ kind: "enter", messages: [] }));
+  assert.deepEqual(next.messages, [], "a stale edge from before the toggle is not consumed later");
+  rescue.dispose();
+});
+
 test("#249 N3：契约——默认关、父关不生效、轻量档压掉、降级规则只在开启时进描述", () => {
   assert.equal(Config({}).continuityRescueEnabled, false, "新增注入表面 → opt-in 默认关");
   assert.equal(applyLightModePreset({ lightMode: true }).continuityRescueEnabled, false, "轻量档压掉（同 injectGuidanceEnabled）");

package/test/dedupe-candidate-window.test.js

@@ -0,0 +1,180 @@
+// Issue #505：saveWithDedupe 的去重候选窗口固定 100 条，库一变大就静默不再合并。
+//
+// 根因：候选集是 store.list({ type, limit: 100 })，order 默认 importance
+// ⇒「该类型最重要的 100 行」，与「找出同标题的那一行」无关。某类型里 importance
+// 高于待写行的行数一旦超过窗口，同标题行与待写行双双落在窗口外，find 恒不命中，
+// 于是走创建分支：不报错、不告警，合并语义随库增长而失效。
+//
+// 这组用例刻意复刻报告里的实测形状（类型 1047 行、其中 importance=5 有 180 行），
+// 但用更小的数字达成同样的窗口溢出，避免测试本身变慢。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+function freshService() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+// 往某个类型里灌 n 条 importance=5 的行，把窗口挤满。
+function crowdType(store, type, n) {
+  for (let i = 0; i < n; i++) {
+    store.save({
+      type,
+      title: `crowd-${type}-${i}`,
+      content: `padding row ${i}`,
+      importance: 5
+    });
+  }
+}
+
+test("#505: 同类型 importance 更高的行超过窗口后，同标题第二次写入仍然合并", () => {
+  const { store, service } = freshService();
+  // 窗口是 100。灌 120 条 importance=5，保证待写行（importance=3）与它的同标题
+  // 行都排不进前 100。
+  crowdType(store, "project", 120);
+
+  const payload = {
+    type: "project",
+    title: "dedupe-target",
+    content: "first content",
+    importance: 3
+  };
+  const first = service.saveWithDedupe(payload);
+  assert.equal(first.action, "created", "第一次写入应当是新建");
+
+  const second = service.saveWithDedupe({ ...payload, content: "second content" });
+  assert.equal(
+    second.action,
+    "merged",
+    "第二次同标题写入必须并入已有行；返回 created 说明候选窗口把同标题行挡在窗口外（#505 静默降级）"
+  );
+  assert.equal(second.memory.id, first.memory.id, "合并必须落在同一行");
+
+  const rows = store.list({ type: "project", limit: null })
+    .filter((m) => m.title.trim() === "dedupe-target");
+  assert.equal(rows.length, 1, "同标题只应存在一行");
+});
+
+test("#505: 定向候选不受 importance 分布影响（低 importance 的同标题行也能命中）", () => {
+  const { store, service } = freshService();
+  // 先写一条 importance=1 的目标行，再用大量 importance=5 的行把它挤出窗口。
+  const first = service.saveWithDedupe({
+    type: "pattern",
+    title: "low-importance-target",
+    content: "seed",
+    importance: 1
+  });
+  assert.equal(first.action, "created");
+
+  crowdType(store, "pattern", 120);
+
+  const second = service.saveWithDedupe({
+    type: "pattern",
+    title: "low-importance-target",
+    content: "merged later",
+    importance: 1
+  });
+  assert.equal(second.action, "merged", "低 importance 的同标题行同样必须能被找到");
+  assert.equal(second.memory.id, first.memory.id);
+});
+
+test("#505: 标题首尾空白不影响去重命中（入库不 trim，比较 trim）", () => {
+  const { store, service } = freshService();
+  crowdType(store, "constraint", 120);
+
+  const first = service.saveWithDedupe({
+    type: "constraint",
+    title: "  spaced title  ",
+    content: "seed",
+    importance: 3
+  });
+  assert.equal(first.action, "created");
+
+  // 同一个标题、首尾空白写法不同——按 trim 口径应当命中同一行。
+  const second = service.saveWithDedupe({
+    type: "constraint",
+    title: "spaced title",
+    content: "merged",
+    importance: 3
+  });
+  assert.equal(second.action, "merged", "trim 后同标题必须合并，否则存量带空白的标题会退回静默降级");
+  assert.equal(second.memory.id, first.memory.id);
+});
+
+test("#505: 定向候选不跨类型命中", () => {
+  const { store, service } = freshService();
+  crowdType(store, "project", 120);
+
+  const a = service.saveWithDedupe({
+    type: "project",
+    title: "same-title-different-type",
+    content: "in project",
+    importance: 3
+  });
+  const b = service.saveWithDedupe({
+    type: "preference",
+    title: "same-title-different-type",
+    content: "in preference",
+    importance: 3
+  });
+  assert.equal(a.action, "created");
+  assert.equal(b.action, "created", "不同 type 的同标题行不得合并");
+  assert.notEqual(a.memory.id, b.memory.id);
+});
+
+test("#505: 归档行不作为合并目标（口径与 list 默认一致）", () => {
+  const { store, service } = freshService();
+  crowdType(store, "decision", 120);
+
+  const first = service.saveWithDedupe({
+    type: "decision",
+    title: "archived-target",
+    content: "seed",
+    importance: 3
+  });
+  // 归档必须走 store.setArchived——store.update 的 SET 子句里没有 archived 列，
+  // 用 update({archived:true}) 根本不会归档，测试会假绿。
+  store.setArchived(first.memory.id, true);
+
+  const second = service.saveWithDedupe({
+    type: "decision",
+    title: "archived-target",
+    content: "after archive",
+    importance: 3
+  });
+  assert.equal(second.action, "created", "已归档行不该被当作活跃合并目标");
+  assert.notEqual(second.memory.id, first.memory.id);
+});
+
+
+// #505 把「取该类型前 100 条」换成「按 type + TRIM(title) 精确取」：窗口没了、静默不
+// 合并也没了，但 SQL 形状变了——代价随最大类型的行数线性长（20000 行时 4.6ms 一次，
+// 每存一条付一次），所以 store.js 里配了 (type, TRIM(title)) 表达式索引。这条用例不测
+// 快慢（机器有关节，数字不可复现），测的是**那条索引真的被这条查询选中**：表达式写歪
+// 一点（漏 TRIM、列序不对）优化器就静默退回扫整个类型，而本文件其余用例全绿。
+test("#505: 定向候选那条 SQL 命中表达式索引，而不是扫完整个类型", () => {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-dedupe-idx-"));
+  const file = join(dir, "m.db");
+  const store = createStore(file);
+  store.save({ type: "project", title: "  spaced  ", content: "x", importance: 3 });
+  store.close();
+  const db = new DatabaseSync(file);
+  try {
+    // WHERE 与 store.js 的 activeByTypeAndTitle 逐字同形，只把列表换成单列。
+    const plan = db.prepare(
+      "EXPLAIN QUERY PLAN SELECT id FROM memories WHERE type = ? AND TRIM(title) = ? AND forgotten = 0 AND archived = 0"
+    ).all("project", "spaced").map((r) => r.detail).join(" ");
+    assert.match(plan, /idx_memories_type_trimmed_title/,
+      `定向候选必须走 (type, TRIM(title)) 表达式索引，实得：${plan}`);
+  } finally {
+    db.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/test/dependency-overrides.test.js

@@ -0,0 +1,78 @@
+// 两个 overrides 存在的唯一理由是 osv-scanner 的红灯，而红灯的判据是**已提交的
+// lockfile**——所以这里锁的是 lockfile 的解析结果，不是 node_modules 里装了什么。
+// 2026-10-31 的现场：同一条 lockfile 在 08:36 是绿的，04:42 那次 push 却是红的，
+// 中间没有任何依赖变更——上游在 23:09 发了两条新公告（glob 超时后仍继续遍历、
+// minimatch globparts 放大 DoS）。换句话说，这个文件里的断言会**因为上游多一条公告
+// 而变红**，那是它应该做的事：红在本地，比红在 main 上便宜。
+//
+// 依赖链只有一条，且全部是 devDependency：
+//   c8@12 → test-exclude@8 → glob + minimatch
+// 两个上游包都已经是 npm 上的最新版、其 deps 仍写旧范围，所以只能在本仓库抬 pin。
+// 一旦上游跟上、这条链不再解析到旧版本，下面的 overrides 断言就会失败——那时应当
+// 删掉这两条 overrides，而不是把断言删掉。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const pkg = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
+const lock = JSON.parse(readFileSync(join(PKG_ROOT, "package-lock.json"), "utf8"));
+
+// 公告给出的修复下限。低于它 = osv-scanner 会在 main 上红，这里先红。
+const FLOORS = {
+  glob: { fixed: [14, 0, 2], cve: "CVE-2026-118773 / GHSA-3g3m-2fjr-6pw4" },
+  minimatch: { fixed: [11, 0, 1], cve: "CVE-2026-118764 / GHSA-g3hv-75wg-m249" },
+};
+
+function parseVersion(v) {
+  return String(v).split(/[.+-]/).slice(0, 3).map((n) => Number.parseInt(n, 10) || 0);
+}
+
+function gte(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] > b[i];
+  }
+  return true;
+}
+
+test("glob 与 minimatch 在 lockfile 里都解析到公告的修复下限之上", () => {
+  for (const [name, { fixed, cve }] of Object.entries(FLOORS)) {
+    const entry = lock.packages[`node_modules/${name}`];
+    assert.ok(entry, `lockfile 里应当有 node_modules/${name}`);
+    const actual = parseVersion(entry.version);
+    assert.ok(
+      gte(actual, fixed),
+      `${name} 解析成 ${entry.version}，低于 ${cve} 的修复下限 ${fixed.join(".")}——osv-scanner 会在 main 上红`,
+    );
+  }
+});
+
+// overrides 必须是**精确版本**，不能是 ^ / ~ 范围。
+// 范围等于把选择权交回解析器：下一次上游发版，lockfile 会在某个「只更新 lockfile」
+// 的 PR 里悄悄漂走，而红绿灯本该由人决定。brace-expansion 那次（PR #345）就是精确号。
+test("overrides 是精确版本号，不是范围", () => {
+  for (const name of Object.keys(FLOORS)) {
+    const pin = pkg.overrides?.[name];
+    assert.equal(typeof pin, "string", `package.json overrides 里应当钉住 ${name}`);
+    assert.ok(
+      /^\d+\.\d+\.\d+$/.test(pin),
+      `${name} 的 override 应写精确版本（如 14.0.3），实际是 ${JSON.stringify(pin)}`,
+    );
+  }
+});
+
+// 钉版本是权宜之计，不是永久配置：这条链还在（c8 → test-exclude → glob）就说明
+// 上游仍会解析到旧范围，overrides 必须留着。上游哪天收了，这条会红，提示来删 pin。
+test("devDependency 链仍在：c8 → test-exclude → glob", () => {
+  const c8 = lock.packages["node_modules/c8"];
+  assert.ok(c8, "lockfile 里应当有 c8");
+  assert.ok(c8.dependencies?.["test-exclude"], "c8 仍应依赖 test-exclude");
+  const testExclude = lock.packages["node_modules/test-exclude"];
+  assert.ok(testExclude, "lockfile 里应当有 test-exclude");
+  assert.ok(
+    testExclude.dependencies?.glob,
+    "test-exclude 仍应依赖 glob——它一旦不再依赖，glob/minimatch 两条 overrides 就可以删了",
+  );
+});

package/test/differentiate-feedback.test.js

@@ -0,0 +1,248 @@
+// Issue #533：differentiate 的正反馈死循环回归护栏。
+//
+// 现象（issue #533 实测）：sleepActionSet="full" 下，一对高相似记忆被判成
+// differentiate，旧实现把**同一段**差异注记同时追加到两侧正文，指望"注记进
+// embedding 后下一轮不再判重复"。离线复现证明恰好相反——两侧共享同一段后缀会让
+// 向量同向靠拢（0.876 → 0.960 只用 5 轮，把注记截到 0 字照样往上爬，因为推高相似
+// 度的是共享前缀本身而不是注记长短），于是下一轮又被判重复、又追加一段，实测单条
+// 堆到 19 段、正文 150 字膨胀到 2200+ 字。
+//
+// 现在的契约：differentiate **不改正文**，裁决落 differentiated_pairs 账本；候选
+// 构造阶段读账本，已裁决且两侧正文未变就不送模型。本文件锁的就是这两件事——
+// 「正文不变」和「第二轮不再花钱」。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { applyDecisions, validateDecisions } from "../src/dream/decisions.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+import { runSleep } from "../src/dream/sleep.js";
+
+const embedder = {
+  // 批量接口要按输入条数返回（向量回填走这一条），返回单个向量会让 usable 判空。
+  embedSingle: async () => [1, 0, 0],
+  embed: async (texts) => (Array.isArray(texts) ? texts.map(() => [1, 0, 0]) : [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 makeMemory(service, title, content, type = "project") {
+  return service.saveWithDedupe({ type, title, content, importance: 3 }).memory;
+}
+
+function snapshotOf(store, ...mems) {
+  return new Map(mems.map((m) => [m.id, store.getById(m.id)]));
+}
+
+function captureCtx(reply) {
+  const seen = [];
+  return {
+    seen,
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream(options) {
+        seen.push(options.messages.find((m) => m.system ?? m.role === "system")?.content?.[0]?.text ?? "");
+        yield { type: "text-delta", index: 0, text: typeof reply === "function" ? reply() : reply };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+function baseConfig(overrides = {}) {
+  return {
+    sleepModeEnabled: true,
+    sleepIdleMinutes: 5,
+    sleepMinIntervalHours: 8,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 100,
+    sleepMaxPatternPerRun: 3,
+    ...overrides
+  };
+}
+
+function seedPair(service, vectorIndex, t1, t2, sim = 1.0) {
+  const a = makeMemory(service, t1, `${t1} 的内容`);
+  const b = makeMemory(service, t2, `${t2} 的内容`);
+  const sin = Math.sqrt(Math.max(0, 1 - sim * sim));
+  vectorIndex.saveEmbedding(a.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(b.id, [sim, sin, 0]);
+  return { a, b };
+}
+
+// ---------------------------------------------------------------- 正文不变
+
+test("issue#533: repeated differentiate with drifting wording never grows the bodies", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "内网 SSH 端口", "内网走 22");
+  const b = makeMemory(service, "外网 SSH 端口", "外网映射 2222");
+  const before = { [a.id]: service.getById(a.id).content, [b.id]: service.getById(b.id).content };
+  // 模型每轮换一种说法——这正是字面 includes 幂等失效的场景，也是 issue 里单条堆到
+  // 19 段的真实成因。账本口径下措辞漂移不再产生任何正文副作用。
+  const wordings = [
+    ["内网直连", "外网映射"],
+    ["走内网", "走外网映射"],
+    ["内网那台直连", "外网那台做映射"],
+    ["内网的机器直连", "外网的机器走映射"],
+    ["内网直连（22）", "外网映射（2222）"]
+  ];
+  let appliedRounds = 0;
+  for (const distinctions of wordings) {
+    const snapshot = snapshotOf(store, service.getById(a.id), service.getById(b.id));
+    const { applied } = applyDecisions(
+      [{ action: "differentiate", ids: [a.id, b.id], distinctions }],
+      service, null, snapshot, {}
+    );
+    appliedRounds += applied;
+  }
+  assert.equal(appliedRounds, 1, "only the first round is a real verdict; the rest are idempotent");
+  // 这一条是 #533 的核心断言：无论判多少轮，正文长度一个字节都不许变。
+  assert.equal(service.getById(a.id).content, before[a.id], "side A body is byte-identical");
+  assert.equal(service.getById(b.id).content, before[b.id], "side B body is byte-identical");
+  assert.equal(service.getById(a.id).content.length, "内网走 22".length, "no note accumulates");
+  store.close();
+});
+
+test("issue#533: the ledger keeps one row per pair and refreshes the distinctions", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "甲", "内容甲");
+  const b = makeMemory(service, "乙", "内容乙");
+  for (const distinctions of [["第一版"], ["第二版", "补充版"]]) {
+    applyDecisions(
+      [{ action: "differentiate", ids: [a.id, b.id], distinctions }],
+      service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+    );
+  }
+  // 顺序归一：不管送审时谁在前，账本只有一行。
+  assert.equal(store.listDifferentiatedPairs().length, 1, "one pair, one row");
+  const record = service.findDifferentiatedPair(b.id, a.id);
+  assert.deepEqual(record.distinctions, ["第一版"], "an unchanged body keeps the original verdict");
+  store.close();
+});
+
+// -------------------------------------------------------------- 三层幂等
+
+test("issue#533: a body edited after the verdict re-opens the pair", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "甲", "内容甲");
+  const b = makeMemory(service, "乙", "内容乙");
+  applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  // 原样重放 → 幂等。
+  const replay = applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  assert.equal(replay.applied, 0, "an unchanged pair is idempotent");
+  // 一侧被改写 → 结论可能不再成立，必须能重新裁决（宁可再判一次，不静音真的演化）。
+  service.update(a.id, { content: "内容甲被改写" });
+  const reopened = applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面", "改写后"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  assert.equal(reopened.applied, 1, "an edited side re-opens the pair");
+  assert.deepEqual(
+    service.findDifferentiatedPair(a.id, b.id).distinctions, ["甲面", "乙面", "改写后"],
+    "the refreshed verdict replaces the stale one"
+  );
+  store.close();
+});
+
+test("issue#533: legacy rows that still carry the old note are treated as adjudicated", () => {
+  const { service, store } = setup();
+  // 旧版本写进正文的注记块原样造出来（升级不清账：这些行没有账本行）。
+  const a = makeMemory(service, "甲", "内容甲\n\n（差异注记：甲面；乙面）");
+  const b = makeMemory(service, "乙", "内容乙\n\n（差异注记：甲面；乙面）");
+  const { applied } = applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  assert.equal(applied, 0, "no ledger row is needed once both sides carry the note");
+  assert.equal(service.getById(a.id).content, "内容甲\n\n（差异注记：甲面；乙面）", "the legacy body is untouched");
+  store.close();
+});
+
+test("issue#533: a bare service without the ledger degrades to skipped, never throws", () => {
+  // 人工确认路径（service.js 的裸 applyService）没有账本透传——此时「正文不变」本身
+  // 就是全部副作用，没有账本就没有可写之处，只能是 skipped，不能算 applied。
+  const mems = new Map();
+  const bare = {
+    getById: (id) => mems.get(id) ?? null,
+    update: (id, patch) => { mems.set(id, { ...mems.get(id), ...patch }); },
+    setArchived: () => {},
+    transaction: (fn) => fn()
+  };
+  mems.set("a", { id: "a", title: "甲", content: "内容甲", archived: false });
+  mems.set("b", { id: "b", title: "乙", content: "内容乙", archived: false });
+  const { applied, failures } = applyDecisions(
+    [{ action: "differentiate", ids: ["a", "b"], distinctions: ["甲面", "乙面"] }],
+    bare, null, null, {}
+  );
+  assert.equal(applied, 0, "nothing to record, nothing applied");
+  assert.equal(failures.length, 0, "degrades cleanly");
+  assert.equal(mems.get("a").content, "内容甲", "still never touches the body");
+});
+
+// ------------------------------------------------------- 候选构造阶段抑制
+
+test("issue#533: a second sleep cycle does not pay for an already-adjudicated pair", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "甲端口", "乙端口");
+  const reply = () => JSON.stringify([
+    { action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }
+  ]);
+  const ctx1 = captureCtx(reply);
+  const first = await runSleep(ctx1, service, baseConfig({ sleepActionSet: "full" }), ctx1.logger, { embedder, vectorIndex }, null);
+  assert.equal(first.phases.conflicts.applied, 1, "the first cycle adjudicates the pair");
+  const callsAfterFirst = ctx1.seen.length;
+  assert.ok(service.findDifferentiatedPair(a.id, b.id), "the verdict landed in the ledger");
+
+  // 第二轮：同一对、同一相似度，账本命中且两侧正文未变 → 候选在送 LLM 之前就被压掉。
+  const ctx2 = captureCtx(reply);
+  const second = await runSleep(ctx2, service, baseConfig({ sleepActionSet: "full" }), ctx2.logger, { embedder, vectorIndex }, null);
+  assert.equal(second.phases.conflicts.status, "noop", "the phase has nothing left to adjudicate");
+  assert.equal(second.phases.conflicts.suppressed, 1, "the pair is accounted for, not silently dropped");
+  // 只数冲突阶段那次调用：patterns 阶段与本题无关，别把它的调用算进来。
+  assert.equal(ctx2.seen.filter((p) => p.includes("冲突仲裁")).length, 0,
+    "no LLM call is made for a settled pair");
+
+  // 但这不等于「永远不再判」：一侧被改写后必须重新回到候选里。
+  service.update(a.id, { content: "甲端口 的内容被改写" });
+  const ctx3 = captureCtx(reply);
+  const third = await runSleep(ctx3, service, baseConfig({ sleepActionSet: "full" }), ctx3.logger, { embedder, vectorIndex }, null);
+  assert.ok(ctx3.seen.some((p) => p.includes("冲突仲裁")), "an edited pair is re-sent to the model");
+  assert.ok(third.phases.conflicts, "the phase still runs");
+  store.close();
+});
+
+test("issue#533: the audit row reports suppressed separately from 'no conflicts found'", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "甲端口", "乙端口");
+  // 先手工记一笔账（正文与相似度都没变），第二轮应报 noop + suppressed。
+  applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }],
+    service, null, snapshotOf(store, service.getById(a.id), service.getById(b.id)), {}
+  );
+  const ctx = captureCtx(JSON.stringify([]));
+  const result = await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.status, "noop");
+  assert.equal(result.phases.conflicts.reason, "all candidate pairs already differentiated");
+  assert.equal(result.phases.conflicts.suppressed, 1);
+  assert.equal(result.phases.conflicts.pairs, undefined, "no pair is reported as pending work");
+  store.close();
+});

package/test/dream-candidate-hybrid.test.js

@@ -39,8 +39,8 @@ function seed(service, vectorIndex, title, vec) {
 }
 
 /** Capture the candidate titles the LLM was handed. */
-// 注意：不能用 helpers 的 mockCtx —— 它靠 userText.startsWith("id=") 区分阶段，而
-// semantic 可用时候选列表以「# 聚类 N」开头（语义预分组），会被误判成 summary。
+// 注：helpers 的 mockCtx 过去靠 userText.startsWith("id=") 区分阶段，semantic 预分组把清单
+// 头换成「# 聚类 N」就误判成 summary；#501/#493 把它的判据换成了清单形状（includes("| type=")），
 // 这里改用 system prompt 判定，与 listText 的形态解耦。
 function stubCtx(consolidationReply) {
   const seen = { titles: [] };