@modusensus/dsh-mneme 0.14.0-beta.1 → 0.14.0-beta.2

package/test/distill-tx-embed-gap.test.js

@@ -1,110 +1,110 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-// ============================================================ distill-tx-embed-gap
-// 回归锁：此前 scheduleEmbed 在 txDepth>0 时首行直接 return（注释写 deferred，
-// 实际 transaction() 从不补跑）——与 #372 的实体抽取是同一个 bug 模板，只是受害者
-// 换成了嵌入：自动蒸馏（summarize 全部走 service.transaction）写入的 session:* 行
-// 100% 拿不到向量，语义检索对这批行永远失明。照 #372 的修复模板改为入队、提交后
-// 补跑、回滚截断。五把锁与 test/entities.test.js 的 #372 锁一一对应，锁的是
-// 「commit 才补跑、回滚绝不补跑」这个契约本身——任何一侧改回丢弃或回滚也补跑，
-// 这里当场红。
-
-function makeService(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-// 8 维定值向量；schedule 分支同步写回（语义同真实 embedder：调度即含写回），
-// 让整条链路确定性、无异步漂移。embedSingle 仅供 ready-gate/embedSingle 分支
-// 的调用方使用，本文件的锁都走 schedule 分支。
-function makeEmbedder(store, embedded) {
-  return {
-    schedule(memory) {
-      embedded.push(memory.id);
-      store.setEmbedding(memory.id, new Array(8).fill(0.5), "fake-model-hash");
-    },
-    embedSingle: async () => new Array(8).fill(0.5),
-  };
-}
-
-test("distill-tx: embedding queued inside transaction is written exactly once after commit", () => {
-  const { store, service } = makeService();
-  const embedded = [];
-  service.setEmbedder(makeEmbedder(store, embedded));
-  const r = service.transaction(() =>
-    service.saveWithDedupe({ type: "preference", title: "事务内创建", content: "x" })
-  );
-  const id = r.memory.id;
-  // 提交后补跑恰一次：向量非空、维度等于 embedder 输出（8 维）
-  assert.deepEqual(embedded, [id], "drain fires exactly once, after commit");
-  const row = store.db.prepare("SELECT embedding FROM memories WHERE id = ?").get(id);
-  const vec = JSON.parse(row.embedding);
-  assert.equal(vec.length, 8, "vector dimension equals embedder output");
-  store.close();
-});
-
-test("distill-tx: nothing schedules while txDepth > 0 (queued, not dropped, not immediate)", () => {
-  const { store, service } = makeService();
-  const embedded = [];
-  service.setEmbedder(makeEmbedder(store, embedded));
-  service.transaction(() => {
-    service.saveWithDedupe({ type: "preference", title: "事务内观察", content: "x" });
-    // 事务内此刻不得触发（排进队列而不是丢弃，也不是立即跑）
-    assert.equal(embedded.length, 0, "no embedding while txDepth > 0");
-  });
-  assert.equal(embedded.length, 1, "queued entry drains after commit");
-  store.close();
-});
-
-test("distill-tx: rolled-back transaction never embeds rolled-back rows", () => {
-  const { store, service } = makeService();
-  const embedded = [];
-  service.setEmbedder(makeEmbedder(store, embedded));
-  assert.throws(() => {
-    service.transaction(() => {
-      service.saveWithDedupe({ type: "preference", title: "会被回滚", content: "x" });
-      throw new Error("boom");
-    });
-  }, /boom/);
-  assert.equal(embedded.length, 0, "no embedding against rolled-back rows");
-  assert.equal(store.count(), 0, "row itself rolled back");
-  store.close();
-});
-
-// 与 #372 复审补锁同构：内层回滚截断只丢内层条目，外层提交 drain 外层条目。
-test("distill-tx: inner rollback drops only inner entries; outer commit drains the rest", () => {
-  const { store, service } = makeService();
-  const embedded = [];
-  service.setEmbedder(makeEmbedder(store, embedded));
-  const ids = [];
-  service.transaction(() => {
-    ids.push(service.saveWithDedupe({ type: "preference", title: "外层A", content: "x" }).memory.id);
-    try {
-      service.transaction(() => {
-        service.saveWithDedupe({ type: "preference", title: "内层回滚", content: "x" });
-        throw new Error("inner boom");
-      });
-    } catch { /* 内层回滚，外层继续 */ }
-    ids.push(service.saveWithDedupe({ type: "preference", title: "外层B", content: "x" }).memory.id);
-  });
-  assert.deepEqual(embedded.sort(), ids.sort(), "inner rolled-back row never embedded; outer rows drain once");
-  assert.equal(store.count(), 2);
-  store.close();
-});
-
-test("distill-tx: no unbounded cap — large transaction drains every entry", () => {
-  const { store, service } = makeService();
-  const embedded = [];
-  service.setEmbedder(makeEmbedder(store, embedded));
-  service.transaction(() => {
-    for (let i = 0; i < 150; i++) {
-      service.saveWithDedupe({ type: "preference", title: `批量${i}`, content: "x" });
-    }
-  });
-  assert.equal(embedded.length, 150, "no silent drop at any queue cap");
-  store.close();
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// ============================================================ distill-tx-embed-gap
+// 回归锁：此前 scheduleEmbed 在 txDepth>0 时首行直接 return（注释写 deferred，
+// 实际 transaction() 从不补跑）——与 #372 的实体抽取是同一个 bug 模板，只是受害者
+// 换成了嵌入：自动蒸馏（summarize 全部走 service.transaction）写入的 session:* 行
+// 100% 拿不到向量，语义检索对这批行永远失明。照 #372 的修复模板改为入队、提交后
+// 补跑、回滚截断。五把锁与 test/entities.test.js 的 #372 锁一一对应，锁的是
+// 「commit 才补跑、回滚绝不补跑」这个契约本身——任何一侧改回丢弃或回滚也补跑，
+// 这里当场红。
+
+function makeService(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+// 8 维定值向量；schedule 分支同步写回（语义同真实 embedder：调度即含写回），
+// 让整条链路确定性、无异步漂移。embedSingle 仅供 ready-gate/embedSingle 分支
+// 的调用方使用，本文件的锁都走 schedule 分支。
+function makeEmbedder(store, embedded) {
+  return {
+    schedule(memory) {
+      embedded.push(memory.id);
+      store.setEmbedding(memory.id, new Array(8).fill(0.5), "fake-model-hash");
+    },
+    embedSingle: async () => new Array(8).fill(0.5),
+  };
+}
+
+test("distill-tx: embedding queued inside transaction is written exactly once after commit", () => {
+  const { store, service } = makeService();
+  const embedded = [];
+  service.setEmbedder(makeEmbedder(store, embedded));
+  const r = service.transaction(() =>
+    service.saveWithDedupe({ type: "preference", title: "事务内创建", content: "x" })
+  );
+  const id = r.memory.id;
+  // 提交后补跑恰一次：向量非空、维度等于 embedder 输出（8 维）
+  assert.deepEqual(embedded, [id], "drain fires exactly once, after commit");
+  const row = store.db.prepare("SELECT embedding FROM memories WHERE id = ?").get(id);
+  const vec = JSON.parse(row.embedding);
+  assert.equal(vec.length, 8, "vector dimension equals embedder output");
+  store.close();
+});
+
+test("distill-tx: nothing schedules while txDepth > 0 (queued, not dropped, not immediate)", () => {
+  const { store, service } = makeService();
+  const embedded = [];
+  service.setEmbedder(makeEmbedder(store, embedded));
+  service.transaction(() => {
+    service.saveWithDedupe({ type: "preference", title: "事务内观察", content: "x" });
+    // 事务内此刻不得触发（排进队列而不是丢弃，也不是立即跑）
+    assert.equal(embedded.length, 0, "no embedding while txDepth > 0");
+  });
+  assert.equal(embedded.length, 1, "queued entry drains after commit");
+  store.close();
+});
+
+test("distill-tx: rolled-back transaction never embeds rolled-back rows", () => {
+  const { store, service } = makeService();
+  const embedded = [];
+  service.setEmbedder(makeEmbedder(store, embedded));
+  assert.throws(() => {
+    service.transaction(() => {
+      service.saveWithDedupe({ type: "preference", title: "会被回滚", content: "x" });
+      throw new Error("boom");
+    });
+  }, /boom/);
+  assert.equal(embedded.length, 0, "no embedding against rolled-back rows");
+  assert.equal(store.count(), 0, "row itself rolled back");
+  store.close();
+});
+
+// 与 #372 复审补锁同构：内层回滚截断只丢内层条目，外层提交 drain 外层条目。
+test("distill-tx: inner rollback drops only inner entries; outer commit drains the rest", () => {
+  const { store, service } = makeService();
+  const embedded = [];
+  service.setEmbedder(makeEmbedder(store, embedded));
+  const ids = [];
+  service.transaction(() => {
+    ids.push(service.saveWithDedupe({ type: "preference", title: "外层A", content: "x" }).memory.id);
+    try {
+      service.transaction(() => {
+        service.saveWithDedupe({ type: "preference", title: "内层回滚", content: "x" });
+        throw new Error("inner boom");
+      });
+    } catch { /* 内层回滚，外层继续 */ }
+    ids.push(service.saveWithDedupe({ type: "preference", title: "外层B", content: "x" }).memory.id);
+  });
+  assert.deepEqual(embedded.sort(), ids.sort(), "inner rolled-back row never embedded; outer rows drain once");
+  assert.equal(store.count(), 2);
+  store.close();
+});
+
+test("distill-tx: no unbounded cap — large transaction drains every entry", () => {
+  const { store, service } = makeService();
+  const embedded = [];
+  service.setEmbedder(makeEmbedder(store, embedded));
+  service.transaction(() => {
+    for (let i = 0; i < 150; i++) {
+      service.saveWithDedupe({ type: "preference", title: `批量${i}`, content: "x" });
+    }
+  });
+  assert.equal(embedded.length, 150, "no silent drop at any queue cap");
+  store.close();
+});

package/test/docs-config-keys.test.js

@@ -1,65 +1,65 @@
-// 「CONFIGURATION.md 是全键参考」这句声明需要一条闸门，否则它会慢慢变成谎话：
-// 2026-10 审计实测有 11 个 schema 键（graph 组 8 个、sensitiveScanEnabled、
-// injectTimePrefix、actionPipelineEnabled）在文档与双 README 里一个字都没有，
-// 而它们里有安全开关。锁法：从 Config({}) 的默认值深挖叶子键，要求每个键名
-// （或它的父路径，用于 heatTypeDecay 这类整表描述）在文档里出现。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-import { Config } from "../src/config.js";
-
-const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-const doc = readFileSync(path.join(root, "docs", "CONFIGURATION.md"), "utf8");
-const cfgSrc = readFileSync(path.join(root, "src", "config.js"), "utf8");
-
-function leafKeys(obj, prefix) {
-  const out = [];
-  for (const [k, v] of Object.entries(obj)) {
-    const p = prefix ? prefix + "." + k : k;
-    if (v && typeof v === "object" && !Array.isArray(v)) { out.push(...leafKeys(v, p)); continue; }
-    out.push({ path: p, leaf: k, parent: prefix || "" });
-  }
-  return out;
-}
-
-// 父路径回退是给「整表说明」用的例外，白名单写死在这里而不是「任何父路径都
-// 放行」——否则往 writeAdmission 里加个子键，只要文档提到 writeAdmission 就过，
-// 测试原本要防的漏键会静默复发（评审指出的漏洞）。新增例外必须显式加一行。
-const PARENT_ONLY_OK = new Set(["heatTypeDecay"]);
-
-test("CONFIGURATION.md 覆盖 schema 的每一个键", () => {
-  const keys = leafKeys(Config({}), "");
-  assert.ok(keys.length > 150, "键枚举失败会静默返回 0 项，先锁下限");
-  const missing = keys.filter((k) => {
-    // 完整路径优先（"writeAdmission.enabled"），其次才是显式白名单里的整表父路径。
-    if (doc.includes(k.path)) return false;
-    if (k.parent && PARENT_ONLY_OK.has(k.parent) && doc.includes(k.parent)) return false;
-    // 表里写的是裸键名也认（绝大多数顶层键就是这么写的）。
-    return !doc.includes(k.leaf);
-  });
-  assert.deepEqual(missing.map((m) => m.path), []);
-});
-
-// lightMode 清单是有边界的一节：整份文档 grep 会让「删掉清单里的某一行」照样
-// 通过（图谱表里还留着同名键），测试要盯的漏项就藏在那个缝里。
-function lightSection(text) {
-  const start = text.indexOf("lightMode 强制关闭清单");
-  assert.ok(start >= 0, "文档里应有「lightMode 强制关闭清单」一节");
-  const rest = text.slice(start);
-  const end = rest.indexOf("预设只是默认值");
-  return end > 0 ? rest.slice(0, end) : rest;
-}
-
-test("LIGHT_MODE_OFF 的每一项都写进了文档的轻量档清单", () => {
-  // LIGHT_MODE_OFF 没有导出，只能解析源码文本；先锁解析结果的长度，防止
-  // 正则失配时这个用例变成「空数组 ⊂ 文档」的永真断言。
-  const m = cfgSrc.match(/const LIGHT_MODE_OFF = \[([\s\S]*?)\];/);
-  assert.ok(m, "LIGHT_MODE_OFF 应从 src/config.js 中解析出来");
-  const names = [...m[1].matchAll(/"([^"]+)"/g)].map((x) => x[1]);
-  assert.ok(names.length >= 20, "解析到 " + names.length + " 项，少于预期的 21 项");
-  const section = lightSection(doc);
-  const missing = names.filter((n) => !section.includes(n));
-  assert.deepEqual(missing, []);
-});
+// 「CONFIGURATION.md 是全键参考」这句声明需要一条闸门，否则它会慢慢变成谎话：
+// 2026-10 审计实测有 11 个 schema 键（graph 组 8 个、sensitiveScanEnabled、
+// injectTimePrefix、actionPipelineEnabled）在文档与双 README 里一个字都没有，
+// 而它们里有安全开关。锁法：从 Config({}) 的默认值深挖叶子键，要求每个键名
+// （或它的父路径，用于 heatTypeDecay 这类整表描述）在文档里出现。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { Config } from "../src/config.js";
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const doc = readFileSync(path.join(root, "docs", "CONFIGURATION.md"), "utf8");
+const cfgSrc = readFileSync(path.join(root, "src", "config.js"), "utf8");
+
+function leafKeys(obj, prefix) {
+  const out = [];
+  for (const [k, v] of Object.entries(obj)) {
+    const p = prefix ? prefix + "." + k : k;
+    if (v && typeof v === "object" && !Array.isArray(v)) { out.push(...leafKeys(v, p)); continue; }
+    out.push({ path: p, leaf: k, parent: prefix || "" });
+  }
+  return out;
+}
+
+// 父路径回退是给「整表说明」用的例外，白名单写死在这里而不是「任何父路径都
+// 放行」——否则往 writeAdmission 里加个子键，只要文档提到 writeAdmission 就过，
+// 测试原本要防的漏键会静默复发（评审指出的漏洞）。新增例外必须显式加一行。
+const PARENT_ONLY_OK = new Set(["heatTypeDecay"]);
+
+test("CONFIGURATION.md 覆盖 schema 的每一个键", () => {
+  const keys = leafKeys(Config({}), "");
+  assert.ok(keys.length > 150, "键枚举失败会静默返回 0 项，先锁下限");
+  const missing = keys.filter((k) => {
+    // 完整路径优先（"writeAdmission.enabled"），其次才是显式白名单里的整表父路径。
+    if (doc.includes(k.path)) return false;
+    if (k.parent && PARENT_ONLY_OK.has(k.parent) && doc.includes(k.parent)) return false;
+    // 表里写的是裸键名也认（绝大多数顶层键就是这么写的）。
+    return !doc.includes(k.leaf);
+  });
+  assert.deepEqual(missing.map((m) => m.path), []);
+});
+
+// lightMode 清单是有边界的一节：整份文档 grep 会让「删掉清单里的某一行」照样
+// 通过（图谱表里还留着同名键），测试要盯的漏项就藏在那个缝里。
+function lightSection(text) {
+  const start = text.indexOf("lightMode 强制关闭清单");
+  assert.ok(start >= 0, "文档里应有「lightMode 强制关闭清单」一节");
+  const rest = text.slice(start);
+  const end = rest.indexOf("预设只是默认值");
+  return end > 0 ? rest.slice(0, end) : rest;
+}
+
+test("LIGHT_MODE_OFF 的每一项都写进了文档的轻量档清单", () => {
+  // LIGHT_MODE_OFF 没有导出，只能解析源码文本；先锁解析结果的长度，防止
+  // 正则失配时这个用例变成「空数组 ⊂ 文档」的永真断言。
+  const m = cfgSrc.match(/const LIGHT_MODE_OFF = \[([\s\S]*?)\];/);
+  assert.ok(m, "LIGHT_MODE_OFF 应从 src/config.js 中解析出来");
+  const names = [...m[1].matchAll(/"([^"]+)"/g)].map((x) => x[1]);
+  assert.ok(names.length >= 20, "解析到 " + names.length + " 项，少于预期的 21 项");
+  const section = lightSection(doc);
+  const missing = names.filter((n) => !section.includes(n));
+  assert.deepEqual(missing, []);
+});