@modusensus/dsh-mneme 0.3.7 → 0.3.9

package/test/mirror-generation.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { EventEmitter } from "node:events";
@@ -141,30 +141,33 @@ test("V0.3.6-C3: incrementGeneration 每次 +1，不动 dirty/applied", () => {
 
 // ── D. 逐 type 部分成功（store 层 setTypeStatus）──────────────────────────
 
-test("V0.3.6-D1: setTypeStatus 按 type 合并，partial patch 保留未传字段", () => {
+test("V0.3.6-D1: setTypeStatus 记录逐 type committed/failed/pending 回执（peer blocker 4）", () => {
   const { dir, store } = setup();
   try {
-    const s1 = store.setTypeStatus("project", { dirty: true, last_error: "e1" });
-    assert.equal(s1.type_status.project.dirty, true);
+    // 状态必填且必须合法
+    assert.throws(() => store.setTypeStatus("project", { applied_gen: 1 }), /status must be one of/, "缺 status 必须抛错");
+    assert.throws(() => store.setTypeStatus("project", { status: "bogus" }), /status must be one of/, "非法 status 必须抛错");
+
+    const s1 = store.setTypeStatus("project", { status: "failed", last_error: "e1" });
+    assert.equal(s1.type_status.project.status, "failed");
     assert.equal(s1.type_status.project.last_error, "e1");
 
-    const s2 = store.setTypeStatus("project", { applied_gen: 7 });
-    assert.equal(s2.type_status.project.applied_gen, 7, "partial 合并到同 type");
-    assert.equal(s2.type_status.project.dirty, true, "未传字段保留");
-    assert.equal(s2.type_status.project.last_error, "e1", "未传字段保留");
+    const s2 = store.setTypeStatus("project", { status: "committed", applied_gen: 7, last_error: null });
+    assert.equal(s2.type_status.project.status, "committed", "同 type 状态更新");
+    assert.equal(s2.type_status.project.applied_gen, 7);
 
-    const s3 = store.setTypeStatus("decision", { dirty: false, applied_gen: 7 });
-    assert.equal(s3.type_status.decision.applied_gen, 7, "另一 type 独立");
-    assert.equal(s3.type_status.project.dirty, true, "同 type 不受影响");
+    const s3 = store.setTypeStatus("decision", { status: "pending" });
+    assert.equal(s3.type_status.decision.status, "pending", "另一 type 独立");
+    assert.equal(s3.type_status.project.status, "committed", "同 type 不受影响");
 
     // getTypeStatus 返回同一解析后的 map
     assert.deepEqual(store.getTypeStatus(), {
-      project: { dirty: true, last_error: "e1", applied_gen: 7 },
-      decision: { dirty: false, applied_gen: 7 }
+      project: { status: "committed", applied_gen: 7, last_error: null },
+      decision: { status: "pending" }
     });
     // type_status 持久化为 JSON 文本
     const row = store.db.prepare("SELECT type_status FROM mirror_state WHERE id='main'").get();
-    assert.ok(JSON.parse(row.type_status).project.applied_gen === 7, "type_status 必须以 JSON 落库");
+    assert.ok(JSON.parse(row.type_status).project.status === "committed", "type_status 必须以 JSON 落库");
   } finally {
     store.close();
     rmSync(dir, { recursive: true, force: true });
@@ -253,7 +256,7 @@ test("V0.3.6-B1: markMirrorDirty 自身写失败——syncMirror 不抛、genera
 
 // ── D. 逐 type 部分成功（service 层 type_status 生命周期）─────────────────
 
-test("V0.3.6-D2: syncMirror 成功时逐 type 记录 clean（applied_gen=gen）", () => {
+test("V0.3.6-D2: syncMirror 成功时逐 type 记录 committed（applied_gen=gen）", () => {
   const { dir, store, mirror, service } = setup();
   try {
     const mock = makeSyncMock();
@@ -261,7 +264,7 @@ test("V0.3.6-D2: syncMirror 成功时逐 type 记录 clean（applied_gen=gen）"
     service.saveWithDedupe({ type: "project", title: "P", content: "x", importance: 3 });
     const ts = store.getTypeStatus();
     assert.ok(ts.project, "覆盖的 type 必须记录 type_status");
-    assert.equal(ts.project.dirty, false);
+    assert.equal(ts.project.status, "committed");
     assert.equal(ts.project.last_error, null);
     assert.equal(ts.project.applied_gen, store.getMirrorState().applied_generation,
       "type_status.applied_gen 与全局 applied 一致");
@@ -271,15 +274,15 @@ test("V0.3.6-D2: syncMirror 成功时逐 type 记录 clean（applied_gen=gen）"
   }
 });
 
-test("V0.3.6-D3: syncMirror 失败时逐 type 记录 dirty，recoverMirror 后追到最新 applied", () => {
+test("V0.3.6-D3: syncMirror 失败时逐 type 记录 failed，recoverMirror 后追到最新 applied", () => {
   const { dir, store, mirror, service } = setup();
   try {
     const mock = makeSyncMock();
     mirror.sync = mock.sync;
-    // 第一次成功建立 clean type_status
+    // 第一次成功建立 committed type_status
     mock.mode = "ok";
     service.saveWithDedupe({ type: "project", title: "P", content: "x", importance: 3 });
-    assert.equal(store.getTypeStatus().project.dirty, false);
+    assert.equal(store.getTypeStatus().project.status, "committed");
 
     // 模拟一次"债务轮次"：incrementGeneration 但未成功 applied（崩溃在 type_status 层面）
     store.incrementGeneration();
@@ -293,7 +296,7 @@ test("V0.3.6-D3: syncMirror 失败时逐 type 记录 dirty，recoverMirror 后
     const ts = store.getTypeStatus();
     assert.equal(ts.project.applied_gen, finalState.applied_generation,
       "type_status 必须追到最新 applied（部分成功债务表达并收敛）");
-    assert.equal(ts.project.dirty, false);
+    assert.equal(ts.project.status, "committed");
   } finally {
     store.close();
     rmSync(dir, { recursive: true, force: true });
@@ -454,10 +457,43 @@ test("V0.3.6-F1: 旧库（v0.3.5 5 列）打开自动 ALTER 加 3 列，不丢
     // 新方法在迁移后的库上正常工作
     const clean = store.markMirrorCleanForGeneration(0, "t");
     assert.equal(clean.dirty, false, "迁移库上 fence clean 正常工作");
-    store.setTypeStatus("project", { dirty: true, applied_gen: 0 });
-    assert.equal(store.getTypeStatus().project.dirty, true, "迁移库上 setTypeStatus 正常工作");
+    store.setTypeStatus("project", { status: "failed", applied_gen: 0 });
+    assert.equal(store.getTypeStatus().project.status, "failed", "迁移库上 setTypeStatus 正常工作");
     store.close();
   } finally {
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test("v0.3.9-D: mirror 逐 type 物理终态——兄弟 type 失败不误标已提交 type", () => {
+  const { dir, store, mirror, service } = setup();
+  try {
+    // 注入逐 type 故障：project 写成功、decision 抛错（模拟 EISDIR），其余 type 正常。
+    // 对应审计 D：project 文件已物理提交、decision 失败，状态必须逐 type 记录——
+    // 不能像旧逻辑那样整体批量标 failed。
+    const original = mirror.sync.bind(mirror);
+    mirror.sync = (memories) => {
+      const results = original(memories);
+      results.decision = { ok: false, error: "EISDIR: decision.md is a directory" };
+      return results;
+    };
+    // project 与 decision 都有真实记忆 → 触发逐 type 渲染
+    store.save({ id: "mem-project", type: "project", title: "已提交", content: "物理写入", importance: 3, tags: [] });
+    store.save({ id: "mem-decision", type: "decision", title: "写失败", content: "此 type 失败", importance: 3, tags: [] });
+    // 直接调 service 内部 syncMirror（通过一次写触发）
+    service.saveWithDedupe({ type: "project", title: "触发", content: "sync", importance: 3 });
+
+    const ts = store.getTypeStatus();
+    // project 物理提交 → 必须 committed，不能被 decision 失败拖成 failed
+    assert.equal(ts.project.status, "committed", "物理已提交的 type 必须标记 committed");
+    assert.equal(ts.decision.status, "failed", "失败的 type 必须标记 failed");
+    // 部分失败 = 未完全收敛 → dirty 必须持久
+    assert.equal(store.getMirrorState().dirty, true, "部分 type 失败必须持久 dirty");
+    // 镜像里 project 文件真实存在（物理终态已落地，不是整体失败）
+    const projectFile = mirror.filePath("project");
+    assert.ok(existsSync(projectFile), "project 镜像文件必须已物理写入");
+  } finally {
+    store.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/test/peer-blockers.test.js

@@ -0,0 +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 });
+  }
+});