@modusensus/dsh-mneme 0.7.30 → 0.7.32

package/test/runtime-verify.test.js

@@ -0,0 +1,214 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_PROBE_TEXTS, defaultEngine, verifyFunctional, verifyPayload } from "../src/runtime/verify.js";
+import { TRANSFORMERS_ENTRY } from "../src/runtime/layout.js";
+import { pathToFileURL } from "node:url";
+
+// 验证三件套（issue #131 / PR-A）。重点不是「能跑通」，而是「坏的那几种能被抓住」：
+// 结构对但原生二进制与本机不匹配、返回非归一化向量、向量退化、加载直接抛——
+// 这些都必须变成一条可读的失败结论，而不是让调用方拿到一个假的 ok。
+
+/** 造一个结构上合法的 payload（只有形状，没有真东西）。 */
+function makePayload({ platform = "win32", arch = "x64", withEntry = true } = {}) {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-verify-"));
+  const write = (rel, body) => {
+    const full = join(dir, rel);
+    mkdirSync(join(full, ".."), { recursive: true });
+    writeFileSync(full, body);
+  };
+  for (const name of ["@huggingface/transformers", "onnxruntime-node", "sharp"]) {
+    write(join("node_modules", name, "package.json"), JSON.stringify({ name, version: name === "@huggingface/transformers" ? "4.2.0" : "1.0.0" }));
+  }
+  if (withEntry) write(TRANSFORMERS_ENTRY, "export const x = 1;\n");
+  mkdirSync(join(dir, "node_modules", "onnxruntime-node", "bin", "napi-v6", platform, arch), { recursive: true });
+  return dir;
+}
+
+/** 归一化的假向量：`rows` 行，每行 dim 维，方向由 seed 决定。 */
+function fakeRows(rows, dim, seed = 0) {
+  return Array.from({ length: rows }, (_, r) => {
+    const v = Array.from({ length: dim }, (_, i) => Math.sin((i + 1) * (r + 1 + seed)));
+    const length = Math.hypot(...v);
+    return v.map((x) => x / length);
+  });
+}
+
+/** 注入一个「什么都能返回」的 engine。 */
+function engineReturning(value) {
+  return async () => async () => value;
+}
+
+test("功能验证：正常的向量通过，并报出维度与耗时", async () => {
+  const result = await verifyFunctional("/whatever", { engine: engineReturning(fakeRows(2, 512)) });
+  assert.equal(result.ok, true, result.reason);
+  assert.equal(result.dim, 512);
+  assert.equal(result.rows, 2);
+  assert.ok(result.elapsedMs >= 0);
+});
+
+test("功能验证：行数不符要报出来（而不是只取第一行当作通过）", async () => {
+  const result = await verifyFunctional("/whatever", { engine: engineReturning(fakeRows(1, 512)) });
+  assert.equal(result.ok, false);
+  assert.match(result.reason, /返回行数不符/);
+});
+
+test("功能验证：非归一化向量要报出来（说明 normalize 没生效）", async () => {
+  const rows = fakeRows(2, 8).map((row) => row.map((x) => x * 3));
+  const result = await verifyFunctional("/whatever", { engine: engineReturning(rows) });
+  assert.equal(result.ok, false);
+  assert.match(result.reason, /不是 L2 归一化/);
+});
+
+test("功能验证：向量退化成同一方向要报出来", async () => {
+  const one = fakeRows(1, 16)[0];
+  const result = await verifyFunctional("/whatever", { engine: engineReturning([one, one]) });
+  assert.equal(result.ok, false);
+  assert.match(result.reason, /嵌入退化/);
+});
+
+test("功能验证：加载失败与推理失败分别给出不同措辞", async () => {
+  const loadFail = await verifyFunctional("/whatever", {
+    engine: async () => {
+      throw new Error("Cannot find package 'onnxruntime-node'");
+    }
+  });
+  assert.equal(loadFail.ok, false);
+  assert.match(loadFail.reason, /加载运行时失败/);
+  assert.match(loadFail.reason, /onnxruntime-node/);
+
+  const embedFail = await verifyFunctional("/whatever", {
+    engine: async () => async () => {
+      throw new Error("boom");
+    }
+  });
+  assert.equal(embedFail.ok, false);
+  assert.match(embedFail.reason, /推理失败/);
+});
+
+test("功能验证：返回空向量要报出来，而不是当成 dim=0 通过", async () => {
+  const result = await verifyFunctional("/whatever", { engine: engineReturning([[], []]) });
+  assert.equal(result.ok, false);
+  assert.match(result.reason, /空向量/);
+});
+
+test("三件套：结构不过就不再做功能验证（省掉一次无谓的加载）", async () => {
+  const dir = makePayload({ withEntry: false });
+  let engineCalled = false;
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: async () => {
+      engineCalled = true;
+      return async () => fakeRows(2, 8);
+    }
+  });
+  assert.equal(result.ok, false);
+  assert.equal(result.functional.ok, false);
+  assert.match(result.functional.reason, /跳过功能验证/);
+  assert.equal(engineCalled, false);
+});
+
+test("三件套：结构 + 功能都过、完整性缺失时如实标 unverified 且不判定失败", async () => {
+  const dir = makePayload();
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8))
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.integrity.status, "unverified");
+  assert.equal(result.integrity.ok, true);
+  assert.equal(result.version, "4.2.0");
+});
+
+test("三件套：--strict 场景下哈希不匹配即整体不通过", async () => {
+  const dir = makePayload();
+  const matched = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8)),
+    integrity: { status: "sha512-matched", detail: "tarball 比对通过" }
+  });
+  assert.equal(matched.ok, true);
+  assert.equal(matched.integrity.status, "sha512-matched");
+
+  const mismatch = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning(fakeRows(2, 8)),
+    integrity: { status: "sha512-mismatch", detail: "与钉死的哈希不一致" }
+  });
+  assert.equal(mismatch.ok, false);
+  assert.equal(mismatch.structural.ok, true, "结构仍然是对的，失败来自完整性");
+  assert.equal(mismatch.functional.ok, true);
+});
+
+test("假通过防线 ①：行不是数组时返回失败，而不是抛异常", async () => {
+  // 契约是「任何失败都返回结果对象，不抛」；非数组行会让 .length/.some 直接抛。
+  const dir = makePayload();
+  const result = await verifyPayload(dir, {
+    platform: "win32",
+    arch: "x64",
+    engine: engineReturning([null, null])
+  });
+  assert.equal(result.ok, false);
+  assert.match(result.functional.reason, /不是数组/);
+});
+
+test("假通过防线 ②：非有限数值必须判失败（NaN 的比较恒为 false，会静默通过）", async () => {
+  const dir = makePayload();
+  for (const bad of [[NaN, 0], [Infinity, 0], ["0.5", "0.5"]]) {
+    const result = await verifyPayload(dir, {
+      platform: "win32",
+      arch: "x64",
+      engine: engineReturning([bad, [0, 0]])
+    });
+    assert.equal(result.ok, false, `含 ${JSON.stringify(bad)} 的向量不该被判通过`);
+    assert.match(result.functional.reason, /非有限数值/);
+  }
+});
+
+test("默认 engine 是导出的函数，且探针文本固定（改它等于改验收标准）", () => {
+  assert.equal(typeof defaultEngine, "function");
+  assert.deepEqual(DEFAULT_PROBE_TEXTS, ["猫咪喜欢晒太阳", "the quick brown fox"]);
+});
+
+// ── defaultEngine：注入假 transformers 模块，钉住「真 import + 行切分」的契约 ──
+
+/** 造一个假 transformers 入口：export env + pipeline，把收到的参数记到 globalThis。 */
+function fakeEntry(dims) {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-engine-"));
+  const entry = join(dir, "entry.mjs");
+  writeFileSync(entry, `
+export const env = {};
+export async function pipeline(kind, model, opts) {
+  globalThis.__engineSeen = { kind, model, opts, cacheDir: env.cacheDir, remote: env.allowRemoteModels };
+  const d = ${JSON.stringify(dims)};
+  const data = Float32Array.from({ length: d[0] * d[1] }, (_, i) => i + 1);
+  return async () => ({ dims: d, data });
+}
+`);
+  return pathToFileURL(entry).href;
+}
+
+test("defaultEngine: 假 transformers 入口可驱动嵌入，并按输出维度做行切分", async () => {
+  const entry = fakeEntry([2, 4]);
+  const embed = await defaultEngine(entry, { cacheDir: "/tmp/mneme-cache" });
+  const rows = await embed(["猫咪", "fox"]);
+  assert.equal(rows.length, 2);
+  assert.deepEqual(rows[0], [1, 2, 3, 4]);
+  assert.deepEqual(rows[1], [5, 6, 7, 8]);
+  // 缓存目录与离线开关必须落到 env：验证过程绝不能偷偷下载模型。
+  assert.equal(globalThis.__engineSeen.cacheDir, "/tmp/mneme-cache");
+  assert.equal(globalThis.__engineSeen.remote, false);
+  assert.equal(globalThis.__engineSeen.kind, "feature-extraction");
+});
+
+test("defaultEngine: 输出宽度为 0 时明确抛错（防止调用方死循环）", async () => {
+  const entry = fakeEntry([2, 0]);
+  const embed = await defaultEngine(entry, {});
+  await assert.rejects(() => embed(["x"]), /维度不可用/);
+});

