@modusensus/dsh-mneme 0.6.6 → 0.6.8

package/test/normalize-decisions.test.js

@@ -1,120 +1,120 @@
-// Field-name normalization guard (v0.5.3): thinking-type models
-// (deepseek-v4-flash etc.) sometimes ignore the prompt's exact decision schema
-// and emit alias keys —实测方案 A 输出 "consolidation"/"target_ids"、方案 B
-// 输出 "action"/"targetIds"，都不是插件要求的 "action"/"ids"。normalizeDecisions
-// 在 validateDecisions 之前把这些变体重写回规范字段名，让"语义正确但 schema
-// 不听话"的输出仍被应用，而不是整单被拒。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { normalizeDecisions, createDreamScheduler } from "../src/dream.js";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-test("normalizeDecisions: canonical decisions pass through untouched", () => {
-  const raw = [
-    { action: "merge", ids: ["m1", "m2"], keepSource: "m1", title: "t", content: "c", importance: 4, reason: "主题相近" },
-    { action: "conflict", winner: "m3", loser: "m4", reason: "矛盾" },
-    { action: "update", ids: ["m5"], content: "修正" },
-    { action: "archive", ids: ["m6"], reason: "过时" },
-    { action: "create", type: "pattern", title: "新模式", content: "发现", importance: 3 }
-  ];
-  assert.deepEqual(normalizeDecisions(raw), raw);
-});
-
-test("normalizeDecisions: alias keys rewritten to canonical names", () => {
-  const raw = [
-    { consolidation: "merge", target_ids: ["m1", "m2"], keep_source: "m1", new_title: "t", new_content: "c", priority: 4, rationale: "主题相近" },
-    { action: "conflict", winner_id: "m3", loser_id: "m4", why: "矛盾" },
-    { action: "update", targetIds: ["m5"], merged_content: "修正" },
-    { action: "archive", memory_ids: ["m6"] }
-  ];
-  assert.deepEqual(normalizeDecisions(raw), [
-    { action: "merge", ids: ["m1", "m2"], keepSource: "m1", title: "t", content: "c", importance: 4, reason: "主题相近" },
-    { action: "conflict", winner: "m3", loser: "m4", reason: "矛盾" },
-    { action: "update", ids: ["m5"], content: "修正" },
-    { action: "archive", ids: ["m6"] }
-  ]);
-});
-
-test("normalizeDecisions: action value synonyms normalized", () => {
-  const raw = [
-    { action: "archived", ids: ["m1"], reason: "重复" },
-    { action: "consolidation", target_ids: ["m2", "m3"], keep_source: "m2" },
-    { action: "combine", targetIds: ["m4", "m5"], keeper: "m5" },
-    { action: "Remove", memory_ids: ["m6"] }
-  ];
-  const normalized = normalizeDecisions(raw);
-  assert.equal(normalized[0].action, "archive");
-  assert.equal(normalized[1].action, "merge");
-  assert.equal(normalized[1].ids[0], "m2");
-  assert.equal(normalized[2].action, "merge");
-  assert.equal(normalized[2].keepSource, "m5");
-  assert.equal(normalized[3].action, "archive");
-});
-
-test("normalizeDecisions: wrapper object around the array is unwrapped", () => {
-  const raw = { consolidation: [{ action: "merge", ids: ["m1"], keepSource: "m1", title: "t", content: "c" }] };
-  assert.deepEqual(normalizeDecisions(raw), [
-    { action: "merge", ids: ["m1"], keepSource: "m1", title: "t", content: "c" }
-  ]);
-  const raw2 = { decisions: [{ action: "archive", target_ids: ["m9"] }] };
-  assert.deepEqual(normalizeDecisions(raw2), [{ action: "archive", ids: ["m9"] }]);
-});
-
-test("normalizeDecisions: single decision object (non-array) normalized too", () => {
-  const raw = { action: "update", targetIds: ["m1"], new_content: "修正" };
-  assert.deepEqual(normalizeDecisions(raw), [{ action: "update", ids: ["m1"], content: "修正" }]);
-});
-
-test("normalizeDecisions: single-string ids become a one-element array", () => {
-  const raw = [{ action: "archive", target_id: "m7" }];
-  // target_id (singular) is not an alias key — the raw key survives untouched
-  // and validateDecisions rejects it (safe side). But targetIds (plural, string)
-  // IS mapped and wrapped.
-  const raw2 = [{ action: "archive", targetIds: "m7" }];
-  assert.deepEqual(normalizeDecisions(raw2), [{ action: "archive", ids: ["m7"] }]);
-  assert.deepEqual(normalizeDecisions(raw), [{ action: "archive", target_id: "m7" }]);
-});
-
-test("normalizeDecisions: create keeps its type field (never mistaken for action)", () => {
-  const raw = { action: "create", type: "preference", title: "语言", content: "中文", importance: 3 };
-  assert.deepEqual(normalizeDecisions(raw), [
-    { action: "create", type: "preference", title: "语言", content: "中文", importance: 3 }
-  ]);
-});
-
-test("normalizeDecisions: null / non-parseable returns as-is (caller's no-json branch)", () => {
-  assert.equal(normalizeDecisions(null), null);
-  assert.equal(normalizeDecisions(undefined), undefined);
-  assert.equal(normalizeDecisions("not json"), "not json");
-});
-
-test("dream runDream applies alias-key consolidation output end-to-end", async () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
-  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
-  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
-  const ctx = {
-    logger: { warn: () => {} },
-    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
-    llm: {
-      async *stream(options) {
-        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
-          // deepseek-v4-flash 实测风格：consolidation 当 action、target_ids 当 ids
-          yield { type: "text-delta", index: 0, text: JSON.stringify([
-            { consolidation: "merge", target_ids: [a.id, b.id], keep_source: b.id, new_title: "插件总览", new_content: "合并内容", priority: 4 }
-          ]) };
-        } else {
-          yield { type: "text-delta", index: 0, text: "记忆库总览：默认摘要。" };
-        }
-        yield { type: "finish", reason: { kind: "stop" } };
-      }
-    }
-  };
-  const result = await dream.runDream(ctx, service, {});
-  assert.equal(result.ok, true, "alias-key output must not be rejected wholesale");
-  assert.ok(result.applied > 0, "alias-key decisions still land changes");
-  store.close();
-});
+// Field-name normalization guard (v0.5.3): thinking-type models
+// (deepseek-v4-flash etc.) sometimes ignore the prompt's exact decision schema
+// and emit alias keys —实测方案 A 输出 "consolidation"/"target_ids"、方案 B
+// 输出 "action"/"targetIds"，都不是插件要求的 "action"/"ids"。normalizeDecisions
+// 在 validateDecisions 之前把这些变体重写回规范字段名，让"语义正确但 schema
+// 不听话"的输出仍被应用，而不是整单被拒。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { normalizeDecisions, createDreamScheduler } from "../src/dream.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+test("normalizeDecisions: canonical decisions pass through untouched", () => {
+  const raw = [
+    { action: "merge", ids: ["m1", "m2"], keepSource: "m1", title: "t", content: "c", importance: 4, reason: "主题相近" },
+    { action: "conflict", winner: "m3", loser: "m4", reason: "矛盾" },
+    { action: "update", ids: ["m5"], content: "修正" },
+    { action: "archive", ids: ["m6"], reason: "过时" },
+    { action: "create", type: "pattern", title: "新模式", content: "发现", importance: 3 }
+  ];
+  assert.deepEqual(normalizeDecisions(raw), raw);
+});
+
+test("normalizeDecisions: alias keys rewritten to canonical names", () => {
+  const raw = [
+    { consolidation: "merge", target_ids: ["m1", "m2"], keep_source: "m1", new_title: "t", new_content: "c", priority: 4, rationale: "主题相近" },
+    { action: "conflict", winner_id: "m3", loser_id: "m4", why: "矛盾" },
+    { action: "update", targetIds: ["m5"], merged_content: "修正" },
+    { action: "archive", memory_ids: ["m6"] }
+  ];
+  assert.deepEqual(normalizeDecisions(raw), [
+    { action: "merge", ids: ["m1", "m2"], keepSource: "m1", title: "t", content: "c", importance: 4, reason: "主题相近" },
+    { action: "conflict", winner: "m3", loser: "m4", reason: "矛盾" },
+    { action: "update", ids: ["m5"], content: "修正" },
+    { action: "archive", ids: ["m6"] }
+  ]);
+});
+
+test("normalizeDecisions: action value synonyms normalized", () => {
+  const raw = [
+    { action: "archived", ids: ["m1"], reason: "重复" },
+    { action: "consolidation", target_ids: ["m2", "m3"], keep_source: "m2" },
+    { action: "combine", targetIds: ["m4", "m5"], keeper: "m5" },
+    { action: "Remove", memory_ids: ["m6"] }
+  ];
+  const normalized = normalizeDecisions(raw);
+  assert.equal(normalized[0].action, "archive");
+  assert.equal(normalized[1].action, "merge");
+  assert.equal(normalized[1].ids[0], "m2");
+  assert.equal(normalized[2].action, "merge");
+  assert.equal(normalized[2].keepSource, "m5");
+  assert.equal(normalized[3].action, "archive");
+});
+
+test("normalizeDecisions: wrapper object around the array is unwrapped", () => {
+  const raw = { consolidation: [{ action: "merge", ids: ["m1"], keepSource: "m1", title: "t", content: "c" }] };
+  assert.deepEqual(normalizeDecisions(raw), [
+    { action: "merge", ids: ["m1"], keepSource: "m1", title: "t", content: "c" }
+  ]);
+  const raw2 = { decisions: [{ action: "archive", target_ids: ["m9"] }] };
+  assert.deepEqual(normalizeDecisions(raw2), [{ action: "archive", ids: ["m9"] }]);
+});
+
+test("normalizeDecisions: single decision object (non-array) normalized too", () => {
+  const raw = { action: "update", targetIds: ["m1"], new_content: "修正" };
+  assert.deepEqual(normalizeDecisions(raw), [{ action: "update", ids: ["m1"], content: "修正" }]);
+});
+
+test("normalizeDecisions: single-string ids become a one-element array", () => {
+  const raw = [{ action: "archive", target_id: "m7" }];
+  // target_id (singular) is not an alias key — the raw key survives untouched
+  // and validateDecisions rejects it (safe side). But targetIds (plural, string)
+  // IS mapped and wrapped.
+  const raw2 = [{ action: "archive", targetIds: "m7" }];
+  assert.deepEqual(normalizeDecisions(raw2), [{ action: "archive", ids: ["m7"] }]);
+  assert.deepEqual(normalizeDecisions(raw), [{ action: "archive", target_id: "m7" }]);
+});
+
+test("normalizeDecisions: create keeps its type field (never mistaken for action)", () => {
+  const raw = { action: "create", type: "preference", title: "语言", content: "中文", importance: 3 };
+  assert.deepEqual(normalizeDecisions(raw), [
+    { action: "create", type: "preference", title: "语言", content: "中文", importance: 3 }
+  ]);
+});
+
+test("normalizeDecisions: null / non-parseable returns as-is (caller's no-json branch)", () => {
+  assert.equal(normalizeDecisions(null), null);
+  assert.equal(normalizeDecisions(undefined), undefined);
+  assert.equal(normalizeDecisions("not json"), "not json");
+});
+
+test("dream runDream applies alias-key consolidation output end-to-end", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const ctx = {
+    logger: { warn: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          // deepseek-v4-flash 实测风格：consolidation 当 action、target_ids 当 ids
+          yield { type: "text-delta", index: 0, text: JSON.stringify([
+            { consolidation: "merge", target_ids: [a.id, b.id], keep_source: b.id, new_title: "插件总览", new_content: "合并内容", priority: 4 }
+          ]) };
+        } else {
+          yield { type: "text-delta", index: 0, text: "记忆库总览：默认摘要。" };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, true, "alias-key output must not be rejected wholesale");
+  assert.ok(result.applied > 0, "alias-key decisions still land changes");
+  store.close();
+});

