@modusensus/dsh-mneme 0.2.4 → 0.2.6

package/test/dream.test.js

@@ -0,0 +1,526 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { validateDecisions, applyDecisions, createDreamScheduler } from "../src/dream.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+function snapshot(ids, type = "project") {
+  return new Map(ids.map((id, i) => [id, { id, type, title: `t${i}`, content: `c${i}`, importance: 3, archived: false, forgotten: false }]));
+}
+
+test("valid decision list passes", () => {
+  const snap = snapshot(["a", "b", "c"]);
+  const decisions = [
+    { action: "keep", ids: ["a"], reason: "ok" },
+    { action: "merge", ids: ["b", "c"], title: "bc", content: "merged", importance: 4, keepSource: "b" }
+  ];
+  const { ok, errors } = validateDecisions(decisions, snap);
+  assert.equal(ok, true);
+  assert.deepEqual(errors, []);
+});
+
+test("unknown id rejects whole list", () => {
+  const snap = snapshot(["a"]);
+  const { ok, errors } = validateDecisions([{ action: "archive", ids: ["zzz"], reason: "x" }], snap);
+  assert.equal(ok, false);
+  assert.ok(errors.some((e) => e.includes("zzz")));
+});
+
+test("invalid action rejects", () => {
+  const snap = snapshot(["a"]);
+  const { ok } = validateDecisions([{ action: "explode", ids: ["a"] }], snap);
+  assert.equal(ok, false);
+});
+
+test("merge keepSource must be in ids", () => {
+  const snap = snapshot(["a", "b"]);
+  const { ok } = validateDecisions([{ action: "merge", ids: ["a"], keepSource: "b", title: "t", content: "c" }], snap);
+  assert.equal(ok, false);
+});
+
+test("conflict winner and loser must exist and differ", () => {
+  const snap = snapshot(["a", "b"]);
+  const { ok } = validateDecisions([{ action: "conflict", winner: "a", loser: "a" }], snap);
+  assert.equal(ok, false);
+  const { ok: ok2 } = validateDecisions([{ action: "conflict", winner: "a", loser: "zzz" }], snap);
+  assert.equal(ok2, false);
+});
+
+test("duplicate primary ids across decisions reject", () => {
+  const snap = snapshot(["a", "b"]);
+  const { ok } = validateDecisions([
+    { action: "archive", ids: ["a"] },
+    { action: "keep", ids: ["a"] }
+  ], snap);
+  assert.equal(ok, false, "a claimed twice");
+});
+
+test("archived or summary entries cannot be decision targets", () => {
+  const snap = new Map([["arch", { id: "arch", type: "project", title: "t", content: "c", importance: 3, archived: true, forgotten: false }]]);
+  const { ok } = validateDecisions([{ action: "archive", ids: ["arch"] }], snap);
+  assert.equal(ok, false);
+});
+
+test("empty decision list rejects", () => {
+  const { ok, errors } = validateDecisions([], snapshot(["a"]));
+  assert.equal(ok, false);
+  assert.ok(errors.some((e) => e.includes("non-empty array")));
+});
+
+test("empty ids rejects", () => {
+  const { ok } = validateDecisions([{ action: "archive", ids: [] }], snapshot(["a"]));
+  assert.equal(ok, false);
+});
+
+test("merge requires non-empty title and content", () => {
+  const snap = snapshot(["a"]);
+  const base = { action: "merge", ids: ["a"], keepSource: "a" };
+  for (const [title, content] of [["", "x"], ["t", ""], [undefined, "x"], ["t", undefined]]) {
+    const { ok } = validateDecisions([{ ...base, title, content }], snap);
+    assert.equal(ok, false, `title=${JSON.stringify(title)} content=${JSON.stringify(content)}`);
+  }
+});
+
+test("summary entries cannot be decision targets", () => {
+  const snap = new Map([["s", { id: "s", type: "summary", title: "t", content: "c", importance: 3, archived: false, forgotten: false }]]);
+  const { ok } = validateDecisions([{ action: "archive", ids: ["s"] }], snap);
+  assert.equal(ok, false);
+});
+
+test("every snapshot memory must be covered by a decision", () => {
+  const snap = snapshot(["a", "b"]);
+  const { ok, errors } = validateDecisions([{ action: "keep", ids: ["a"] }], snap);
+  assert.equal(ok, false);
+  assert.ok(errors.some((e) => e.includes("missing from decisions")));
+});
+
+test("duplicate ids within one decision reject", () => {
+  const { ok } = validateDecisions([{ action: "keep", ids: ["a", "a"] }], snapshot(["a"]));
+  assert.equal(ok, false);
+});
+
+test("merge importance out of range rejects", () => {
+  const snap = snapshot(["a", "b"]);
+  for (const importance of [0, 6, 99, 1.5, "4"]) {
+    const { ok, errors } = validateDecisions([
+      { action: "merge", ids: ["a", "b"], keepSource: "a", title: "t", content: "c", importance }
+    ], snap);
+    assert.equal(ok, false, `importance=${JSON.stringify(importance)} rejected`);
+    assert.ok(errors.some((e) => e.includes("importance")), `importance error present for ${JSON.stringify(importance)}`);
+  }
+  const { ok } = validateDecisions([
+    { action: "merge", ids: ["a", "b"], keepSource: "a", title: "t", content: "c", importance: 5 }
+  ], snap);
+  assert.equal(ok, true, "importance 5 accepted");
+});
+
+test("merge across types rejects", () => {
+  const snap = new Map([
+    ["p", { id: "p", type: "preference", title: "语言", content: "中文", importance: 3, archived: false, forgotten: false }],
+    ["j", { id: "j", type: "project", title: "插件", content: "内容", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const { ok, errors } = validateDecisions([
+    { action: "merge", ids: ["p", "j"], keepSource: "p", title: "合并", content: "合并内容", importance: 4 }
+  ], snap);
+  assert.equal(ok, false, "cross-type merge rejected");
+  assert.ok(errors.some((e) => e.includes("multiple types")), "multi-type error present");
+});
+
+function dreamSetup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+test("applyDecisions merges: keepSource updated, others archived", () => {
+  const { store, service } = dreamSetup();
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const { applied } = applyDecisions([
+    { action: "merge", ids: [a.id, b.id], title: "插件总览", content: "合并内容", importance: 5, keepSource: b.id }
+  ], service);
+  assert.equal(applied, 1);
+  const keeper = store.getById(b.id);
+  assert.equal(keeper.content, "合并内容");
+  assert.equal(keeper.title, "插件总览");
+  assert.equal(keeper.importance, 5);
+  assert.equal(store.getById(a.id).archived, true, "source archived");
+});
+
+test("applyDecisions conflict: winner kept, loser archived with provenance", () => {
+  const { store, service } = dreamSetup();
+  const { memory: w } = service.saveWithDedupe({ type: "decision", title: "截止", content: "8月20日", importance: 4 });
+  const { memory: l } = service.saveWithDedupe({ type: "decision", title: "截止旧", content: "8月15日", importance: 4 });
+  applyDecisions([{ action: "conflict", winner: w.id, loser: l.id, reason: "更新" }], service);
+  assert.equal(store.getById(l.id).archived, true);
+  const winner = store.getById(w.id);
+  assert.ok(winner.content.includes("8月20日"), "winner content intact");
+  assert.ok(winner.content.includes("已否决旧信息"), "provenance note appended");
+});
+
+test("applyDecisions archive and keep", () => {
+  const { store, service } = dreamSetup();
+  const { memory: k } = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "废弃", content: "过时" });
+  applyDecisions([
+    { action: "keep", ids: [k.id] },
+    { action: "archive", ids: [a.id], reason: "过时" }
+  ], service);
+  assert.equal(store.getById(k.id).archived, false);
+  assert.equal(store.getById(a.id).archived, true);
+});
+
+test("applyDecisions returns count and never throws on unknown id (skip)", () => {
+  const { store, service } = dreamSetup();
+  const { memory: k } = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  const { applied } = applyDecisions([{ action: "archive", ids: ["ghost"], reason: "x" }], service);
+  assert.equal(applied, 0);
+  assert.equal(store.getById(k.id).archived, false);
+});
+
+test("applyDecisions catch path: throwing decision is skipped, logged, and later decisions still apply", () => {
+  const { store, service } = dreamSetup();
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "会炸", content: "x" });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "正常", content: "y" });
+  const originalSetArchived = service.setArchived;
+  let calls = 0;
+  service.setArchived = (id, archived) => {
+    calls++;
+    if (calls === 1) throw new Error("boom");
+    return originalSetArchived.call(service, id, archived);
+  };
+  const warnings = [];
+  const logger = { warn: (msg) => warnings.push(msg) };
+  const { applied, failures } = applyDecisions([
+    { action: "archive", ids: [a.id], reason: "x" },
+    { action: "archive", ids: [b.id], reason: "y" }
+  ], service, logger);
+  assert.equal(applied, 1, "throwing decision not counted, surviving decision counted");
+  assert.equal(failures.length, 1, "thrown decision reported as a failure");
+  assert.equal(store.getById(a.id).archived, false, "throwing decision left no partial effect");
+  assert.equal(store.getById(b.id).archived, true, "later decision still applied");
+  assert.equal(warnings.length, 1, "logger called once");
+  assert.match(warnings[0], /failed to apply archive at index 0: boom/);
+});
+
+test("applyDecisions conflict with missing loser skips cleanly", () => {
+  const { store, service } = dreamSetup();
+  const { memory: w } = service.saveWithDedupe({ type: "decision", title: "截止", content: "8月20日", importance: 4 });
+  const { applied } = applyDecisions([{ action: "conflict", winner: w.id, loser: "ghost", reason: "x" }], service);
+  assert.equal(applied, 0);
+  assert.equal(store.getById(w.id).archived, false, "winner untouched");
+  assert.ok(!store.getById(w.id).content.includes("已否决"), "no provenance note appended");
+});
+
+test("applyDecisions merge with missing keeper skips cleanly", () => {
+  const { store, service } = dreamSetup();
+  const { applied } = applyDecisions([
+    { action: "merge", ids: ["ghost"], keepSource: "ghost", title: "t", content: "c" }
+  ], service);
+  assert.equal(applied, 0);
+  assert.equal(store.getById("ghost"), undefined);
+});
+
+test("applyDecisions merge without importance falls back to max source importance", () => {
+  const { store, service } = dreamSetup();
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const { applied } = applyDecisions([
+    { action: "merge", ids: [a.id, b.id], title: "插件总览", content: "合并内容", keepSource: b.id }
+  ], service);
+  assert.equal(applied, 1);
+  assert.equal(store.getById(b.id).importance, 4, "keeper keeps max of source importances");
+  assert.equal(store.getById(a.id).archived, true, "source archived");
+});
+
+test("maybeSchedule triggers when count exceeds threshold", () => {
+  const { store, service } = dreamSetup();
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; },
+    thresholdCount: 3,
+    thresholdChars: 5000,
+    delayMs: 0
+  });
+  for (let i = 0; i < 3; i++) service.saveWithDedupe({ type: "project", title: `m${i}`, content: "x".repeat(100) });
+  const pending = dream.maybeSchedule(service);
+  assert.equal(pending, true, "scheduled");
+  assert.equal(runs, 0, "not run yet (async)");
+  store.close();
+});
+
+test("maybeSchedule does not trigger below threshold", () => {
+  const { store, service } = dreamSetup();
+  const dream = createDreamScheduler({ onRun: async () => {}, thresholdCount: 10, thresholdChars: 5000, delayMs: 0 });
+  service.saveWithDedupe({ type: "project", title: "only", content: "x" });
+  assert.equal(dream.maybeSchedule(service), false);
+  store.close();
+});
+
+test("scheduler fires async and resets baseline", async () => {
+  const { store, service } = dreamSetup();
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: true }; },
+    thresholdCount: 2, thresholdChars: 5000, delayMs: 5
+  });
+  for (let i = 0; i < 2; i++) service.saveWithDedupe({ type: "project", title: `m${i}`, content: "x".repeat(50) });
+  dream.maybeSchedule(service);
+  await new Promise((r) => setTimeout(r, 50));
+  assert.equal(runs, 1, "ran once");
+  // still above threshold but baseline reset → no immediate re-trigger
+  assert.equal(dream.maybeSchedule(service), false, "baseline prevents loop");
+  store.close();
+});
+
+test("failed run does not refresh baseline: next write re-triggers", async () => {
+  const { store, service } = dreamSetup();
+  let calls = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => {
+      calls++;
+      return { ok: false, error: "llm failed" };
+    },
+    thresholdCount: 2, thresholdChars: 5000, delayMs: 5,
+    logger: { warn: () => {} }
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x".repeat(10) });
+  service.saveWithDedupe({ type: "project", title: "b", content: "y".repeat(10) });
+  assert.equal(dream.maybeSchedule(service), true, "scheduled");
+  await new Promise((r) => setTimeout(r, 50));
+  assert.equal(calls, 1, "run attempted once");
+  // baseline NOT refreshed on failure → the same write volume still triggers
+  assert.equal(dream.maybeSchedule(service), true, "failed run keeps baseline, re-schedules");
+  await new Promise((r) => setTimeout(r, 50));
+  assert.equal(calls, 2, "retried after failure");
+  store.close();
+});
+
+test("throwing run does not refresh baseline and is logged", async () => {
+  const { store, service } = dreamSetup();
+  const warnings = [];
+  let calls = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => {
+      calls++;
+      throw new Error("boom");
+    },
+    thresholdCount: 1, thresholdChars: 0, delayMs: 5,
+    logger: { warn: (msg) => warnings.push(msg) }
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  assert.equal(dream.maybeSchedule(service), true, "scheduled");
+  await new Promise((r) => setTimeout(r, 30));
+  assert.equal(calls, 1, "run attempted once");
+  assert.ok(warnings.some((m) => m.includes("run failed")), "throw logged");
+  assert.equal(dream.maybeSchedule(service), true, "throw keeps baseline, re-schedules");
+  store.close();
+});
+
+test("maybeSchedule returns false while a run is in flight", async () => {
+  const { store, service } = dreamSetup();
+  let release;
+  const gate = new Promise((r) => { release = r; });
+  let entered = false;
+  const dream = createDreamScheduler({
+    onRun: async () => { entered = true; await gate; },
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0,
+    logger: { warn: () => {} }
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  assert.equal(dream.maybeSchedule(service), true, "first schedule accepted");
+  await new Promise((r) => setTimeout(r, 20));
+  assert.equal(entered, true, "run started");
+  assert.equal(dream.maybeSchedule(service), false, "no schedule while running");
+  release();
+  await new Promise((r) => setTimeout(r, 10)); // let the run finish + baseline refresh
+  store.close();
+});
+
+test("dispose clears pending timer and blocks future scheduling", async () => {
+  const { store, service } = dreamSetup();
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; },
+    thresholdCount: 1, thresholdChars: 0, delayMs: 5,
+    logger: { warn: () => {} }
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  assert.equal(dream.maybeSchedule(service), true, "scheduled");
+  dream.dispose();
+  await new Promise((r) => setTimeout(r, 30));
+  assert.equal(runs, 0, "pending run cancelled by dispose");
+  assert.equal(dream.maybeSchedule(service), false, "disposed scheduler never schedules");
+  store.close();
+});
+
+test("dispose awaits an in-flight run so the store can close safely", async () => {
+  const { store, service } = dreamSetup();
+  let release;
+  const gate = new Promise((r) => { release = r; });
+  let entered = false;
+  let finished = false;
+  const dream = createDreamScheduler({
+    onRun: async () => { entered = true; await gate; finished = true; },
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0,
+    logger: { warn: () => {} }
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  assert.equal(dream.maybeSchedule(service), true, "scheduled");
+  await new Promise((r) => setTimeout(r, 20));
+  assert.equal(entered, true, "run started");
+
+  const disposeP = dream.dispose();
+  let settled = false;
+  disposeP.then(() => { settled = true; });
+  await new Promise((r) => setTimeout(r, 10));
+  assert.equal(settled, false, "dispose must not resolve while a run is in flight");
+  assert.equal(finished, false, "run still pending");
+
+  release();
+  await disposeP;
+  assert.equal(finished, true, "run completed before dispose resolved");
+  store.close();
+});
+
+test("runDream stores summary and applies decisions", async () => {
+  const { store, service } = dreamSetup();
+  // seed 2 memories so snapshot is non-empty and decisions cover them
+  const a = service.saveWithDedupe({ type: "project", title: "旧1", content: "第一段内容" });
+  const b = service.saveWithDedupe({ type: "project", title: "旧2", content: "第二段内容" });
+  let calls = 0;
+  const ctx = {
+    llm: {
+      stream: async function* () {
+        calls++;
+        if (calls === 1) {
+          const text = JSON.stringify([
+            { action: "merge", ids: [a.memory.id, b.memory.id], title: "合并标题", content: "合并后的内容", importance: 4, keepSource: a.memory.id }
+          ]);
+          yield { type: "text-delta", text };
+        } else {
+          yield { type: "text-delta", text: "记忆库总览摘要文本" };
+        }
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    },
+    logger: { warn: () => {} }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  assert.equal(result.ok, true);
+  assert.equal(result.applied, 1, "merge decision applied");
+  assert.equal(result.summary, true, "summary stored");
+  const keeper = store.getById(a.memory.id);
+  assert.equal(keeper.title, "合并标题", "keeper title updated");
+  assert.equal(keeper.content, "合并后的内容", "keeper content updated");
+  assert.equal(keeper.importance, 4, "keeper importance updated");
+  assert.equal(store.getById(b.memory.id).archived, true, "merged source archived");
+  const summary = store.all().find((m) => m.type === "summary");
+  assert.ok(summary, "summary created");
+  assert.equal(summary.title, "记忆库总览");
+  assert.equal(summary.content, "记忆库总览摘要文本");
+  store.close();
+});
+
+test("runDream fails safe on invalid decisions", async () => {
+  const { store, service } = dreamSetup();
+  const saved = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
+  let calls = 0;
+  const warnings = [];
+  const ctx = {
+    llm: {
+      stream: async function* () {
+        calls++;
+        yield { type: "text-delta", text: calls === 1 ? "not json at all" : "summary" };
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    },
+    logger: { warn: (msg) => warnings.push(msg) }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  assert.equal(result.ok, false, "invalid decisions rejected");
+  assert.equal(result.summary, false, "no summary flag on failure");
+  assert.equal(store.all().filter((m) => m.type === "summary").length, 0, "no summary on failure");
+  const lang = store.getById(saved.memory.id);
+  assert.ok(lang, "original memory still present");
+  assert.equal(lang.archived, false, "original memory not archived");
+  assert.equal(lang.content, "中文", "original memory content untouched");
+  assert.ok(warnings.length >= 1, "failure was logged");
+  store.close();
+});
+
+// --- item ①: CAS guard against concurrent edits ----------------------------
+
+test("applyDecisions CAS: merge onto a concurrently-edited target is skipped as a conflict, not applied", () => {
+  const { store, service } = dreamSetup();
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  // snapshot captured before the "LLM call"; a concurrent edit lands meanwhile
+  const snapshot = new Map([a.id, b.id].map((id) => [id, store.getById(id)]));
+  service.update(a.id, { content: "并发编辑" });
+  const { applied, conflicts, committed } = applyDecisions([
+    { action: "merge", ids: [a.id, b.id], title: "插件总览", content: "合并内容", importance: 5, keepSource: b.id }
+  ], service, null, snapshot);
+  assert.equal(applied, 0, "decision skipped entirely");
+  assert.equal(conflicts.length, 1, "recorded as a CAS conflict");
+  assert.equal(committed.length, 0, "nothing committed");
+  assert.equal(store.getById(a.id).content, "并发编辑", "concurrent edit preserved");
+  assert.equal(store.getById(b.id).archived, false, "source not archived");
+  assert.equal(store.getById(b.id).title, "插件2", "keeper untouched");
+  store.close();
+});
+
+test("applyDecisions CAS: update to a concurrently-edited memory is skipped as a conflict", () => {
+  const { store, service } = dreamSetup();
+  const { memory: m } = service.saveWithDedupe({ type: "preference", title: "语言", content: "喜欢 Python" });
+  const snapshot = new Map([[m.id, store.getById(m.id)]]);
+  service.update(m.id, { content: "并发改动" });
+  const { applied, conflicts } = applyDecisions(
+    [{ action: "update", ids: [m.id], content: "喜欢 Rust" }],
+    service, null, snapshot
+  );
+  assert.equal(applied, 0);
+  assert.equal(conflicts.length, 1);
+  assert.equal(store.getById(m.id).content, "并发改动", "concurrent edit wins");
+  store.close();
+});
+
+test("applyDecisions without a snapshot skips the CAS guard (replay path unchanged)", () => {
+  const { store, service } = dreamSetup();
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  service.update(a.id, { content: "并发编辑" }); // concurrent edit
+  const { applied, conflicts } = applyDecisions([
+    { action: "archive", ids: [a.id], reason: "x" }
+  ], service);
+  assert.equal(applied, 1, "snapshotless replay applies (no CAS guard)");
+  assert.equal(conflicts.length, 0);
+  assert.equal(store.getById(a.id).archived, true);
+  store.close();
+});
+
+// --- item ②: per-decision transaction atomicity ----------------------------
+
+test("applyDecisions merge is atomic: a throwing archive step rolls back the keeper update too", () => {
+  const { store, service } = dreamSetup();
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "甲", content: "旧甲", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "乙", content: "旧乙", importance: 4 });
+  const originalSetArchived = service.setArchived;
+  service.setArchived = (id, archived) => {
+    if (id === a.id) throw new Error("archive boom");
+    return originalSetArchived.call(service, id, archived);
+  };
+  const warnings = [];
+  const { applied, failures, committed } = applyDecisions([
+    { action: "merge", ids: [a.id, b.id], title: "甲乙", content: "合并", importance: 4, keepSource: b.id }
+  ], service, { warn: (m) => warnings.push(m) });
+  assert.equal(applied, 0, "merge not committed");
+  assert.equal(failures.length, 1, "reported as a failure");
+  assert.equal(committed.length, 0, "outcome must not claim a merge that rolled back");
+  assert.equal(store.getById(b.id).title, "乙", "keeper title untouched by the rolled-back update");
+  assert.equal(store.getById(b.id).content, "旧乙", "keeper content untouched");
+  assert.equal(store.getById(a.id).archived, false, "source not archived");
+  assert.ok(warnings.length >= 1, "failure logged");
+  store.close();
+});

package/test/helpers/dream-mock.js

@@ -0,0 +1,82 @@
+// test/helpers/dream-mock.js
+// 共享的确定性 LLM 测试桩：consolidation 决策生成器 + 最小 DSH ctx。
+// 被 scripts/stress-dsh.js 与 test/stress.test.js 共用，保证压测与单测
+// 走同一套"LLM 行为"，避免两边决策逻辑漂移。
+
+export function parseEntries(listText) {
+  return [...listText.matchAll(
+    /id=([^\s|]+)\s*\|\s*type=(\w+)\s*\|\s*importance=(\d+)\s*\|\s*updated=([^\s|]+)\s*\|\s*title=([^|]*)/g
+  )].map((m) => ({ id: m[1], type: m[2], importance: Number(m[3]), updated: m[4], title: m[5].trim() }));
+}
+
+/**
+ * 长会话检索的确定性决策：title 含「变体」→ archive，其余 keep。
+ */
+export function sessionDecisions(listText) {
+  const entries = parseEntries(listText);
+  const decisions = [];
+  const claimed = new Set();
+  for (const e of entries) {
+    if (e.title.includes("变体")) {
+      decisions.push({ action: "archive", ids: [e.id], reason: "stale variant" });
+      claimed.add(e.id);
+    }
+  }
+  for (const e of entries) {
+    if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
+  }
+  return JSON.stringify(decisions);
+}
+
+/**
+ * 冲突裁决的确定性决策：title 以「(旧)」结尾 → conflict（胜者为同主题
+ * 不带「(旧)」者），无对手 → keep。同一快照必然产出同一决策。
+ */
+export function arbitrationDecisions(listText) {
+  const entries = parseEntries(listText);
+  const byKey = new Map();
+  for (const e of entries) {
+    const key = e.title.replace(/\(旧\)$/, "").trim();
+    if (!byKey.has(key)) byKey.set(key, []);
+    byKey.get(key).push(e);
+  }
+  const decisions = [];
+  const claimed = new Set();
+  for (const group of byKey.values()) {
+    const loser = group.find((e) => e.title.includes("(旧)"));
+    const winner = group.find((e) => !e.title.includes("(旧)"));
+    if (winner && loser) {
+      decisions.push({ action: "conflict", winner: winner.id, loser: loser.id, reason: "新信息覆盖旧信息" });
+      claimed.add(winner.id);
+      claimed.add(loser.id);
+      continue;
+    }
+    for (const e of group) {
+      if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
+      claimed.add(e.id);
+    }
+  }
+  return JSON.stringify(decisions);
+}
+
+/**
+ * 最小 DSH ctx：consolidation 用 onConsolidation(listText) 产出决策，
+ * summary 返回固定文本。
+ */
+export function mockCtx({ onConsolidation, summaryText = "记忆库总览：用户偏好中文；关键决策已巩固。" } = {}) {
+  return {
+    logger: { warn: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "stress-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
+        } else {
+          yield { type: "text-delta", index: 0, text: summaryText };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}