@modusensus/dsh-mneme 0.8.10 → 0.8.12

package/test/dream.test.js

@@ -1306,3 +1306,78 @@ test("issue#258: dreamSummaryMaxInputs caps summary inputs to the newest N (0 =
   assert.match(overview().content, /整理后 5 条/, "uncapped run covers the whole library");
   store.close();
 });
+
+// --- issue #339 / E8 考卷：merge 护栏（dreamMergeGuard，opt-in）---------------
+// E8 实测巩固损耗里 10/26 条被丢约束已归位 guarded 类型仍被 merge 吃掉——
+// archive 护栏只挡 archive 不挡 merge。开启后被合并对象命中 ARCHIVE_GUARDED_TYPES
+// 的 merge 决策走与 archive 护栏同款通道：skipInvalid 时 skipped、严格时整单拒绝。
+
+test("validateDecisions mergeGuard: guarded-type merge is skipped under skipInvalid", () => {
+  const snap = new Map([
+    ["c1", { id: "c1", type: "constraint", title: "预算", content: "$12,400", importance: 4, archived: false, forgotten: false }],
+    ["c2", { id: "c2", type: "constraint", title: "预算(疑似重复)", content: "$12,450", importance: 4, archived: false, forgotten: false }],
+    ["h1", { id: "h1", type: "history", title: "旧事", content: "内容", importance: 3, archived: false, forgotten: false }],
+    ["h2", { id: "h2", type: "history", title: "旧事(近似)", content: "内容2", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const decisions = [
+    { action: "merge", ids: ["c1", "c2"], keepSource: "c1", title: "预算合并", content: "$12,400 上下", importance: 4 },
+    { action: "merge", ids: ["h1", "h2"], keepSource: "h1", title: "旧事合并", content: "合并内容", importance: 3 }
+  ];
+  const { ok, skipped } = validateDecisions(decisions, snap, { skipInvalid: true, mergeGuard: true });
+  assert.equal(ok, true, "history merge survives, guarded merge skipped");
+  assert.equal(skipped.length, 1);
+  assert.match(skipped[0].error, /dreamMergeGuard/, "skip reason names the guard");
+  assert.match(skipped[0].error, /constraint/, "skip reason names the guarded type");
+  // guarded merge 被 splice 掉，history merge 与两条隐式 keep 存活。
+  assert.deepEqual(decisions.map((d) => d.action), ["merge", "keep", "keep"]);
+  assert.ok(decisions.some((d) => d.action === "keep" && d.ids.includes("c1")), "c1 auto-kept");
+});
+
+test("validateDecisions mergeGuard: strict mode rejects the whole batch", () => {
+  const guardedSnap = new Map([
+    ["g1", { id: "g1", type: "pitfall", title: "坑", content: "内容", importance: 3, archived: false, forgotten: false }],
+    ["g2", { id: "g2", type: "pitfall", title: "坑2", content: "内容2", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const strict = validateDecisions(
+    [{ action: "merge", ids: ["g1", "g2"], keepSource: "g1", title: "t", content: "c" }],
+    guardedSnap,
+    { skipInvalid: false, mergeGuard: true }
+  );
+  assert.equal(strict.ok, false, "strict mode rejects guarded merge");
+  assert.ok(strict.errors.some((e) => /dreamMergeGuard/.test(e)));
+});
+
+test("validateDecisions mergeGuard: non-guarded types unaffected, guard off = legacy behavior", () => {
+  const snap = new Map([
+    ["c1", { id: "c1", type: "constraint", title: "预算", content: "$12,400", importance: 4, archived: false, forgotten: false }],
+    ["c2", { id: "c2", type: "constraint", title: "预算(疑似重复)", content: "$12,450", importance: 4, archived: false, forgotten: false }]
+  ]);
+  const decisions = [{ action: "merge", ids: ["c1", "c2"], keepSource: "c1", title: "预算合并", content: "合并", importance: 4 }];
+  // guard 关 = 现行为（merge 照常通过）。
+  assert.equal(validateDecisions(decisions, snap, { skipInvalid: true }).ok, true);
+  // guard 开但类型非 guarded（history 用 snapshot 默认 type=project 亦非 guarded）。
+  const plainSnap = snapshot(["x", "y"]);
+  assert.equal(
+    validateDecisions(
+      [{ action: "merge", ids: ["x", "y"], keepSource: "x", title: "t", content: "c" }],
+      plainSnap,
+      { skipInvalid: true, mergeGuard: true }
+    ).ok,
+    true,
+    "non-guarded merge passes under guard"
+  );
+});
+
+test("validateDecisions archive guard: long-retention type without duplicate/outdated rationale is skipped (prior gap)", () => {
+  const snap = new Map([
+    ["c", { id: "c", type: "constraint", title: "预算", content: "$12,400", importance: 4, archived: false, forgotten: false }],
+    ["p", { id: "p", type: "project", title: "项目", content: "内容", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const { ok, skipped } = validateDecisions([
+    { action: "archive", ids: ["c"], reason: "keeps the store tidy" },
+    { action: "archive", ids: ["p"], reason: "outdated" }
+  ], snap, { skipInvalid: true });
+  assert.equal(ok, true, "project archive with stale rationale survives");
+  assert.equal(skipped.length, 1, "constraint archive without rationale skipped");
+  assert.match(skipped[0].error, /long-retention type/);
+});

package/test/graph-anchoring.test.js

@@ -0,0 +1,185 @@
+// issue #24 块1 图谱锚定层（graphAnchoringEnabled）测试。
+// 覆盖：默认关=单跳轴行为逐字节不变 / 开=级联扩散邻居挂联记忆进融合池 /
+// 邻居分 = hop 配额 × tier（attr 1.0 > relation 0.9）/ 种子直达分不被邻居覆盖 /
+// 级联深度上界 / graphSeedCap 收敛邻居总量 / 空关系表降级 / lightMode 关闭配置。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { HOP_QUOTA } from "../src/graph/anchoring.js";
+
+function makeService(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+function putMemory(store, service, { type = "project", title, content, importance = 3 }) {
+  return service.saveWithDedupe({ type, title, content, importance }).memory;
+}
+
+function linkAttr(store, service, { entityName, memory, key = "k", value = "v", type = "technology" }) {
+  let entity = store.findEntityByName(entityName);
+  if (!entity) entity = store.createEntity({ name: entityName, type });
+  store.saveAttr({ entity_id: entity.id, attr_key: key, attr_value: value, memory_id: memory.id });
+  return entity;
+}
+
+function linkRelation(store, { from, to, relType = "related", memoryId, type = "technology" }) {
+  const a = store.findEntityByName(from) ?? store.createEntity({ name: from, type });
+  const b = store.findEntityByName(to) ?? store.createEntity({ name: to, type });
+  store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: relType, memory_id: memoryId });
+}
+
+// ============================================================ 默认关（回归红线）
+
+test("graphAnchoringEnabled=false (default): neighbor-linked memory NOT recalled, seed-only preserved", async () => {
+  const { store, service } = makeService({ entityRecallEnabled: true });
+  // 种子实体 PostgreSQL 挂一条记忆；关系边连到 PgBouncer（不挂记忆）。
+  const seedMem = putMemory(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  linkAttr(store, service, { entityName: "PostgreSQL", memory: seedMem, key: "version", value: "16" });
+  // 邻居实体 + 它自己挂的记忆：必须不被默认关猜中。
+  const neighborMem = putMemory(store, service, { title: "连接池笔记", content: "PgBouncer 池调优记录" });
+  const neigh = linkAttr(store, service, { entityName: "PgBouncer", memory: neighborMem, key: "mode", value: "pool" });
+  // 关系：PostgreSQL —uses→ PgBouncer（种子 → 邻居），不直接挂 seedMem。
+  const a = store.findEntityByName("PostgreSQL");
+  linkRelation(store, { from: a.name, to: neigh.name, relType: "uses", memoryId: seedMem.id });
+
+  const rows = await service.searchMemories("PostgreSQL 现状", { mode: "auto" });
+  const ids = rows.map((r) => r.id);
+  assert.ok(ids.includes(seedMem.id), "seed-linked memory present");
+  assert.ok(!ids.includes(neighborMem.id), "neighbor memory absent when anchoring off");
+});
+
+// ============================================================ 开：级联扩散
+
+test("graphAnchoringEnabled=true: neighbor-linked memory joins via cascade, seed keeps full tier score", async () => {
+  const { store, service } = makeService({ entityRecallEnabled: true, graphAnchoringEnabled: true });
+  const seedMem = putMemory(store, service, { title: "数据库迁移", content: "主库切换完成" });
+  linkAttr(store, service, { entityName: "PostgreSQL", memory: seedMem, key: "version", value: "16" });
+  const neighborMem = putMemory(store, service, { title: "连接池笔记", content: "PgBouncer 池调优记录" });
+  const neigh = linkAttr(store, service, { entityName: "PgBouncer", memory: neighborMem, key: "mode", value: "pool" });
+  const a = store.findEntityByName("PostgreSQL");
+  linkRelation(store, { from: a.name, to: neigh.name, relType: "uses", memoryId: seedMem.id });
+
+  // hybrid blend 走加权合算，便于精确断言 entity 轴分（blend: + we·score）。
+  const rows = await service.searchMemories("PostgreSQL 现状", { mode: "hybrid" });
+  const ids = rows.map((r) => r.id);
+  assert.ok(ids.includes(seedMem.id), "seed memory present");
+  assert.ok(ids.includes(neighborMem.id), "neighbor memory present via cascade");
+  // 种子 attr 1.0 × we(0.3) = 0.3；邻居 attr 1.0 × HOP_QUOTA[1](0.5) × we = 0.15。
+  const seedRow = rows.find((r) => r.id === seedMem.id);
+  const nbRow = rows.find((r) => r.id === neighborMem.id);
+  assert.ok(Math.abs(seedRow.score - 0.3) < 1e-9, "seed keeps full tier score");
+  assert.ok(Math.abs(nbRow.score - 0.3 * HOP_QUOTA[1]) < 1e-9, "neighbor hop-weighted");
+});
+
+test("cascade respects hop-quota ordering: 1-hop neighbors score above 2-hop", async () => {
+  const { store, service } = makeService({ entityRecallEnabled: true, graphAnchoringEnabled: true });
+  const seedMem = putMemory(store, service, { title: "根服务", content: "服务 A 上线" });
+  linkAttr(store, service, { entityName: "ServiceA", memory: seedMem, key: "env", value: "prod" });
+  const hop1Mem = putMemory(store, service, { title: "链路一", content: "ServiceB 依赖记录" });
+  const hop2Mem = putMemory(store, service, { title: "链路二", content: "ServiceC 间接关联" });
+  const b = linkAttr(store, service, { entityName: "ServiceB", memory: hop1Mem, key: "tier", value: "edge" });
+  const c = linkAttr(store, service, { entityName: "ServiceC", memory: hop2Mem, key: "tier", value: "leaf" });
+  const a = store.findEntityByName("ServiceA");
+  // A—B 关系（hop1）；B—C 关系（hop2）。
+  linkRelation(store, { from: a.name, to: b.name, relType: "depends", memoryId: hop1Mem.id });
+  linkRelation(store, { from: b.name, to: c.name, relType: "depends", memoryId: hop2Mem.id });
+
+  const rows = await service.searchMemories("ServiceA", { mode: "auto" });
+  const ids = rows.map((r) => r.id);
+  assert.ok(ids.includes(hop1Mem.id) && ids.includes(hop2Mem.id), "both hops recalled");
+  const h1 = rows.find((r) => r.id === hop1Mem.id);
+  const h2 = rows.find((r) => r.id === hop2Mem.id);
+  assert.ok(h1.score > h2.score, `1-hop (${h1.score}) scores above 2-hop (${h2.score})`);
+});
+
+test("empty relation table degrades cleanly (still returns seed memories)", async () => {
+  const { store, service } = makeService({ entityRecallEnabled: true, graphAnchoringEnabled: true });
+  const seedMem = putMemory(store, service, { title: "独立条", content: "单独存在" });
+  linkAttr(store, service, { entityName: "Standalone", memory: seedMem, key: "k", value: "v" });
+  const rows = await service.searchMemories("Standalone", { mode: "auto" });
+  assert.ok(rows.some((r) => r.id === seedMem.id), "seed memory survives with no relations");
+});
+
+// ============================================================ 配置与配额
+
+test("graphSeedCap bounds neighbor expansion (small cap cuts deeper hops)", async () => {
+  const { store, service } = makeService({
+    entityRecallEnabled: true, graphAnchoringEnabled: true, graphSeedCap: 1, graphCascadeDepth: 3
+  });
+  const seedMem = putMemory(store, service, { title: "根", content: "入口" });
+  const hop1Mem = putMemory(store, service, { title: "一层", content: "近邻" });
+  const hop2Mem = putMemory(store, service, { title: "二层", content: "远邻" });
+  const b = linkAttr(store, service, { entityName: "NodeB", memory: hop1Mem, key: "k", value: "v" });
+  const c = linkAttr(store, service, { entityName: "NodeC", memory: hop2Mem, key: "k", value: "v" });
+  const a = store.findEntityByName("入口占位"); // 无；用 NodeA
+  const nodeA = store.createEntity({ name: "NodeA", type: "technology" });
+  store.saveRelation({ from_entity: nodeA.id, to_entity: b.id, relation_type: "x", memory_id: seedMem.id });
+  store.saveRelation({ from_entity: b.id, to_entity: c.id, relation_type: "x", memory_id: hop1Mem.id });
+
+  const rows = await service.searchMemories("NodeA", { mode: "auto" });
+  const ids = rows.map((r) => r.id).sort();
+  // cap=1 → 配额 floor(1*0.5)=0 → max(1,…) 兜底只进 1 个 1-hop；2-hop 进不来。
+  assert.ok(ids.includes(hop1Mem.id), "1-hop fits within cap");
+  assert.ok(!ids.includes(hop2Mem.id), "2-hop cut by small cap");
+});
+
+test("the anchoring pure module is self-checked", () => {
+  // 模块自带 _selfCheck 已在模块加载时断言；这里再锚定导出契约，防重构断链。
+  assert.ok(typeof HOP_QUOTA[1] === "number" && HOP_QUOTA[1] > HOP_QUOTA[2]);
+});
+
+// ---- #24 复审回归（review findings 逐条落锁）--------------------------------
+
+// 关档逐字节复用 #219 单跳轴：graphSeedCap 只在锚定开启后生效。种子裁剪若漏进
+// 关档路径，cap=1 时第二个命中实体整支挂联记忆都会消失——这条专门钉死它。
+test("anchoring off: graphSeedCap does not cap the legacy single-hop axis", async () => {
+  const { store, service } = makeService({ entityRecallEnabled: true, graphSeedCap: 1 });
+  const memA = putMemory(store, service, { title: "迁移记录", content: "主库切换完成" });
+  const memB = putMemory(store, service, { title: "池化记录", content: "连接池调优" });
+  linkAttr(store, service, { entityName: "Alpha", memory: memA, key: "k", value: "v" });
+  linkAttr(store, service, { entityName: "Beta", memory: memB, key: "k", value: "v" });
+
+  const rows = await service.searchMemories("Alpha Beta", { mode: "auto" });
+  const ids = rows.map((r) => r.id);
+  assert.ok(ids.includes(memA.id), "first seed-linked memory present");
+  assert.ok(ids.includes(memB.id), "second seed-linked memory must survive when anchoring is off");
+});
+
+// 级联要真走出 >1 跳：邻接若只带种子那一层，2-hop 实体挂联的记忆根本不进池。
+// 本地图上 2-hop 记忆只经 AnchorC 可达（两条关系行的 memory_id 都留空，堵死
+// 「1-hop 关系行旁路」），所以这条能红着抓回归。
+test("cascade reaches 2 hops (lazy per-node adjacency, deeper hop weighted lower)", async () => {
+  const { store, service } = makeService({
+    entityRecallEnabled: true, graphAnchoringEnabled: true, graphCascadeDepth: 2
+  });
+  const seedMem = putMemory(store, service, { title: "根服务", content: "入口记录" });
+  const hop2Mem = putMemory(store, service, { title: "远环", content: "间接可达" });
+  const a = linkAttr(store, service, { entityName: "AnchorA", memory: seedMem, key: "k", value: "v" });
+  const c = linkAttr(store, service, { entityName: "AnchorC", memory: hop2Mem, key: "k", value: "v" });
+  const b = store.createEntity({ name: "AnchorB", type: "technology" });
+  store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x" });
+  store.saveRelation({ from_entity: b.id, to_entity: c.id, relation_type: "x" });
+
+  const rows = await service.searchMemories("AnchorA", { mode: "hybrid" });
+  const ids = rows.map((r) => r.id);
+  assert.ok(ids.includes(seedMem.id), "seed memory present");
+  assert.ok(ids.includes(hop2Mem.id), "2-hop linked memory reached via cascade");
+  const h2 = rows.find((r) => r.id === hop2Mem.id);
+  assert.ok(Math.abs(h2.score - 0.3 * HOP_QUOTA[2]) < 1e-9, `2-hop keeps hop-quota weighting, got ${h2.score}`);
+  store.close();
+});
+
+// 邻接查询两个 IN 组都要绑定：关系方向写成 X→种子 时，种子同样应看到 X 是它的
+// 邻居（只绑第一组时这类行整批消失，级联方向性丢失）。
+test("getEntityNeighbors sees both directions of a relation", () => {
+  const store = createStore(":memory:");
+  const a = store.createEntity({ name: "Seed", type: "technology" });
+  const b = store.createEntity({ name: "Other", type: "technology" });
+  store.saveRelation({ from_entity: b.id, to_entity: a.id, relation_type: "x" });
+  const nb = store.getEntityNeighbors([a.id]);
+  assert.deepEqual(nb.get(a.id), [b.id], "seed must see the reverse-direction neighbor");
+  store.close();
+});

package/test/graph-inject-budget.test.js

@@ -0,0 +1,104 @@
+// issue #24 块3 关联提示防幻觉（graphInjectHint / graphInjectBudget）测试。
+// 覆盖：图候选打标 graphHint / 保守档（默认关）线索行不进注入块 / 开档受独立
+// 预算 graphInjectBudget 约束且不挤占 maxItems / [检索线索] 引导语与线索行文本。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { STR, langOf } from "../src/lang.js";
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+function linkEntityMem(store, service, { name, title, content, key = "k", value = "v", type = "technology" }) {
+  const mem = service.saveWithDedupe({ type: "project", title, content, importance: 3 }).memory;
+  let ent = store.findEntityByName(name);
+  if (!ent) ent = store.createEntity({ name, type });
+  store.saveAttr({ entity_id: ent.id, attr_key: key, attr_value: value, memory_id: mem.id });
+  return mem;
+}
+
+test("graphHint candidates are tagged when entityRecallEnabled, and do NOT enter the block by default (conservative)", () => {
+  const { store, service } = setup({ entityRecallEnabled: true, maxInjectedItems: 5 });
+  // 一条与查询无关的普通记忆（避免规则路占用），一条实体挂联记忆。
+  linkEntityMem(store, service, {
+    name: "PostgreSQL", title: "数据库迁移", content: "主库切换完成，复制延迟归零"
+  });
+  service.saveWithDedupe({ type: "decision", title: "无关决策", content: "今天天气不错", importance: 4 });
+  const selected = service.injectCandidates({ maxItems: 5, query: "PostgreSQL" });
+  // 保守档默认 graphInjectHint=false：图线索行被 general 选取跳过——
+  // 候选池里能查到 graphHint 标记，但注入终集会排除它。
+  assert.ok(selected.every((m) => m.graphHint !== true), "conservative: no graph hint rows in the injected set");
+});
+
+test("graphInjectHint=true admits graph hint rows under independent budget", () => {
+  const { store, service } = setup({
+    entityRecallEnabled: true, maxInjectedItems: 5, graphInjectHint: true, graphInjectBudget: 2
+  });
+  // 两条实体挂联记忆（都命中查询实体），一条普通规则记忆。
+  linkEntityMem(store, service, { name: "PostgreSQL", title: "数据库迁移", content: "主库切换完成", key: "k1" });
+  linkEntityMem(store, service, { name: "PostgreSQL", title: "连接池调优", content: "PgBouncer 配置", key: "k2" });
+  service.saveWithDedupe({ type: "decision", title: "无关决策", content: "其他内容", importance: 5 });
+  const selected = service.injectCandidates({ maxItems: 5, query: "PostgreSQL" });
+  const hints = selected.filter((m) => m.graphHint === true);
+  assert.equal(hints.length, 2, "both graph hint rows fit within budget 2");
+  // 普通规则记忆仍在（graph 行不挤占 maxItems 槽）。
+  assert.ok(selected.some((m) => !m.graphHint), "non-graph rows still present");
+  store.close();
+});
+
+test("graphInjectBudget caps graph hint rows even when more match the query", () => {
+  const { store, service } = setup({
+    entityRecallEnabled: true, maxInjectedItems: 10, graphInjectHint: true, graphInjectBudget: 1
+  });
+  // 三条候选实体挂联记忆，预算只有 1。
+  for (const i of [1, 2, 3]) {
+    linkEntityMem(store, service, { name: "PostgreSQL", title: `PG 记录 ${i}`, content: `内容 ${i}`, key: `k${i}` });
+  }
+  const selected = service.injectCandidates({ maxItems: 10 });
+  const hints = selected.filter((m) => m.graphHint === true);
+  assert.ok(hints.length <= 1, `budget 1 caps at 1, got ${hints.length}`);
+  store.close();
+});
+
+test("graphHint=false (default) + entityRecallEnabled returns zero candidate set change (conservative = sorting only)", () => {
+  const { store, service } = setup({ entityRecallEnabled: true, maxInjectedItems: 5 });
+  // 仅实体挂联记忆，保守档下不该有任何候选进块。
+  linkEntityMem(store, service, { name: "PostgreSQL", title: "数据库迁移", content: "主库切换完成" });
+  const selected = service.injectCandidates({ maxItems: 5, query: "PostgreSQL 现状" });
+  assert.equal(selected.filter((m) => m.graphHint).length, 0);
+  store.close();
+});
+
+test("[检索线索] 引导语与线索行文本渲染正确（zh/en 双语）", () => {
+  assert.ok(STR.graphHintHeader.zh.includes("检索线索"));
+  assert.ok(STR.graphHintHeader.zh.includes("非事实断言"));
+  assert.ok(STR.graphHintHeader.en.includes("Retrieval hints"));
+  assert.ok(STR.graphHintHeader.en.toLowerCase().includes("not factual"));
+  const lineZh = STR.graphHintLine.zh("entity", "某某", "内容");
+  assert.ok(lineZh.startsWith("- [线索/entity]"));
+  const lineEn = STR.graphHintLine.en("technology", "Foo", "bar");
+  assert.ok(lineEn.startsWith("- [hint/technology]"));
+});
+
+// ---- 复审回归 ---------------------------------------------------------------
+
+// 保守档（graphInjectHint 关）下线索行不许从 pin 池侧漏进注入块：pin 池取自打标
+// 之后、又不占 maxItems 名额，pin 若不排除 graphHint 行，「图召回 + 约束型记忆」
+// 就会在默认关档下照常进常驻注入文本，把线索开关整个绕过去。
+test("conservative mode: a graph hint row cannot leak in via the pin pool", () => {
+  const { store, service } = setup({ entityRecallEnabled: true, maxInjectedItems: 5, pinnedInjectBudget: 1 });
+  // 约束型记忆 + 命中查询实体：同时是 pin 候选与图线索候选（最坏交叉）。
+  const mem = service.saveWithDedupe({
+    type: "constraint", title: "部署约束", content: "生产环境不许直接改库", importance: 4
+  }).memory;
+  const ent = store.createEntity({ name: "PostgreSQL", type: "technology" });
+  store.saveAttr({ entity_id: ent.id, attr_key: "k", attr_value: "v", memory_id: mem.id });
+
+  const selected = service.injectCandidates({ maxItems: 5, query: "PostgreSQL" });
+  assert.equal(selected.filter((m) => m.graphHint === true).length, 0, "hint rows stay out while graphInjectHint is off");
+  store.close();
+});

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

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

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

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