@modusensus/dsh-mneme 0.2.7 → 0.2.9

package/test/conflict-freeze.test.js

@@ -0,0 +1,290 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Config } from "../src/config.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+
+// ---------------------------------------------------------------------------
+// conflict freeze (冲突冻结) — 测试用例由 Kimi K2.7 设计，覆盖 config/store/
+// service/dream 单测 + runDream 端到端（mock LLM 输出 conflict）。
+// 核心约定：freeze 默认关闭（自动裁决行为完全不变）；开启后 conflict 不自动
+// 裁决、存入 conflict_pending 待人工确认，outcome 标 conflict-pending。
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------- config
+
+test("config: conflictFreezeEnabled 默认关闭", () => {
+  const cfg = Config({});
+  assert.equal(cfg.conflictFreezeEnabled, false, "freeze 默认不开启");
+});
+
+test("config: conflictFreezeEnabled 可显式开启", () => {
+  const cfg = Config({ conflictFreezeEnabled: true });
+  assert.equal(cfg.conflictFreezeEnabled, true);
+});
+
+test("config: conflictFreezeMaxPending 默认为 100 且为整数", () => {
+  const cfg = Config({});
+  assert.equal(cfg.conflictFreezeMaxPending, 100);
+  assert.ok(Number.isInteger(cfg.conflictFreezeMaxPending));
+});
+
+test("config: conflictFreezeMaxPending 可显式覆盖", () => {
+  const cfg = Config({ conflictFreezeMaxPending: 5 });
+  assert.equal(cfg.conflictFreezeMaxPending, 5);
+});
+
+test("config: freeze 配置项不影响其它字段", () => {
+  const base = Config({});
+  const tuned = Config({ conflictFreezeEnabled: true, conflictFreezeMaxPending: 7 });
+  assert.equal(tuned.rerankEnabled, base.rerankEnabled, "rerank 不受影响");
+  assert.equal(tuned.autoDream, base.autoDream, "autoDream 不受影响");
+});
+
+// ---------------------------------------------------------------- store
+
+function openStore() {
+  return createStore(":memory:");
+}
+
+test("store: saveConflictPending 插入后 listConflictPending 读回", () => {
+  const store = openStore();
+  const pending = store.saveConflictPending({ run_id: "run-1", memory_a: "a", memory_b: "b", reason: "日期矛盾" });
+  assert.ok(pending.id, "有 id");
+  assert.equal(pending.run_id, "run-1");
+  assert.equal(pending.reason, "日期矛盾");
+  assert.ok(pending.created_at, "有 created_at");
+  assert.equal(pending.resolved_at, undefined, "未决行没有 resolved_at");
+
+  const list = store.listConflictPending();
+  assert.equal(list.length, 1);
+  assert.ok([list[0].memory_a, list[0].memory_b].includes("a"), "pair 包含双方");
+  assert.ok([list[0].memory_a, list[0].memory_b].includes("b"));
+  store.close();
+});
+
+test("store: 对序归一化去重 —— 同一对不管顺序只存一次", () => {
+  const store = openStore();
+  const p1 = store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "r1" });
+  const p2 = store.saveConflictPending({ memory_a: "b", memory_b: "a", reason: "r2" });
+  assert.equal(p2.id, p1.id, "反序重报返回同一条 pending");
+  assert.equal(p2.reason, "r1", "保留首次 reason");
+  assert.equal(store.countConflictPending(), 1, "绝不重复入队");
+  store.close();
+});
+
+test("store: 不同对不去重", () => {
+  const store = openStore();
+  store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "ab" });
+  store.saveConflictPending({ memory_a: "a", memory_b: "c", reason: "ac" });
+  assert.equal(store.countConflictPending(), 2);
+  store.close();
+});
+
+test("store: resolveConflictPending 标 resolved + winner，默认列表不再返回", () => {
+  const store = openStore();
+  const pending = store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "r" });
+  const resolved = store.resolveConflictPending(pending.id, { winner: "a" });
+  assert.ok(resolved.resolved_at, "resolved_at 已盖章");
+  assert.equal(resolved.resolved_winner, "a");
+  assert.equal(store.listConflictPending().length, 0, "已解决默认排除");
+  const all = store.listConflictPending({ includeResolved: true });
+  assert.equal(all.length, 1, "includeResolved 可见");
+  assert.equal(all[0].resolved_winner, "a");
+  store.close();
+});
+
+test("store: resolveConflictPending 未知 id 返回 undefined", () => {
+  const store = openStore();
+  assert.equal(store.resolveConflictPending("ghost"), undefined);
+  store.close();
+});
+
+test("store: countConflictPending 只统计未决行", () => {
+  const store = openStore();
+  store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "ab" });
+  const p2 = store.saveConflictPending({ memory_a: "b", memory_b: "c", reason: "bc" });
+  assert.equal(store.countConflictPending(), 2);
+  store.resolveConflictPending(p2.id, { winner: "b" });
+  assert.equal(store.countConflictPending(), 1, "已解决不再计入");
+  store.close();
+});
+
+test("store: 已解决的同一对后续可再次 pending", () => {
+  const store = openStore();
+  const p1 = store.saveConflictPending({ memory_a: "a", memory_b: "b", reason: "r" });
+  store.resolveConflictPending(p1.id, { winner: "a" });
+  // 去重只看未决行 —— 已解决后再现同一对应产生新 pending
+  const p2 = store.saveConflictPending({ memory_a: "b", memory_b: "a", reason: "again" });
+  assert.notEqual(p2.id, p1.id, "已解决行不参与去重");
+  assert.equal(p2.resolved_at, undefined);
+  assert.equal(store.countConflictPending(), 1);
+  store.close();
+});
+
+// ---------------------------------------------------------------- service passthrough
+
+function openService() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+test("service: 4 个 conflict freeze passthrough 委托到 store", () => {
+  const { store, service } = openService();
+  const saved = service.saveConflictPending({ run_id: "run-1", memory_a: "a", memory_b: "b", reason: "r" });
+  assert.equal(store.countConflictPending(), 1, "save 落到 store");
+  assert.equal(service.countConflictPending(), 1, "count 读回一致");
+  assert.equal(service.listConflictPending().length, 1, "list 读回一致");
+  const resolved = service.resolveConflictPending(saved.id, { winner: "a" });
+  assert.ok(resolved.resolved_at, "resolve 落到 store");
+  assert.equal(service.listConflictPending().length, 0, "已解决从默认列表消失");
+  store.close();
+});
+
+test("service: passthrough 透传 store 异常", () => {
+  const { store, service } = openService();
+  const original = store.countConflictPending;
+  store.countConflictPending = () => { throw new Error("db boom"); };
+  assert.throws(() => service.countConflictPending(), /db boom/);
+  store.countConflictPending = original;
+  store.close();
+});
+
+// ---------------------------------------------------------------- dream: runDream 端到端
+
+function dreamSetup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+// mock LLM：第一次调用返回 consolidation decisions，第二次返回 summary。
+function freezeCtx({ conflicts, includes = [], summaryText = "记忆库总览摘要" }) {
+  let calls = 0;
+  const warnings = [];
+  const ctx = {
+    warnings,
+    llm: {
+      stream: async function* () {
+        calls++;
+        const list = [...includes, ...conflicts];
+        yield { type: "text-delta", text: calls === 1 ? JSON.stringify(list) : summaryText };
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    },
+    logger: { warn: (m) => warnings.push(m) }
+  };
+  return ctx;
+}
+
+const BASE_CONFIG = { dreamProvider: "deepseek", dreamModel: "deepseek-chat" };
+
+test("dream: freeze=false（默认）conflict 仍自动裁决（回归）", async () => {
+  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 });
+  const ctx = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "日期更新" }] });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, BASE_CONFIG);
+  assert.equal(result.ok, true);
+  assert.equal(result.applied, 1, "conflict 被自动裁决");
+  assert.equal(result.frozen, 0, "无冻结");
+  assert.equal(store.getById(l.id).archived, true, "loser 被归档");
+  assert.ok(store.getById(w.id).content.includes("已否决旧信息"), "winner 附带来源批注");
+  assert.equal(store.listConflictPending().length, 0, "freeze 关闭不产生 pending");
+  store.close();
+});
+
+test("dream: freeze=true conflict 不自动裁决、存入 pending、outcome 标 conflict-pending", async () => {
+  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 });
+  const ctx = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "日期更新，候选取新" }] });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { ...BASE_CONFIG, conflictFreezeEnabled: true });
+  assert.equal(result.ok, true);
+  assert.equal(result.applied, 0, "conflict 未被应用");
+  assert.equal(result.frozen, 1, "1 个 conflict 被冻结");
+  const pending = store.listConflictPending();
+  assert.equal(pending.length, 1, "pending 记录写入");
+  assert.equal(pending[0].reason, "日期更新，候选取新");
+  assert.equal(store.getById(l.id).archived, false, "loser 未归档");
+  assert.equal(store.getById(w.id).archived, false, "winner 未归档");
+  assert.ok(!store.getById(w.id).content.includes("已否决旧信息"), "无来源批注");
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.outcome.byId[w.id], "conflict-pending", "audit outcome 标记双方 pending");
+  assert.equal(run.outcome.byId[l.id], "conflict-pending");
+  assert.equal(store.listReceipts().length, 0, "冻结 conflict 不写 per-record 收据");
+  store.close();
+});
+
+test("dream: freeze=true 非 conflict 决策照常执行，仅 conflict 冻结", async () => {
+  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 { 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 });
+  const ctx = freezeCtx({
+    includes: [{ action: "merge", ids: [a.id, b.id], title: "插件总览", content: "合并内容", importance: 5, keepSource: b.id }],
+    conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "日期更新" }]
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { ...BASE_CONFIG, conflictFreezeEnabled: true });
+  assert.equal(result.applied, 1, "merge 正常应用");
+  assert.equal(result.frozen, 1, "conflict 被冻结");
+  assert.equal(store.getById(b.id).title, "插件总览", "merge keeper 已更新");
+  assert.equal(store.getById(a.id).archived, true, "merge 源已归档");
+  assert.equal(store.getById(l.id).archived, false, "conflict loser 未被本次运行触碰");
+  assert.equal(store.listConflictPending().length, 1);
+  store.close();
+});
+
+test("dream: freeze=true 超过 conflictFreezeMaxPending 上限跳过（不抛错）", async () => {
+  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 });
+  const ctx = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "x" }] });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    ...BASE_CONFIG, conflictFreezeEnabled: true, conflictFreezeMaxPending: 0
+  });
+  assert.equal(result.frozen, 0, "容量 0 时无冻结");
+  assert.equal(store.listConflictPending().length, 0, "无 pending 写入");
+  assert.ok(ctx.warnings.some((m) => m.includes("freeze queue full")), "超限警告已记录");
+  store.close();
+});
+
+test("dream: freeze=true 存 pending 失败 fail-safe 不阻断 run", async () => {
+  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 });
+  service.saveConflictPending = () => { throw new Error("pending store boom"); };
+  service.countConflictPending = () => { throw new Error("count boom"); };
+  const ctx = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "x" }] });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { ...BASE_CONFIG, conflictFreezeEnabled: true });
+  assert.equal(result.ok, true, "尽管 pending 存储失败，run 正常完成");
+  assert.equal(result.frozen, 0, "无冻结");
+  assert.ok(ctx.warnings.length >= 1, "freeze 失败已记录");
+  assert.equal(store.getById(l.id).archived, false, "记忆无副作用");
+  assert.equal(store.getById(w.id).content, "8月20日", "winner 未被改动");
+  store.close();
+});
+
+test("dream: freeze=true 同一对跨 run 去重 —— 只保留一条 pending", async () => {
+  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 });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const ctx = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "日期矛盾" }] });
+  const r1 = await dream.runDream(ctx, service, { ...BASE_CONFIG, conflictFreezeEnabled: true });
+  // mock LLM 计数器按 run 重置：每次 runDream 用独立的 ctx
+  const ctx2 = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "日期矛盾" }] });
+  const r2 = await dream.runDream(ctx2, service, { ...BASE_CONFIG, conflictFreezeEnabled: true });
+  assert.equal(r1.frozen, 1);
+  assert.equal(r2.frozen, 1, "每次 run 都检出并上报该对");
+  assert.equal(store.countConflictPending(), 1, "但队列只有一条 pending");
+  store.close();
+});