package/test/peer-blockers.test.js

@@ -1,190 +1,190 @@
-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 { fileURLToPath } from "node:url";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { createStore } from "../src/store.js";
-import { createMirror } from "../src/mirror.js";
-import { createService } from "../src/service.js";
-
-const execFileP = promisify(execFile);
-const STORE_PATH = fileURLToPath(new URL("../src/store.js", import.meta.url));
-
-/**
- * v0.3.8 回归测试（audit peer 6 项运行时阻断 → INSTALLATION_NOT_APPROVED）。
- *
- * 测试点：
- *  A. 崩溃窗口（真实语义）：store.save 在业务事务内原子递增 desired generation，
- *     崩溃在 COMMIT 后、syncMirror 前 → 重启 recoverMirror 仅凭
- *     generation > applied_generation 捕获并收敛（peer blocker 1）
- *  B. 业务写同事务原子性：INSERT 失败回滚时 generation 不得递增（peer blocker 1/3）
- *  C. 多进程并发原子递增：8 进程 × 10 次不丢增量（peer blocker 3）
- *  D. generation 上界/负数拒绝（peer blocker 6）
- */
-
-function setup(dbPath) {
-  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
-  const mirrorDir = join(dir, "mirror");
-  const store = createStore(dbPath ?? ":memory:");
-  const mirror = createMirror(mirrorDir);
-  const warns = [];
-  const logger = { warn: (...a) => warns.push(a.join(" ")) };
-  const service = createService({ store, mirror, config: {}, logger });
-  return { dir, mirrorDir, store, mirror, service, warns };
-}
-
-test("peer-A: 崩溃窗口——save 后（generation 已递增）不 sync 直接关闭重开，recoverMirror 捕获并收敛", () => {
-  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
-  const dbPath = join(dir, "mneme.db");
-  const mirrorDir = join(dir, "mirror");
-  try {
-    const store = createStore(dbPath);
-    const mirror = createMirror(mirrorDir);
-    const service = createService({ store, mirror, config: {}, logger: { warn() {} } });
-    try {
-      // 业务写：store.save 在事务内递增 desired generation，但不触发 mirror 渲染
-      store.save({ type: "project", title: "P", content: "x", importance: 3 });
-      const afterSave = store.getMirrorState();
-      assert.ok(afterSave.generation > afterSave.applied_generation,
-        "save 后 generation > applied（COMMIT 完成，mirror 未同步=崩溃窗口）");
-    } finally {
-      // 模拟崩溃：不调 syncMirror，直接关库
-      store.close();
-    }
-
-    // 重启：重新打开同一 DB，recoverMirror 必须捕获债务并收敛
-    const store2 = createStore(dbPath);
-    const mirror2 = createMirror(mirrorDir);
-    const service2 = createService({ store: store2, mirror: mirror2, config: {}, logger: { warn() {} } });
-    try {
-      const result = service2.recoverMirror();
-      assert.equal(result.recovered, true, "崩溃窗口必须被 recover 捕获");
-      assert.equal(result.error, null);
-      const state = store2.getMirrorState();
-      assert.equal(state.dirty, false, "收敛后 dirty 清");
-      assert.ok(state.generation <= state.applied_generation, "收敛后无未应用债务");
-    } finally {
-      store2.close();
-    }
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("peer-B: 业务写同事务原子性——INSERT 失败回滚时 generation 不得递增", () => {
-  const { dir, store } = setup();
-  try {
-    store.save({ id: "dup", type: "project", title: "A", content: "x", importance: 3 });
-    const before = store.getMirrorState().generation;
-    assert.throws(
-      () => store.save({ id: "dup", type: "project", title: "B", content: "y", importance: 3 }),
-      /UNIQUE|constraint/i,
-      "重复主键 INSERT 必须抛错"
-    );
-    assert.equal(store.getMirrorState().generation, before,
-      "回滚后 generation 不递增（写与 desired generation 同事务，失败一起回滚）");
-  } finally {
-    store.close();
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("peer-C: 多进程并发原子递增——8 进程×10 次 incrementGeneration 不丢增量", async () => {
-  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
-  const dbPath = join(dir, "concurrent.db");
-  const N = 8;
-  const M = 10;
-  try {
-    // 子进程脚本：打开同一 DB 文件，原子递增 M 次
-    const worker = `
-      const { createStore } = require(process.argv[1]);
-      const store = createStore(process.argv[2]);
-      for (let i = 0; i < ${M}; i++) { store.incrementGeneration(); }
-      store.close();
-    `;
-    await Promise.all(
-      Array.from({ length: N }, () =>
-        execFileP(process.execPath, ["-e", worker, STORE_PATH, dbPath], { timeout: 30000 })
-      )
-    );
-    const store = createStore(dbPath);
-    try {
-      const state = store.getMirrorState();
-      assert.equal(state.generation, N * M,
-        `并发 ${N} 进程 × ${M} 次必须无丢失增量，得到 ${state.generation}`);
-    } finally {
-      store.close();
-    }
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("peer-D: generation 上界与负数拒绝", () => {
-  const { dir, store } = setup();
-  try {
-    // 负数拒绝
-    assert.throws(() => store.setMirrorState({ generation: -1 }), RangeError, "负数必须拒绝");
-    assert.throws(() => store.setMirrorState({ applied_generation: -5 }), RangeError, "负数 applied 必须拒绝");
-    // 超 MAX_SAFE_INTEGER 拒绝
-    assert.throws(
-      () => store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER + 1 }),
-      RangeError,
-      "超出 MAX_SAFE_INTEGER 必须拒绝"
-    );
-    // 到上界后再 increment 必须抛错（读回不会 ERR_OUT_OF_RANGE）
-    store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER });
-    assert.throws(() => store.incrementGeneration(), /exceeded MAX_SAFE_INTEGER/, "上界后再递增必须抛错");
-    // 正常递增仍工作
-    store.setMirrorState({ generation: 5 });
-    assert.equal(store.incrementGeneration().generation, 6, "正常递增不受影响");
-  } finally {
-    store.close();
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("v0.3.9-A: compareAndUpdate 的 CAS UPDATE 与 generation 同事务——miss 不得递增", () => {
-  const { dir, store } = setup();
-  try {
-    const saved = store.save({ type: "project", title: "CAS 原子", content: "v0" });
-    const before = store.getById(saved.id);
-    const genBefore = store.getMirrorState().generation;
-
-    // 成功 CAS：业务写入 + generation 递增必须一次提交（同事务）
-    const updated = store.compareAndUpdate(saved.id, before.updated_at, { content: "v1" });
-    assert.ok(updated, "当前版本 CAS 必须成功");
-    const genAfterOk = store.getMirrorState().generation;
-    assert.equal(genAfterOk, genBefore + 1, "成功 CAS 必须恰好递增一次 generation");
-
-    // miss CAS：不写任何东西，generation 也不得递增
-    const stale = store.getById(saved.id).updated_at; // v1 的 token
-    store.compareAndUpdate(saved.id, before.updated_at, { content: "v2" }); // 用旧 token → miss
-    assert.equal(store.getById(saved.id).content, "v1", "miss 不得改数据");
-    assert.equal(store.getMirrorState().generation, genAfterOk,
-      "CAS miss 不得递增 generation（UPDATE 与 increment 必须同事务）");
-  } finally {
-    store.close();
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("v0.3.9-F: generation 非整数必须拒绝（不得截断）", () => {
-  const { dir, store } = setup();
-  try {
-    // 审计 peer F：1.5 这类小数此前被 Math.trunc 截断 + SQLite CHECK 接受 → 静默脏值。
-    // fail-closed：JS 与 SQL 统一只接受整数。
-    assert.throws(() => store.setMirrorState({ generation: 1.5 }), RangeError, "小数 generation 必须拒绝");
-    assert.throws(() => store.setMirrorState({ applied_generation: -1.5 }), RangeError, "负数小数必须拒绝");
-    assert.throws(() => store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER + 0.5 }), RangeError, "超界小数必须拒绝");
-    // 整数仍正常
-    const s = store.setMirrorState({ generation: 7 });
-    assert.equal(s.generation, 7, "整数 generation 正常");
-  } finally {
-    store.close();
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+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 { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createStore } from "../src/store.js";
+import { createMirror } from "../src/mirror.js";
+import { createService } from "../src/service.js";
+
+const execFileP = promisify(execFile);
+const STORE_PATH = fileURLToPath(new URL("../src/store.js", import.meta.url));
+
+/**
+ * v0.3.8 回归测试（audit peer 6 项运行时阻断 → INSTALLATION_NOT_APPROVED）。
+ *
+ * 测试点：
+ *  A. 崩溃窗口（真实语义）：store.save 在业务事务内原子递增 desired generation，
+ *     崩溃在 COMMIT 后、syncMirror 前 → 重启 recoverMirror 仅凭
+ *     generation > applied_generation 捕获并收敛（peer blocker 1）
+ *  B. 业务写同事务原子性：INSERT 失败回滚时 generation 不得递增（peer blocker 1/3）
+ *  C. 多进程并发原子递增：8 进程 × 10 次不丢增量（peer blocker 3）
+ *  D. generation 上界/负数拒绝（peer blocker 6）
+ */
+
+function setup(dbPath) {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
+  const mirrorDir = join(dir, "mirror");
+  const store = createStore(dbPath ?? ":memory:");
+  const mirror = createMirror(mirrorDir);
+  const warns = [];
+  const logger = { warn: (...a) => warns.push(a.join(" ")) };
+  const service = createService({ store, mirror, config: {}, logger });
+  return { dir, mirrorDir, store, mirror, service, warns };
+}
+
+test("peer-A: 崩溃窗口——save 后（generation 已递增）不 sync 直接关闭重开，recoverMirror 捕获并收敛", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
+  const dbPath = join(dir, "mneme.db");
+  const mirrorDir = join(dir, "mirror");
+  try {
+    const store = createStore(dbPath);
+    const mirror = createMirror(mirrorDir);
+    const service = createService({ store, mirror, config: {}, logger: { warn() {} } });
+    try {
+      // 业务写：store.save 在事务内递增 desired generation，但不触发 mirror 渲染
+      store.save({ type: "project", title: "P", content: "x", importance: 3 });
+      const afterSave = store.getMirrorState();
+      assert.ok(afterSave.generation > afterSave.applied_generation,
+        "save 后 generation > applied（COMMIT 完成，mirror 未同步=崩溃窗口）");
+    } finally {
+      // 模拟崩溃：不调 syncMirror，直接关库
+      store.close();
+    }
+
+    // 重启：重新打开同一 DB，recoverMirror 必须捕获债务并收敛
+    const store2 = createStore(dbPath);
+    const mirror2 = createMirror(mirrorDir);
+    const service2 = createService({ store: store2, mirror: mirror2, config: {}, logger: { warn() {} } });
+    try {
+      const result = service2.recoverMirror();
+      assert.equal(result.recovered, true, "崩溃窗口必须被 recover 捕获");
+      assert.equal(result.error, null);
+      const state = store2.getMirrorState();
+      assert.equal(state.dirty, false, "收敛后 dirty 清");
+      assert.ok(state.generation <= state.applied_generation, "收敛后无未应用债务");
+    } finally {
+      store2.close();
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("peer-B: 业务写同事务原子性——INSERT 失败回滚时 generation 不得递增", () => {
+  const { dir, store } = setup();
+  try {
+    store.save({ id: "dup", type: "project", title: "A", content: "x", importance: 3 });
+    const before = store.getMirrorState().generation;
+    assert.throws(
+      () => store.save({ id: "dup", type: "project", title: "B", content: "y", importance: 3 }),
+      /UNIQUE|constraint/i,
+      "重复主键 INSERT 必须抛错"
+    );
+    assert.equal(store.getMirrorState().generation, before,
+      "回滚后 generation 不递增（写与 desired generation 同事务，失败一起回滚）");
+  } finally {
+    store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("peer-C: 多进程并发原子递增——8 进程×10 次 incrementGeneration 不丢增量", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-peer-"));
+  const dbPath = join(dir, "concurrent.db");
+  const N = 8;
+  const M = 10;
+  try {
+    // 子进程脚本：打开同一 DB 文件，原子递增 M 次
+    const worker = `
+      const { createStore } = require(process.argv[1]);
+      const store = createStore(process.argv[2]);
+      for (let i = 0; i < ${M}; i++) { store.incrementGeneration(); }
+      store.close();
+    `;
+    await Promise.all(
+      Array.from({ length: N }, () =>
+        execFileP(process.execPath, ["-e", worker, STORE_PATH, dbPath], { timeout: 30000 })
+      )
+    );
+    const store = createStore(dbPath);
+    try {
+      const state = store.getMirrorState();
+      assert.equal(state.generation, N * M,
+        `并发 ${N} 进程 × ${M} 次必须无丢失增量，得到 ${state.generation}`);
+    } finally {
+      store.close();
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("peer-D: generation 上界与负数拒绝", () => {
+  const { dir, store } = setup();
+  try {
+    // 负数拒绝
+    assert.throws(() => store.setMirrorState({ generation: -1 }), RangeError, "负数必须拒绝");
+    assert.throws(() => store.setMirrorState({ applied_generation: -5 }), RangeError, "负数 applied 必须拒绝");
+    // 超 MAX_SAFE_INTEGER 拒绝
+    assert.throws(
+      () => store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER + 1 }),
+      RangeError,
+      "超出 MAX_SAFE_INTEGER 必须拒绝"
+    );
+    // 到上界后再 increment 必须抛错（读回不会 ERR_OUT_OF_RANGE）
+    store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER });
+    assert.throws(() => store.incrementGeneration(), /exceeded MAX_SAFE_INTEGER/, "上界后再递增必须抛错");
+    // 正常递增仍工作
+    store.setMirrorState({ generation: 5 });
+    assert.equal(store.incrementGeneration().generation, 6, "正常递增不受影响");
+  } finally {
+    store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("v0.3.9-A: compareAndUpdate 的 CAS UPDATE 与 generation 同事务——miss 不得递增", () => {
+  const { dir, store } = setup();
+  try {
+    const saved = store.save({ type: "project", title: "CAS 原子", content: "v0" });
+    const before = store.getById(saved.id);
+    const genBefore = store.getMirrorState().generation;
+
+    // 成功 CAS：业务写入 + generation 递增必须一次提交（同事务）
+    const updated = store.compareAndUpdate(saved.id, before.updated_at, { content: "v1" });
+    assert.ok(updated, "当前版本 CAS 必须成功");
+    const genAfterOk = store.getMirrorState().generation;
+    assert.equal(genAfterOk, genBefore + 1, "成功 CAS 必须恰好递增一次 generation");
+
+    // miss CAS：不写任何东西，generation 也不得递增
+    const stale = store.getById(saved.id).updated_at; // v1 的 token
+    store.compareAndUpdate(saved.id, before.updated_at, { content: "v2" }); // 用旧 token → miss
+    assert.equal(store.getById(saved.id).content, "v1", "miss 不得改数据");
+    assert.equal(store.getMirrorState().generation, genAfterOk,
+      "CAS miss 不得递增 generation（UPDATE 与 increment 必须同事务）");
+  } finally {
+    store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("v0.3.9-F: generation 非整数必须拒绝（不得截断）", () => {
+  const { dir, store } = setup();
+  try {
+    // 审计 peer F：1.5 这类小数此前被 Math.trunc 截断 + SQLite CHECK 接受 → 静默脏值。
+    // fail-closed：JS 与 SQL 统一只接受整数。
+    assert.throws(() => store.setMirrorState({ generation: 1.5 }), RangeError, "小数 generation 必须拒绝");
+    assert.throws(() => store.setMirrorState({ applied_generation: -1.5 }), RangeError, "负数小数必须拒绝");
+    assert.throws(() => store.setMirrorState({ generation: Number.MAX_SAFE_INTEGER + 0.5 }), RangeError, "超界小数必须拒绝");
+    // 整数仍正常
+    const s = store.setMirrorState({ generation: 7 });
+    assert.equal(s.generation, 7, "整数 generation 正常");
+  } finally {
+    store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});