package/test/sleep-action-set.test.js

@@ -0,0 +1,422 @@
+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";
+import { buildOutcome } from "../src/dream.js";
+import { STR } from "../src/lang.js";
+
+// Issue #126：sleep 冲突阶段的动作集扩展。默认档（sleepActionSet="conflict"）保持
+// 只有 conflict/keep 的窄语义；"full" 开放六分支，让演进型（supersede）与互补型
+// （differentiate）重复各得其所，不再被强行"输赢化"。
+
+const embedder = {
+  embedSingle: async () => [1, 0, 0],
+  embed: async () => [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;
+}
+
+/** Snapshot the decision targets the way a real run does before the LLM call. */
+function snapshotOf(store, ...mems) {
+  return new Map(mems.map((m) => [m.id, store.getById(m.id)]));
+}
+
+// --------------------------------------------------------- action semantics
+
+test("issue#126 supersede: the note lands on the loser, the winner body stays clean", () => {
+  const { service, store } = setup();
+  const oldMem = makeMemory(service, "部署方式 v1", "用 pm2 常驻启动");
+  const newMem = makeMemory(service, "部署方式 v2", "改用 systemd 托管");
+  const snapshot = snapshotOf(store, oldMem, newMem);
+  const { applied } = applyDecisions(
+    [{ action: "supersede", winner: newMem.id, loser: oldMem.id, reason: "版本演进" }],
+    service, null, snapshot, {}
+  );
+  assert.equal(applied, 1, "decision committed");
+  // #126 的核心诉求：conflict 会把注记写进赢家正文，supersede 必须写在被取代的一侧。
+  assert.equal(service.getById(newMem.id).content, "改用 systemd 托管", "winner body untouched");
+  const loser = service.getById(oldMem.id);
+  assert.equal(loser.archived, true, "loser archived");
+  assert.ok(loser.content.includes("已被取代"), "supersession note appended to the loser");
+  assert.ok(loser.content.includes("部署方式 v2"), "note names the superseding entry");
+  store.close();
+});
+
+test("issue#126 supersede: replay is idempotent (archived loser, single note)", () => {
+  const { service, store } = setup();
+  const oldMem = makeMemory(service, "端口 v1", "内网 22");
+  const newMem = makeMemory(service, "端口 v2", "内网 2222");
+  const snapshot = snapshotOf(store, oldMem, newMem);
+  const decision = { action: "supersede", winner: newMem.id, loser: oldMem.id, reason: "演进" };
+  applyDecisions([decision], service, null, snapshot, {});
+  const second = applyDecisions([{ ...decision }], service, null, snapshot, {});
+  assert.equal(second.applied, 0, "replay commits nothing");
+  assert.equal(second.committed.length, 0);
+  const notes = service.getById(oldMem.id).content.match(/已被取代/g) ?? [];
+  assert.equal(notes.length, 1, "the note is never appended twice");
+  store.close();
+});
+
+test("issue#126 differentiate: both entries survive and each carries the distinctions note", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "内网 SSH 端口", "内网走 22");
+  const b = makeMemory(service, "外网 SSH 端口", "外网映射 2222");
+  const snapshot = snapshotOf(store, a, b);
+  const { applied } = applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["内网直连", "外网映射"] }],
+    service, null, snapshot, {}
+  );
+  assert.equal(applied, 1);
+  for (const m of [a, b]) {
+    const after = service.getById(m.id);
+    assert.equal(after.archived, false, "differentiate never archives");
+    assert.ok(after.content.includes("差异注记"), "each side gets the note");
+  }
+  assert.ok(service.getById(a.id).content.includes("内网直连"), "note carries the distinctions");
+  assert.ok(service.getById(b.id).content.includes("外网映射"));
+  store.close();
+});
+
+test("issue#126 differentiate: replay does not stack the note again", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "场景 A", "内容 A");
+  const b = makeMemory(service, "场景 B", "内容 B");
+  const decision = { action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] };
+  applyDecisions([decision], service, null, snapshotOf(store, a, b), {});
+  const afterFirst = service.getById(a.id).content;
+  const second = applyDecisions([{ ...decision }], service, null, snapshotOf(store, a, b), {});
+  assert.equal(second.applied, 0, "replay is a clean no-op");
+  assert.equal(service.getById(a.id).content, afterFirst, "content is not re-appended");
+  store.close();
+});
+
+test("issue#126 differentiate: a concurrently edited target is reported as a CAS conflict", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "并发 A", "内容 A");
+  const b = makeMemory(service, "并发 B", "内容 B");
+  const snapshot = snapshotOf(store, a, b);
+  service.update(a.id, { content: "并发编辑后的内容" });
+  const { applied, conflicts } = applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲", "乙"] }],
+    service, null, snapshot, {}
+  );
+  assert.equal(applied, 0, "stale decision is not applied");
+  assert.equal(conflicts.length, 1, "surfaced as a CAS conflict (existing semantics)");
+  assert.equal(service.getById(a.id).content, "并发编辑后的内容", "concurrent edit preserved");
+  store.close();
+});
+
+// ------------------------------------------------------------------ validation
+
+test("issue#126 validate: supersede requires distinct winner/loser", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "甲", "内容甲");
+  const snapshot = snapshotOf(store, a);
+  const bad = validateDecisions([{ action: "supersede", winner: a.id, loser: a.id }], snapshot, {});
+  assert.equal(bad.ok, false);
+  assert.ok(bad.errors.some((e) => e.includes("supersede needs distinct winner and loser")), "explicit message");
+  store.close();
+});
+
+test("issue#126 validate: differentiate needs two ids and a non-empty distinctions array", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "甲", "内容甲");
+  const b = makeMemory(service, "乙", "内容乙");
+  const snapshot = snapshotOf(store, a, b);
+  assert.equal(validateDecisions([{ action: "differentiate", ids: [a.id], distinctions: ["x"] }], snapshot, {}).ok, false);
+  assert.equal(validateDecisions([{ action: "differentiate", ids: [a.id, b.id], distinctions: [] }], snapshot, {}).ok, false);
+  assert.equal(validateDecisions([{ action: "differentiate", ids: [a.id, b.id], distinctions: ["", "  "] }], snapshot, {}).ok, false,
+    "blank-only distinctions are rejected");
+  assert.equal(validateDecisions([{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }], snapshot, {}).ok, true);
+  store.close();
+});
+
+test("issue#126 validate: differentiate is allowed across types while merge is not", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "项目端口", "项目用 8080", "project");
+  const b = makeMemory(service, "偏好端口", "偏好 8080", "preference");
+  const snapshot = snapshotOf(store, a, b);
+  const merge = validateDecisions(
+    [{ action: "merge", ids: [a.id, b.id], keepSource: a.id, title: "t", content: "c" }],
+    snapshot, { skipInvalid: true }
+  );
+  assert.equal(merge.skipped.length, 1, "cross-type merge is skipped");
+  assert.match(merge.skipped[0].error, /multiple types/);
+  // 互补型本来就常跨类型（同一个事实的项目侧与偏好侧），不该套用 merge 的类型边界。
+  assert.equal(validateDecisions([{ action: "differentiate", ids: [a.id, b.id], distinctions: ["项目侧", "偏好侧"] }], snapshot, {}).ok, true);
+  store.close();
+});
+
+// --------------------------------------------------------------- end to end
+
+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.role === "system")?.content?.[0]?.text ?? "");
+        yield { type: "text-delta", index: 0, text: reply };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+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 };
+}
+
+function baseConfig(overrides = {}) {
+  return {
+    sleepModeEnabled: true,
+    sleepIdleMinutes: 5,
+    sleepMinIntervalHours: 8,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 100,
+    sleepMaxPatternPerRun: 3,
+    ...overrides
+  };
+}
+
+test("issue#126 sleepActionSet=conflict (default) keeps the narrow two-branch prompt", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "默认档甲", "默认档乙");
+  const ctx = captureCtx(JSON.stringify([{ action: "keep", ids: [a.id, b.id] }]));
+  await runSleep(ctx, service, baseConfig(), ctx.logger, { embedder, vectorIndex }, null);
+  const conflictPrompt = ctx.seen.find((p) => p.includes("冲突仲裁")) ?? "";
+  assert.ok(conflictPrompt, "the conflict phase ran");
+  assert.ok(!conflictPrompt.includes("supersede"), "default tier never advertises supersede");
+  assert.ok(!conflictPrompt.includes("differentiate"), "default tier never advertises differentiate");
+  store.close();
+});
+
+test("issue#126 sleepActionSet=full advertises the six-branch action set", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "全量档甲", "全量档乙");
+  const ctx = captureCtx(JSON.stringify([{ action: "keep", ids: [a.id, b.id] }]));
+  await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder, vectorIndex }, null);
+  const conflictPrompt = ctx.seen.find((p) => p.includes("冲突仲裁")) ?? "";
+  for (const action of ["merge", "supersede", "differentiate", "update", "conflict", "keep"]) {
+    assert.ok(conflictPrompt.includes(action), `full tier advertises ${action}`);
+  }
+  store.close();
+});
+
+test("issue#126 full tier: a supersede decision resolves an evolution pair end to end", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "旧方案", "新方案");
+  const ctx = captureCtx(JSON.stringify([{ action: "supersede", winner: b.id, loser: a.id, reason: "新方案取代旧方案" }]));
+  const result = await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.status, "ok", "supersede applied");
+  assert.equal(service.getById(a.id).archived, true, "old entry archived");
+  assert.equal(service.getById(b.id).content, "新方案 的内容", "new entry body untouched");
+  // 注：sleep 的裁决不写 receipt_chain（既有设计——per-record receipt 只由 dream 的
+  // runDream 写）。新动作的 receipt kind 由 dream 路径的测试覆盖。
+  store.close();
+});
+
+test("issue#126 skipInvalid: one invalid pair no longer fails the phase, and lands in the audit row", async () => {
+  const { service, store, vectorIndex } = setup();
+  const good = seedPair(service, vectorIndex, "合法甲", "合法乙");
+  const bad = seedPair(service, vectorIndex, "非法甲", "非法乙");
+  const ctx = captureCtx(JSON.stringify([
+    { action: "conflict", winner: good.a.id, loser: good.b.id, reason: "同义重复" },
+    { action: "conflict", winner: "nonexistent-zzz", loser: bad.b.id, reason: "引用了不存在的 id" }
+  ]));
+  const result = await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder, vectorIndex }, null);
+  // Issue #126 review（Copilot）：合法子集已应用但仍有余项被跳过 → degraded，不再是
+  // ok —— 与 dream 的契约对齐，消费方不必去翻审计明细才能区分"整轮"与"残轮"。
+  assert.equal(result.phases.conflicts.status, "degraded", "valid subset applied, run flagged degraded");
+  assert.equal(result.status, "degraded", "the whole sleep run reflects the partial phase");
+  assert.equal(service.getById(good.b.id).archived, true, "the valid pair still landed");
+  // #104 同向：被跳过的逐对明细进审计行（此前只进日志）。
+  const run = store.getDreamRun(result.runId);
+  assert.ok(Array.isArray(run?.skipped) && run.skipped.length === 1, "skipped detail persisted on the sleep audit row");
+  assert.equal(run.skipped[0].phase, "conflicts", "detail is tagged with its phase");
+  assert.match(run.skipped[0].error, /unknown id/, "per-pair reason kept");
+  store.close();
+});
+
+// ------------------------------------------------- fail-safe / boundary shapes
+
+test("issue#126 supersede: trustEpistemicWeighting is honored on the superseding side", () => {
+  const { service, store } = setup();
+  const oldMem = makeMemory(service, "旧结论", "旧结论内容");
+  const newMem = makeMemory(service, "新结论", "新结论内容");
+  const snapshot = snapshotOf(store, oldMem, newMem);
+  // 两侧可信度相同（默认 subjective）→ 保持模型给出的 winner，不凭空交换。
+  const { applied } = applyDecisions(
+    [{ action: "supersede", winner: newMem.id, loser: oldMem.id, reason: "演进" }],
+    service, null, snapshot, { trustEpistemicWeighting: true }
+  );
+  assert.equal(applied, 1);
+  assert.equal(service.getById(oldMem.id).archived, true, "model's loser stays the loser at equal trust");
+  store.close();
+});
+
+test("issue#126 supersede: a missing target degrades to skipped instead of throwing", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "有主", "内容");
+  // snapshot=null 跳过 CAS 守卫，直接验证"目标不存在"的 fail-safe 分支。
+  const { applied, failures } = applyDecisions(
+    [{ action: "supersede", winner: a.id, loser: "missing-zzz", reason: "x" }],
+    service, null, null, {}
+  );
+  assert.equal(applied, 0, "nothing committed");
+  assert.equal(failures.length, 0, "degrades cleanly, never throws");
+  store.close();
+});
+
+test("issue#126 differentiate: fewer than two live targets is a no-op", () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "存活", "内容甲");
+  const b = makeMemory(service, "已归档", "内容乙");
+  service.setArchived(b.id, true);
+  const { applied } = applyDecisions(
+    [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }],
+    service, null, null, {}
+  );
+  assert.equal(applied, 0, "differentiate needs two live entries");
+  assert.ok(!service.getById(a.id).content.includes("差异注记"), "no note is written without a pair");
+  store.close();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Issue #126 review（Copilot 逐条）的回归护栏：一处修复一条断言。
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("issue#126r: the default tier rejects an unexpected supersede (opt-in stays opt-in)", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "默认档甲", "默认档乙");
+  // 默认档没开 full，模型却输出了 supersede —— 校验器必须挡住。只换 prompt 挡不住，
+  // 这正是 Copilot 指出的 "opt-in 空话"。
+  const ctx = captureCtx(JSON.stringify([{ action: "supersede", winner: b.id, loser: a.id, reason: "越档" }]));
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(service.getById(a.id).archived, false, "supersede must not be applied in the default tier");
+  // 全部决策越档 → 无合法决策 → 覆盖率闸整单拒绝（phase 因此没有 applied 计数）。
+  // 这与 #146 之前的行为一致（那时 supersede 同样被判 invalid action）。
+  assert.equal(result.phases.conflicts.applied ?? 0, 0, "nothing was applied");
+  store.close();
+});
+
+test("issue#126r: the full tier still accepts the very same supersede", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "全量档甲", "全量档乙");
+  const ctx = captureCtx(JSON.stringify([{ action: "supersede", winner: b.id, loser: a.id, reason: "演进" }]));
+  const result = await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.applied, 1, "full tier applies it");
+  assert.equal(service.getById(a.id).archived, true);
+  store.close();
+});
+
+test("issue#126r: strict mode no longer rejects a valid supersede over synthetic keeps", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "严格甲", "严格乙");
+  const ctx = captureCtx(JSON.stringify([{ action: "supersede", winner: b.id, loser: a.id, reason: "演进" }]));
+  // dreamSkipInvalid:false = 严格模式。covered 预填必须认 supersede 的 winner/loser，
+  // 否则会补两条 keep 与它抢 claim → 整单被拒。
+  const result = await runSleep(
+    ctx, service,
+    baseConfig({ sleepActionSet: "full", dreamSkipInvalid: false }),
+    ctx.logger, { embedder, vectorIndex }, null
+  );
+  assert.equal(result.phases.conflicts.status, "ok", "strict mode accepts the valid supersede");
+  assert.equal(service.getById(a.id).archived, true, "the supersede landed");
+  store.close();
+});
+
+test("issue#126r: the English full prompt names the field the validator requires", () => {
+  const en = STR.prompts.conflictFull.en;
+  assert.ok(en.includes("distinctions"), "the English prompt must name `distinctions`");
+  assert.ok(!en.includes("distinguish must"), "the stale `distinguish` field name is gone");
+});
+
+test("issue#126r: buildOutcome records a disposition for the new actions", () => {
+  const outcome = buildOutcome([
+    { action: "supersede", winner: "w1", loser: "l1" },
+    { action: "differentiate", ids: ["d1", "d2"] }
+  ]);
+  assert.equal(outcome.byId.w1, "supersede-winner");
+  assert.equal(outcome.byId.l1, "superseded-archived");
+  assert.equal(outcome.byId.d1, "differentiated");
+  assert.equal(outcome.byId.d2, "differentiated");
+});
+
+test("issue#126r: differentiate refreshes the cached vectors so the note reaches the index", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "向量甲", "向量乙");
+  const before = vectorIndex.getEmbedding(a.id);
+  // 让嵌入器产出与旧向量不同的结果，便于确认"确实重嵌了"。
+  const fresh = { ...embedder, embedSingle: async () => [0, 1, 0] };
+  service.setEmbedder(fresh);
+  const ctx = captureCtx(JSON.stringify([
+    { action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }
+  ]));
+  await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder: fresh, vectorIndex }, null);
+  const after = vectorIndex.getEmbedding(a.id);
+  assert.notDeepEqual(after, before, "the cached vector was recomputed after the content note");
+  assert.deepEqual(after, [0, 1, 0], "it carries the fresh embedding");
+  store.close();
+});
+
+test("issue#126r: the full tier discovers cross-type pairs (differentiate would otherwise be unreachable)", async () => {
+  const { service, store, vectorIndex } = setup();
+  const proj = makeMemory(service, "项目端口", "项目用 8080", "project");
+  const pref = makeMemory(service, "偏好端口", "偏好 8080", "preference");
+  vectorIndex.saveEmbedding(proj.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(pref.id, [1, 0, 0]);
+  const ctx = captureCtx(JSON.stringify([
+    { action: "differentiate", ids: [proj.id, pref.id], distinctions: ["项目侧", "偏好侧"] }
+  ]));
+  const result = await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.applied, 1, "the cross-type pair was adjudicated");
+  assert.ok(service.getById(proj.id).content.includes("差异注记"), "differentiate reached the cross-type pair");
+  store.close();
+});
+
+test("issue#126r: a throwing index maintenance degrades to a warning, never fails the phase", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedPair(service, vectorIndex, "抖动甲", "抖动乙");
+  // deleteEmbedding 抛错 → maintainIndexAfterDream 抛出 → sleep 只能告警：索引维护是
+  // 收尾动作，不能反过来把已经落库的决策判成失败。
+  const badIndex = {
+    getEmbedding: (id) => vectorIndex.getEmbedding(id),
+    saveEmbedding: (id, v) => vectorIndex.saveEmbedding(id, v),
+    deleteEmbedding: () => { throw new Error("index down"); }
+  };
+  const ctx = captureCtx(JSON.stringify([{ action: "supersede", winner: b.id, loser: a.id, reason: "演进" }]));
+  const result = await runSleep(
+    ctx, service, baseConfig({ sleepActionSet: "full" }),
+    ctx.logger, { embedder, vectorIndex: badIndex }, null
+  );
+  assert.equal(service.getById(a.id).archived, true, "the decision itself still landed");
+  assert.equal(result.phases.conflicts.status, "ok", "index maintenance failure is only a warning");
+  store.close();
+});

package/test/store.test.js

@@ -367,3 +367,17 @@ test("conflict_pending table persists across store reopen", () => {
   assert.equal(pending[0].reason, "x");
   s2.close();
 });
+
+// Issue #128：回填候选只取活跃行——归档/遗忘行不参与召回与聚类，不该吃掉
+// 回填配额（报告实测 50 个 reindex 名额全部落在归档行，88 条活跃记忆永远轮不到）。
+test("Issue #128: needsEmbedding skips archived and forgotten rows", () => {
+  const store = openMemory();
+  const active = store.save({ type: "preference", title: "活跃", content: "内容" });
+  const archived = store.save({ type: "preference", title: "归档", content: "内容" });
+  const forgotten = store.save({ type: "preference", title: "遗忘", content: "内容" });
+  store.setArchived(archived.id, true);
+  store.setForget(forgotten.id, true);
+  const ids = store.needsEmbedding(50).map((r) => r.id);
+  assert.deepEqual(ids, [active.id], "only the active row is a backfill candidate");
+  store.close();
+});