package/test/dream.test.js

@@ -545,3 +545,129 @@ test("applyDecisions merge is atomic: a throwing archive step rolls back the kee
   assert.ok(warnings.length >= 1, "failure logged");
   store.close();
 });
+
+// --- conflict freeze: manual review instead of auto-adjudication ----------
+
+function freezeCtx({ conflicts, includes = [], summaryText = "记忆库总览摘要" }) {
+  let calls = 0;
+  const warnings = [];
+  const ctx = {
+    warnings,
+    llm: {
+      stream: async function* () {
+        calls++;
+        const list = [...includes, ...conflicts];
+        yield { type: "text-delta", text: calls === 1 ? JSON.stringify(list) : summaryText };
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    },
+    logger: { warn: (m) => warnings.push(m) }
+  };
+  return ctx;
+}
+
+test("runDream with conflictFreezeEnabled parks conflicts instead of adjudicating", async () => {
+  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 });
+  const ctx = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "日期更新，候选取新" }] });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat", conflictFreezeEnabled: true
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.applied, 0, "no conflict applied");
+  assert.equal(result.frozen, 1, "one conflict frozen");
+  // pending row recorded for human review
+  const pending = store.listConflictPending();
+  assert.equal(pending.length, 1);
+  assert.equal(pending[0].reason, "日期更新，候选取新");
+  // neither side was auto-adjudicated
+  assert.equal(store.getById(l.id).archived, false, "loser NOT archived");
+  assert.equal(store.getById(w.id).archived, false, "winner NOT archived");
+  assert.ok(!store.getById(w.id).content.includes("已否决旧信息"), "no provenance note appended");
+  // audit outcome marks both sides pending
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.outcome.byId[w.id], "conflict-pending");
+  assert.equal(run.outcome.byId[l.id], "conflict-pending");
+  assert.equal(run.status, "ok", "summary stored + freeze landed → ok");
+  assert.equal(store.listReceipts().length, 0, "no conflict receipt for a frozen (unapplied) conflict");
+  store.close();
+});
+
+test("runDream freeze keeps auto-adjudication when disabled (default)", async () => {
+  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 });
+  const ctx = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "更新" }] });
+  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, "conflict auto-adjudicated when freeze is off");
+  assert.equal(result.frozen, 0);
+  assert.equal(store.getById(l.id).archived, true, "loser archived");
+  assert.ok(store.getById(w.id).content.includes("已否决旧信息"), "provenance note appended");
+  assert.equal(store.listConflictPending().length, 0, "no pending rows in auto mode");
+  store.close();
+});
+
+test("runDream freeze applies non-conflict decisions while parking conflicts", async () => {
+  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 { 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 });
+  const ctx = freezeCtx({
+    includes: [{ action: "merge", ids: [a.id, b.id], title: "插件总览", content: "合并内容", importance: 5, keepSource: b.id }],
+    conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "日期更新" }]
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat", conflictFreezeEnabled: true
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.applied, 1, "merge applied normally");
+  assert.equal(result.frozen, 1, "conflict frozen");
+  assert.equal(store.getById(b.id).title, "插件总览", "merge keeper updated");
+  assert.equal(store.getById(a.id).archived, true, "merge source archived");
+  assert.equal(store.getById(l.id).archived, false, "conflict loser untouched by the merge run");
+  const pending = store.listConflictPending();
+  assert.equal(pending.length, 1);
+  assert.ok(pending[0].reason.includes("日期更新"));
+  store.close();
+});
+
+test("runDream freeze respects conflictFreezeMaxPending cap and skips overflow", async () => {
+  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 });
+  const ctx = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "x" }] });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat",
+    conflictFreezeEnabled: true, conflictFreezeMaxPending: 0
+  });
+  assert.equal(result.frozen, 0, "nothing frozen at capacity");
+  assert.equal(store.listConflictPending().length, 0, "no pending rows");
+  assert.ok(ctx.warnings.some((m) => m.includes("freeze queue full")), "capacity warning logged");
+  store.close();
+});
+
+test("runDream freeze store failure never blocks the run (fail-safe)", async () => {
+  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 });
+  service.saveConflictPending = () => { throw new Error("pending store boom"); };
+  service.countConflictPending = () => { throw new Error("count boom"); };
+  const ctx = freezeCtx({ conflicts: [{ action: "conflict", winner: w.id, loser: l.id, reason: "x" }] });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat", conflictFreezeEnabled: true
+  });
+  assert.equal(result.ok, true, "run completes despite freeze store failure");
+  assert.equal(result.frozen, 0, "nothing frozen");
+  assert.ok(ctx.warnings.length >= 1, "freeze failure logged");
+  assert.equal(store.getById(l.id).archived, false, "no side effects on memories");
+  assert.equal(store.getById(w.id).content, "8月20日", "winner untouched");
+  store.close();
+});