@modusensus/dsh-mneme 0.8.14 → 0.8.15

package/test/graph-passive-confirm.test.js

@@ -1,92 +1,92 @@
-// issue #24 块4 被动确认（graphPassiveConfirm）测试。
-// 覆盖：默认关=零行为变化 / 开启=命中记忆的关联边 bump / heat 关但 passive
-// 开仍 bump（独立闸门）/ bump 只加不减封顶 / 无关联边的记忆触达安全降级。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-function putMem(store, service, { title, content, importance = 3 }) {
-  return service.saveWithDedupe({ type: "project", title, content, importance }).memory;
-}
-
-function linkRelToMem(store, { fromName, toName, memoryId, source = "llm" }) {
-  const a = store.findEntityByName(fromName) ?? store.createEntity({ name: fromName, type: "technology" });
-  const b = store.findEntityByName(toName) ?? store.createEntity({ name: toName, type: "technology" });
-  return store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "uses", memory_id: memoryId, source });
-}
-
-/** 跑一次检索（内部 touchRecalled 触发触达），返回 rows。 */
-async function searchOnce(service, query) {
-  return service.searchMemories(query, { mode: "auto" });
-}
-
-test("graphPassiveConfirm=false (default): touched memory does NOT bump relation weight", async () => {
-  const { store, service } = setup();
-  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
-  const rel = linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
-  assert.equal(rel.weight, 0.4);
-  await searchOnce(service, "数据库迁移");
-  // 默认关：检索触达不 bump（weight 保持 0.4）。
-  assert.equal(store.getRelationsByMemory(mem.id)[0].weight, 0.4, "weight unchanged by default");
-  store.close();
-});
-
-test("graphPassiveConfirm=true: touched memory bumps its linked relation weight", async () => {
-  const { store, service } = setup({ graphWeightEnabled: true, graphPassiveConfirm: true, graphWeightDelta: 0.1 });
-  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
-  const rel = linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
-  assert.equal(rel.weight, 0.4);
-  const rows = await searchOnce(service, "数据库迁移");
-  assert.ok(rows.some((r) => r.id === mem.id), "memory surfaced");
-  assert.ok(store.getRelationsByMemory(mem.id)[0].weight > 0.4, "weight bumped after touch");
-  store.close();
-});
-
-test("heatEnabled=false does NOT gate passive confirm (independent gates)", async () => {
-  const { store, service } = setup({ heatEnabled: false, graphWeightEnabled: true, graphPassiveConfirm: true, graphWeightDelta: 0.1 });
-  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
-  linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
-  await searchOnce(service, "数据库迁移");
-  assert.ok(store.getRelationsByMemory(mem.id)[0].weight > 0.4, "bumped even with heat off");
-  // 但 touchLastAccess 不写（heat 关的既有语义保留：last_accessed_at 仍为空）。
-  assert.equal(store.getById(mem.id).last_accessed_at, undefined);
-  store.close();
-});
-
-test("repeated touches cap at 1.0 (never exceeds)", () => {
-  const { store } = setup();
-  const a = store.createEntity({ name: "A", type: "technology" });
-  const b = store.createEntity({ name: "B", type: "technology" });
-  const rel = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm" }); // 0.4
-  for (let i = 0; i < 5; i++) {
-    store.bumpRelationWeight(rel.id, 0.3); // 0.4→0.7→1.0→1.0…
-  }
-  assert.equal(store.getRelations(a.id)[0].weight, 1.0, "capped at 1.0");
-  store.close();
-});
-
-// 总闸（块2 的 graphWeightEnabled）关着时被动确认不许生效——单开通道键就能演化
-// 边权的话，块2 立的「演化默认关」总闸形同虚设。
-test("graphWeightEnabled=false gates passive confirm (master switch)", async () => {
-  const { store, service } = setup({ graphPassiveConfirm: true, graphWeightDelta: 0.1 });
-  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
-  linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
-  await searchOnce(service, "数据库迁移");
-  assert.equal(store.getRelationsByMemory(mem.id)[0].weight, 0.4, "master switch off → weight untouched");
-  store.close();
-});
-
-test("memory without relations survives touch (no crash)", async () => {
-  const { store, service } = setup({ graphPassiveConfirm: true });
-  const mem = putMem(store, service, { title: "孤立条", content: "无关联边" });
-  await searchOnce(service, "孤立条");
-  assert.ok(store.getById(mem.id), "memory still present");
-  store.close();
+// issue #24 块4 被动确认（graphPassiveConfirm）测试。
+// 覆盖：默认关=零行为变化 / 开启=命中记忆的关联边 bump / heat 关但 passive
+// 开仍 bump（独立闸门）/ bump 只加不减封顶 / 无关联边的记忆触达安全降级。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+function putMem(store, service, { title, content, importance = 3 }) {
+  return service.saveWithDedupe({ type: "project", title, content, importance }).memory;
+}
+
+function linkRelToMem(store, { fromName, toName, memoryId, source = "llm" }) {
+  const a = store.findEntityByName(fromName) ?? store.createEntity({ name: fromName, type: "technology" });
+  const b = store.findEntityByName(toName) ?? store.createEntity({ name: toName, type: "technology" });
+  return store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "uses", memory_id: memoryId, source });
+}
+
+/** 跑一次检索（内部 touchRecalled 触发触达），返回 rows。 */
+async function searchOnce(service, query) {
+  return service.searchMemories(query, { mode: "auto" });
+}
+
+test("graphPassiveConfirm=false (default): touched memory does NOT bump relation weight", async () => {
+  const { store, service } = setup();
+  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  const rel = linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
+  assert.equal(rel.weight, 0.4);
+  await searchOnce(service, "数据库迁移");
+  // 默认关：检索触达不 bump（weight 保持 0.4）。
+  assert.equal(store.getRelationsByMemory(mem.id)[0].weight, 0.4, "weight unchanged by default");
+  store.close();
+});
+
+test("graphPassiveConfirm=true: touched memory bumps its linked relation weight", async () => {
+  const { store, service } = setup({ graphWeightEnabled: true, graphPassiveConfirm: true, graphWeightDelta: 0.1 });
+  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  const rel = linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
+  assert.equal(rel.weight, 0.4);
+  const rows = await searchOnce(service, "数据库迁移");
+  assert.ok(rows.some((r) => r.id === mem.id), "memory surfaced");
+  assert.ok(store.getRelationsByMemory(mem.id)[0].weight > 0.4, "weight bumped after touch");
+  store.close();
+});
+
+test("heatEnabled=false does NOT gate passive confirm (independent gates)", async () => {
+  const { store, service } = setup({ heatEnabled: false, graphWeightEnabled: true, graphPassiveConfirm: true, graphWeightDelta: 0.1 });
+  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
+  await searchOnce(service, "数据库迁移");
+  assert.ok(store.getRelationsByMemory(mem.id)[0].weight > 0.4, "bumped even with heat off");
+  // 但 touchLastAccess 不写（heat 关的既有语义保留：last_accessed_at 仍为空）。
+  assert.equal(store.getById(mem.id).last_accessed_at, undefined);
+  store.close();
+});
+
+test("repeated touches cap at 1.0 (never exceeds)", () => {
+  const { store } = setup();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const rel = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm" }); // 0.4
+  for (let i = 0; i < 5; i++) {
+    store.bumpRelationWeight(rel.id, 0.3); // 0.4→0.7→1.0→1.0…
+  }
+  assert.equal(store.getRelations(a.id)[0].weight, 1.0, "capped at 1.0");
+  store.close();
+});
+
+// 总闸（块2 的 graphWeightEnabled）关着时被动确认不许生效——单开通道键就能演化
+// 边权的话，块2 立的「演化默认关」总闸形同虚设。
+test("graphWeightEnabled=false gates passive confirm (master switch)", async () => {
+  const { store, service } = setup({ graphPassiveConfirm: true, graphWeightDelta: 0.1 });
+  const mem = putMem(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  linkRelToMem(store, { fromName: "A", toName: "B", memoryId: mem.id, source: "llm" });
+  await searchOnce(service, "数据库迁移");
+  assert.equal(store.getRelationsByMemory(mem.id)[0].weight, 0.4, "master switch off → weight untouched");
+  store.close();
+});
+
+test("memory without relations survives touch (no crash)", async () => {
+  const { store, service } = setup({ graphPassiveConfirm: true });
+  const mem = putMem(store, service, { title: "孤立条", content: "无关联边" });
+  await searchOnce(service, "孤立条");
+  assert.ok(store.getById(mem.id), "memory still present");
+  store.close();
 });

package/test/graph-weight-evolution.test.js

@@ -1,105 +1,105 @@
-// issue #24 块2 权重演化（entity_relations weight + source + bump）测试。
-// 覆盖：来源→初值映射（manual/tag/llm）/ weight 显式优先 / toRelation 回读 /
-// bumpRelationWeight 只加不减封顶 / extractor 建 llm 边 / 四来源全映射落表。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore, RELATION_SOURCE_DEFAULTS } from "../src/store.js";
-
-function makeStore() {
-  return createStore(":memory:");
-}
-
-test("RELATION_SOURCE_DEFAULTS matches issue #24 mapping", () => {
-  assert.equal(RELATION_SOURCE_DEFAULTS.manual, 1.0);
-  assert.equal(RELATION_SOURCE_DEFAULTS.confirmed, 1.0);
-  assert.equal(RELATION_SOURCE_DEFAULTS.tag, 0.3);
-  assert.equal(RELATION_SOURCE_DEFAULTS.llm, 0.4);
-});
-
-test("saveRelation maps source to initial weight", () => {
-  const store = makeStore();
-  const a = store.createEntity({ name: "A", type: "technology" });
-  const b = store.createEntity({ name: "B", type: "technology" });
-  const manual = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "manual" });
-  const tag = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "y", source: "tag" });
-  const llm = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "z", source: "llm" });
-  assert.equal(manual.weight, 1.0);
-  assert.equal(manual.source, "manual");
-  assert.equal(tag.weight, 0.3);
-  assert.equal(tag.source, "tag");
-  assert.equal(llm.weight, 0.4);
-  assert.equal(llm.source, "llm");
-});
-
-test("explicit weight overrides source mapping", () => {
-  const store = makeStore();
-  const a = store.createEntity({ name: "A", type: "technology" });
-  const b = store.createEntity({ name: "B", type: "technology" });
-  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm", weight: 0.7 });
-  assert.equal(r.weight, 0.7);
-});
-
-test("toRelation round-trips weight and source via getRelations", () => {
-  const store = makeStore();
-  const a = store.createEntity({ name: "A", type: "technology" });
-  const b = store.createEntity({ name: "B", type: "technology" });
-  store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "tag" });
-  const rels = store.getRelations(a.id);
-  assert.equal(rels.length, 1);
-  assert.equal(rels[0].weight, 0.3);
-  assert.equal(rels[0].source, "tag");
-});
-
-test("bumpRelationWeight raises weight, caps at 1.0, never lowers", () => {
-  const store = makeStore();
-  const a = store.createEntity({ name: "A", type: "technology" });
-  const b = store.createEntity({ name: "B", type: "technology" });
-  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm" });
-  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);
-  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);
-  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);  // 0.4→0.6→0.8→1.0
-  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);
-  assert.equal(store.getRelations(a.id)[0].weight, 1.0, "capped");
-  // 不存在的关系：幂等 false
-  assert.equal(store.bumpRelationWeight("no-such-id"), false);
-});
-
-test("legacy relation rows migrate with manual weight default (no crash)", () => {
-  const store = makeStore();
-  const a = store.createEntity({ name: "A", type: "technology" });
-  const b = store.createEntity({ name: "B", type: "technology" });
-  // 直接走底层 SQL 模拟旧库行（不带 weight/source 列 —— 但新 schema 已含列，
-  // 所以这条主要验证 migration 幂等路径不崩 + 默认映射成立）。
-  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x" });
-  assert.equal(r.weight, 1.0, "default source manual → weight 1.0");
-  assert.equal(r.source, "manual");
-});
-
-// ---- #24 复审回归（review findings 逐条落锁）--------------------------------
-
-// 「只加不减」是存储接口自己的契约：负/非法增量必须在存储边界被拒（false +
-// 权值不动），不能把下界托付给调用方的配置范围——旧写法 bumpRelationWeight(id,
-// -0.2) 能把 0.4 敲到 0.2。
-test("bumpRelationWeight rejects negative and non-finite increments (只加不减)", () => {
-  const store = makeStore();
-  const a = store.createEntity({ name: "A", type: "technology" });
-  const b = store.createEntity({ name: "B", type: "technology" });
-  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm" });
-  for (const bad of [-0.2, -1, Number.NaN, Number.POSITIVE_INFINITY, "0.2"]) {
-    assert.equal(store.bumpRelationWeight(r.id, bad), false, `increment ${String(bad)} must be refused`);
-    assert.equal(store.getRelations(a.id)[0].weight, 0.4, `weight must not move on increment ${String(bad)}`);
-  }
-  assert.equal(store.bumpRelationWeight(r.id, 0.2), true, "a valid increment still lands");
-  assert.ok(Math.abs(store.getRelations(a.id)[0].weight - 0.6) < 1e-9, "0.4 + 0.2 lands at 0.6 (float-safe)");
-});
-
-// 来源查询只认映射表的自有键：src="constructor"/"toString" 会命中原型链上的函数，
-// 旧写法把它当权重绑进 SQL（函数不可绑定 → 整条写入抛错）而不是回退默认 1.0。
-test("an inherited source name falls back to the default weight", () => {
-  const store = makeStore();
-  const a = store.createEntity({ name: "A", type: "technology" });
-  const b = store.createEntity({ name: "B", type: "technology" });
-  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "constructor" });
-  assert.equal(r.weight, 1.0, "prototype-chain names must fall back to 1.0, not a function");
-  assert.equal(r.source, "constructor", "source is recorded verbatim");
+// issue #24 块2 权重演化（entity_relations weight + source + bump）测试。
+// 覆盖：来源→初值映射（manual/tag/llm）/ weight 显式优先 / toRelation 回读 /
+// bumpRelationWeight 只加不减封顶 / extractor 建 llm 边 / 四来源全映射落表。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore, RELATION_SOURCE_DEFAULTS } from "../src/store.js";
+
+function makeStore() {
+  return createStore(":memory:");
+}
+
+test("RELATION_SOURCE_DEFAULTS matches issue #24 mapping", () => {
+  assert.equal(RELATION_SOURCE_DEFAULTS.manual, 1.0);
+  assert.equal(RELATION_SOURCE_DEFAULTS.confirmed, 1.0);
+  assert.equal(RELATION_SOURCE_DEFAULTS.tag, 0.3);
+  assert.equal(RELATION_SOURCE_DEFAULTS.llm, 0.4);
+});
+
+test("saveRelation maps source to initial weight", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const manual = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "manual" });
+  const tag = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "y", source: "tag" });
+  const llm = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "z", source: "llm" });
+  assert.equal(manual.weight, 1.0);
+  assert.equal(manual.source, "manual");
+  assert.equal(tag.weight, 0.3);
+  assert.equal(tag.source, "tag");
+  assert.equal(llm.weight, 0.4);
+  assert.equal(llm.source, "llm");
+});
+
+test("explicit weight overrides source mapping", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm", weight: 0.7 });
+  assert.equal(r.weight, 0.7);
+});
+
+test("toRelation round-trips weight and source via getRelations", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "tag" });
+  const rels = store.getRelations(a.id);
+  assert.equal(rels.length, 1);
+  assert.equal(rels[0].weight, 0.3);
+  assert.equal(rels[0].source, "tag");
+});
+
+test("bumpRelationWeight raises weight, caps at 1.0, never lowers", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm" });
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);  // 0.4→0.6→0.8→1.0
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true);
+  assert.equal(store.getRelations(a.id)[0].weight, 1.0, "capped");
+  // 不存在的关系：幂等 false
+  assert.equal(store.bumpRelationWeight("no-such-id"), false);
+});
+
+test("legacy relation rows migrate with manual weight default (no crash)", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  // 直接走底层 SQL 模拟旧库行（不带 weight/source 列 —— 但新 schema 已含列，
+  // 所以这条主要验证 migration 幂等路径不崩 + 默认映射成立）。
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x" });
+  assert.equal(r.weight, 1.0, "default source manual → weight 1.0");
+  assert.equal(r.source, "manual");
+});
+
+// ---- #24 复审回归（review findings 逐条落锁）--------------------------------
+
+// 「只加不减」是存储接口自己的契约：负/非法增量必须在存储边界被拒（false +
+// 权值不动），不能把下界托付给调用方的配置范围——旧写法 bumpRelationWeight(id,
+// -0.2) 能把 0.4 敲到 0.2。
+test("bumpRelationWeight rejects negative and non-finite increments (只加不减)", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "llm" });
+  for (const bad of [-0.2, -1, Number.NaN, Number.POSITIVE_INFINITY, "0.2"]) {
+    assert.equal(store.bumpRelationWeight(r.id, bad), false, `increment ${String(bad)} must be refused`);
+    assert.equal(store.getRelations(a.id)[0].weight, 0.4, `weight must not move on increment ${String(bad)}`);
+  }
+  assert.equal(store.bumpRelationWeight(r.id, 0.2), true, "a valid increment still lands");
+  assert.ok(Math.abs(store.getRelations(a.id)[0].weight - 0.6) < 1e-9, "0.4 + 0.2 lands at 0.6 (float-safe)");
+});
+
+// 来源查询只认映射表的自有键：src="constructor"/"toString" 会命中原型链上的函数，
+// 旧写法把它当权重绑进 SQL（函数不可绑定 → 整条写入抛错）而不是回退默认 1.0。
+test("an inherited source name falls back to the default weight", () => {
+  const store = makeStore();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const r = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "constructor" });
+  assert.equal(r.weight, 1.0, "prototype-chain names must fall back to 1.0, not a function");
+  assert.equal(r.source, "constructor", "source is recorded verbatim");
 });