@modusensus/dsh-mneme 0.9.5 → 0.10.1

package/test/graph-boosted-relations.test.js

@@ -0,0 +1,189 @@
+// issue #24 块4（被动确认）的复核出口：
+//   GET /api/dsh-mneme/semantic/graph/boosted-relations
+// 复核的对象是「权重被抬过的边」——抬升是唯一会改变检索形状的动作，所以它自己
+// 就是证据，不必再开一张记账表。这里同时钉住 ego 边的 weight/source 形状：
+// 少了那两个字段，面板就分不清「这条边被用过」和「这条边从没被用过」。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function req(path) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = "GET";
+  r.headers = {};
+  return r;
+}
+
+function setup({ config = {}, apiToken = "" } = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const settings = createSettings(store.db);
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, commands, null, undefined, apiToken, config);
+  return { store, service, routes };
+}
+
+const BOOSTED = "/api/dsh-mneme/semantic/graph/boosted-relations";
+
+test("boosted-relations route is registered and open without apiToken", async () => {
+  const { routes } = setup({ apiToken: "secret-token" });
+  const route = routes.find((r) => r.path === BOOSTED);
+  assert.ok(route, "route must be registered");
+  const res = new FakeRes();
+  await route.handler(req(BOOSTED), res);
+  assert.equal(res.statusCode, 200, "read-only route must not demand a token");
+});
+
+test("boosted-relations lists only edges whose weight rose above its source baseline", async () => {
+  const { store, service, routes } = setup();
+  const a = service.createEntity({ name: "A", type: "concept" });
+  const b = service.createEntity({ name: "B", type: "concept" });
+  const c = service.createEntity({ name: "C", type: "concept" });
+  // tag 边初值 0.3，抬两次 → 0.5，gain 0.2，必进表。
+  const boosted = service.saveRelation({
+    from_entity: a.id, to_entity: b.id, relation_type: "uses", source: "tag"
+  });
+  store.bumpRelationWeight(boosted.id, 0.1);
+  store.bumpRelationWeight(boosted.id, 0.1);
+  // manual 边留在初值 1.0：gain 为 0，不得进表。
+  service.saveRelation({ from_entity: b.id, to_entity: c.id, relation_type: "uses", source: "manual" });
+
+  const res = new FakeRes();
+  await routes.find((r) => r.path === BOOSTED).handler(req(BOOSTED), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.count, 1, "only the raised edge qualifies");
+  const item = data.items[0];
+  assert.equal(item.id, boosted.id);
+  assert.equal(item.from, a.id);
+  assert.equal(item.to, b.id);
+  assert.equal(item.from_name, "A", "both endpoint names ride along so the panel need not re-query");
+  assert.equal(item.to_name, "B");
+  assert.equal(item.source, "tag");
+  assert.ok(Math.abs(item.base_weight - 0.3) < 1e-9, "baseline comes from RELATION_SOURCE_DEFAULTS");
+  assert.ok(Math.abs(item.weight - 0.5) < 1e-9, `weight rose to 0.5, got ${item.weight}`);
+  assert.ok(Math.abs(item.gain - 0.2) < 1e-9, `gain = weight − base, got ${item.gain}`);
+});
+
+test("boosted-relations reports an empty table honestly, with the gate that explains why", async () => {
+  const { service, routes } = setup();
+  const a = service.createEntity({ name: "A", type: "concept" });
+  const b = service.createEntity({ name: "B", type: "concept" });
+  service.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "uses", source: "llm" });
+
+  const res = new FakeRes();
+  await routes.find((r) => r.path === BOOSTED).handler(req(BOOSTED), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.count, 0, "an unraised edge is not a finding");
+  assert.equal(data.passiveConfirmEnabled, false, "the gate is off by default — the panel can say so");
+});
+
+test("boosted-relations surfaces passiveConfirmEnabled=true when the gate is on", async () => {
+  const { routes } = setup({ config: { graphPassiveConfirm: true, graphWeightEnabled: true } });
+  const res = new FakeRes();
+  await routes.find((r) => r.path === BOOSTED).handler(req(BOOSTED), res);
+  assert.equal(JSON.parse(res.body).passiveConfirmEnabled, true);
+});
+
+// 只有 graphPassiveConfirm 开着不算「会继续产生新提升」：touchRecalled 里
+// passive = graphPassiveConfirm && graphWeightEnabled，只看前者面板会说
+// 「会自动提升」而实际一条都不会抬（评审指出）。
+test("boosted-relations reports the gate as off when only graphPassiveConfirm is set", async () => {
+  const { routes } = setup({ config: { graphPassiveConfirm: true, graphWeightEnabled: false } });
+  const res = new FakeRes();
+  await routes.find((r) => r.path === BOOSTED).handler(req(BOOSTED), res);
+  assert.equal(JSON.parse(res.body).passiveConfirmEnabled, false,
+    "passive confirmation only bites when weight evolution is also on");
+});
+
+// 排序口径：按 gain 降序，不是按 weight 降序。不同 source 的 base 不同，
+// 所以 weight 大的边 gain 可能更小。首版把排序交给 SQL 的 weight DESC 并在
+// 循环里按 limit 提前 break，截断处丢掉的正是 gain 更大的边（评审指出）。
+test("boosted-relations ranks by gain, not by raw weight", async () => {
+  const { store, routes } = setup();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const c = store.createEntity({ name: "C", type: "technology" });
+  // llm 边：base 0.4，weight 0.95 → gain 0.55
+  const llmEdge = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "uses", source: "llm" });
+  store.bumpRelationWeight(llmEdge.id, 0.55);
+  // tag 边：base 0.3，weight 0.90 → gain 0.60（weight 更小、gain 更大）
+  const tagEdge = store.saveRelation({ from_entity: a.id, to_entity: c.id, relation_type: "uses", source: "tag" });
+  store.bumpRelationWeight(tagEdge.id, 0.60);
+
+  const res = new FakeRes();
+  await routes.find((r) => r.path === BOOSTED).handler(req(BOOSTED), res);
+  const items = JSON.parse(res.body).items;
+  assert.ok(items.length >= 2);
+  assert.ok(items[0].gain >= items[1].gain, "the list must be ordered by gain");
+  assert.equal(items[0].to_name, "C",
+    "the tag edge (weight 0.90, gain 0.60) must outrank the llm edge (weight 0.95, gain 0.55)");
+});
+
+// 截断也必须发生在按 gain 排完之后：limit=1 时留下的得是 gain 最大那条。
+test("boosted-relations truncates after ranking by gain", async () => {
+  const { store, routes } = setup();
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  const c = store.createEntity({ name: "C", type: "technology" });
+  const llmEdge = store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "uses", source: "llm" });
+  store.bumpRelationWeight(llmEdge.id, 0.55);
+  const tagEdge = store.saveRelation({ from_entity: a.id, to_entity: c.id, relation_type: "uses", source: "tag" });
+  store.bumpRelationWeight(tagEdge.id, 0.60);
+
+  const res = new FakeRes();
+  await routes.find((r) => r.path === BOOSTED).handler(req(BOOSTED + "?limit=1"), res);
+  const items = JSON.parse(res.body).items;
+  assert.equal(items.length, 1);
+  assert.equal(items[0].to_name, "C",
+    "truncation must keep the largest gain, not the largest weight");
+});
+
+test("boosted-relations honours limit and never exceeds the hard cap", async () => {
+  const { store, service, routes } = setup();
+  for (let i = 0; i < 6; i++) {
+    const a = service.createEntity({ name: `L${i}a`, type: "concept" });
+    const b = service.createEntity({ name: `L${i}b`, type: "concept" });
+    const r = service.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "x", source: "tag" });
+    store.bumpRelationWeight(r.id, 0.1);
+  }
+  const route = routes.find((r) => r.path === BOOSTED);
+  let res = new FakeRes();
+  await route.handler(req(`${BOOSTED}?limit=2`), res);
+  assert.equal(JSON.parse(res.body).count, 2, "limit caps the returned rows");
+  res = new FakeRes();
+  await route.handler(req(`${BOOSTED}?limit=9999`), res);
+  assert.equal(JSON.parse(res.body).count, 6, "an absurd limit clamps to the cap, it does not error");
+});
+
+// ego 的边要带 weight/source：面板靠它区分「这条边被用过」与「从没被用过」。
+test("ego edges carry weight and source", async () => {
+  const { service, routes } = setup();
+  const a = service.createEntity({ name: "A", type: "concept" });
+  const b = service.createEntity({ name: "B", type: "concept" });
+  const rel = service.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "uses", source: "llm" });
+
+  const res = new FakeRes();
+  await routes
+    .find((r) => r.path === "/api/dsh-mneme/semantic/graph/ego")
+    .handler(req("/api/dsh-mneme/semantic/graph/ego?entity=A&depth=1"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  const edge = data.edges.find((e) => e.id === rel.id);
+  assert.ok(edge, "the relation must appear among ego edges");
+  assert.ok(Math.abs(edge.weight - 0.4) < 1e-9, `llm edge starts at 0.4, got ${edge.weight}`);
+  assert.equal(edge.source, "llm");
+});

package/test/graph-multipath.test.js

@@ -0,0 +1,269 @@
+// issue #24 块1 三路起点的回归（tag 桥接 / 向量 / 零分种子）。
+// 这三条都在钉「调用点真的接上了」：能力早就写在 graph/anchoring.js 里，
+// 之前的病是 service.js 只喂了一路 exact，另两路永远等不到自己被调用。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+import { HOP_QUOTA } from "../src/graph/anchoring.js";
+
+function mockEmbedder(vec = [1, 0, 0, 0]) {
+  return {
+    embedSingle: async () => vec,
+    embed: async (texts) => texts.map(() => vec),
+    schedule: () => {},
+    modelHash: "mock#abc",
+    dimension: 4
+  };
+}
+
+function makeService(config = {}, { withEmbedder = false } = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  if (withEmbedder) {
+    const vectorIndex = createVectorIndex({ store });
+    service.setEmbedder(mockEmbedder());
+    service.setVectorIndex(vectorIndex);
+    return { store, service, vectorIndex };
+  }
+  return { store, service, vectorIndex: null };
+}
+
+function putMemory(store, service, { type = "project", title, content, tags = [], importance = 3 }) {
+  return service.saveWithDedupe({ type, title, content, tags, importance }).memory;
+}
+
+function linkAttr(store, 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 linkEntities(store, fromName, toName, { relType = "uses", type = "technology" } = {}) {
+  const a = store.findEntityByName(fromName) ?? store.createEntity({ name: fromName, type });
+  const b = store.findEntityByName(toName) ?? store.createEntity({ name: toName, type });
+  store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: relType });
+  return { a, b };
+}
+
+// ---- Tag 桥接 -------------------------------------------------------------
+// 查询「数据库迁移」既不是任何实体名，也不含实体名的子串。tag 命中一条记忆后，
+// 该记忆挂联的实体就是「这次在谈的东西」，沿它级联出去的邻居记忆才有机会进池。
+// 判别点：farMem 只能经 PgTuner → PgCache 这条边到达；tag 路不接线时它必然缺席。
+test("tag path bridges a tag hit into an entity seed (query names no entity)", async () => {
+  const { store, service } = makeService({ entityRecallEnabled: true, graphAnchoringEnabled: true });
+  // nearMem 带 tag，标题正文都不含查询词——但 store.search 的 tags LIKE 也会命中它，
+  // 所以它的存在不是本条用例的判别点，判别点是 farMem。
+  const nearMem = putMemory(store, service, {
+    title: "alpha", content: "beta gamma", tags: ["数据库迁移"]
+  });
+  const farMem = putMemory(store, service, { title: "delta", content: "epsilon zeta" });
+  linkAttr(store, "PgTuner", nearMem);
+  linkAttr(store, "PgCache", farMem);
+  linkEntities(store, "PgTuner", "PgCache");
+
+  const rows = await service.searchMemories("数据库迁移", { mode: "hybrid" });
+  const ids = rows.map((r) => r.id);
+  assert.ok(ids.includes(farMem.id), "1-hop memory reached only via the tag-bridged seed");
+  const far = rows.find((r) => r.id === farMem.id);
+  assert.ok(
+    Math.abs(far.score - 1.0 * HOP_QUOTA[1] * 0.3) < 1e-9,
+    `hop-quota weighting preserved through the tag path, got ${far.score}`
+  );
+});
+
+// 关锚定时 tag 路一次都不许查：否则「默认关=旧单跳轴逐字节不变」这条承诺就破了。
+test("tag path is not consulted when anchoring is off", async () => {
+  const { store, service } = makeService({ entityRecallEnabled: true });
+  const nearMem = putMemory(store, service, {
+    title: "alpha", content: "beta gamma", tags: ["数据库迁移"]
+  });
+  const farMem = putMemory(store, service, { title: "delta", content: "epsilon zeta" });
+  linkAttr(store, "PgTuner", nearMem);
+  linkAttr(store, "PgCache", farMem);
+  linkEntities(store, "PgTuner", "PgCache");
+
+  const rows = await service.searchMemories("数据库迁移", { mode: "hybrid" });
+  assert.ok(!rows.some((r) => r.id === farMem.id), "no cascade when anchoring is off");
+});
+
+// ---- 向量起点 -------------------------------------------------------------
+// 查询里没有实体名、也没有 tag 命中，唯一能给出种子的是向量。早退条件若仍以
+// 「名字没命中」收场，第三路接上了也永远不被调用——这条用例正是钉那个早退。
+test("vector path seeds from near memories when the query names no entity", async () => {
+  const { store, service, vectorIndex } = makeService(
+    { entityRecallEnabled: true, graphAnchoringEnabled: true },
+    { withEmbedder: true }
+  );
+  const nearMem = putMemory(store, service, { title: "alpha", content: "beta gamma" });
+  const farMem = putMemory(store, service, { title: "delta", content: "epsilon zeta" });
+  vectorIndex.saveEmbedding(nearMem.id, [1, 0, 0, 0]); // farMem 刻意不嵌：它只能经图轴到达
+  linkAttr(store, "VecSeed", nearMem);
+  linkAttr(store, "VecNeighbor", farMem);
+  linkEntities(store, "VecSeed", "VecNeighbor");
+
+  const rows = await service.searchMemories("omega", { mode: "hybrid" });
+  const ids = rows.map((r) => r.id);
+  assert.ok(ids.includes(farMem.id), "1-hop memory reached through the vector seed");
+  const far = rows.find((r) => r.id === farMem.id);
+  assert.ok(
+    Math.abs(far.score - HOP_QUOTA[1] * 0.3) < 1e-9,
+    `vector seed keeps hop-quota weighting, got ${far.score}`
+  );
+});
+
+// ---- 向量起点也要看关系端点 -----------------------------------------------
+// 与 Tag 路同一条病：一条近邻记忆若只通过关系挂到实体上（phaseRelations 不建
+// attr 行），只读 entity_attrs 的反查会漏掉它，向量路就凭空少了种子。
+test("vector path seeds from relation-only memories, not just attr rows", async () => {
+  const { store, service, vectorIndex } = makeService(
+    { entityRecallEnabled: true, graphAnchoringEnabled: true },
+    { withEmbedder: true }
+  );
+  const nearMem = putMemory(store, service, { title: "alpha", content: "beta gamma" });
+  const farMem = putMemory(store, service, { title: "delta", content: "epsilon zeta" });
+  vectorIndex.saveEmbedding(nearMem.id, [1, 0, 0, 0]);
+  // nearMem 不写 attr，只通过一条关系挂到 RelSeed / RelNeighbor 上。
+  const seed = store.createEntity({ name: "RelSeed", type: "module" });
+  const neighbor = store.createEntity({ name: "RelNeighbor", type: "module" });
+  store.saveRelation({
+    from_entity: seed.id, to_entity: neighbor.id, relation_type: "uses",
+    memory_id: nearMem.id, metadata: { source: "sleep_relation_completion" }
+  });
+  linkAttr(store, "RelNeighbor", farMem, { key: "k2" });
+
+  const rows = await service.searchMemories("omega", { mode: "hybrid" });
+  assert.ok(rows.some((r) => r.id === farMem.id),
+    "a relation-only near memory must still produce vector seeds");
+});
+
+// 对照：没有 embedder 就没有向量路，三路全空时必须老实返回空，而不是凭空造种子。
+test("vector path absent leaves the axis empty (no phantom seeds)", async () => {  const { store, service } = makeService({ entityRecallEnabled: true, graphAnchoringEnabled: true });
+  const nearMem = putMemory(store, service, { title: "alpha", content: "beta gamma" });
+  const farMem = putMemory(store, service, { title: "delta", content: "epsilon zeta" });
+  linkAttr(store, "VecSeed", nearMem);
+  linkAttr(store, "VecNeighbor", farMem);
+  linkEntities(store, "VecSeed", "VecNeighbor");
+
+  const rows = await service.searchMemories("omega", { mode: "hybrid" });
+  assert.ok(!rows.some((r) => r.id === farMem.id), "no seed sources → no cascade");
+});
+
+// ---- 零分种子 -------------------------------------------------------------
+// min-max 会把连续通路里**最弱的那条**压成 0。0 分种子仍会被 anchorSeeds 收下，
+// 而下游给种子挂联记忆的是**固定满权 tier**（不看种子自己的分数）——于是「这一路
+// 里最不像的那条」会以最强的姿态把记忆拉进池。
+//
+// 两条近邻记忆都必须拿到**正分**：若让第二条与查询正交（cos=0），它在进向量
+// 路时就被 score > 0 挡掉了，min-max 根本轮不到把它压成 0——那样这条用例会
+// 以「从没发生过」的方式通过，看着绿、其实什么都没验。
+//
+// zeroMem 必须**挂在 0 分种子自己身上**（VoZero 同时挂 nearB 与 zeroMem）。
+// 首版把它挂在另一个孤立实体上，于是无论滤不滤 0 分种子它都到不了——变异自证
+// 当场抓到那条用例是空转的。
+test("a zero-score seed does not inject its linked memory at full tier", async () => {
+  const { store, service, vectorIndex } = makeService(
+    { entityRecallEnabled: true, graphAnchoringEnabled: true },
+    { withEmbedder: true }
+  );
+  const nearA = putMemory(store, service, { title: "alpha", content: "beta" });
+  const nearB = putMemory(store, service, { title: "gamma", content: "delta" });
+  const zeroMem = putMemory(store, service, { title: "iota", content: "kappa" });
+  vectorIndex.saveEmbedding(nearA.id, [1, 0, 0, 0]);       // cos = 1.0
+  vectorIndex.saveEmbedding(nearB.id, [0.7, 0.7, 0, 0]);   // cos ≈ 0.707，正分但更低 → min-max 压成 0
+  linkAttr(store, "VoSeed", nearA);
+  linkAttr(store, "VoZero", nearB);
+  linkAttr(store, "VoZero", zeroMem, { key: "k2" }); // 同一实体挂第二条记忆，只能经这颗 0 分种子到达
+  // VoSeed 与 VoZero 之间不建边：zeroMem 拿不到任何别的到达路径。
+
+  const rows = await service.searchMemories("omega", { mode: "hybrid" });
+  assert.ok(rows.some((r) => r.id === nearB.id), "the weak memory itself still comes back via vector");
+  assert.ok(
+    !rows.some((r) => r.id === zeroMem.id),
+    "a 0-score seed must not pull its linked memory in at full tier"
+  );
+});
+
+// ---- Tag 桥接的排序 -------------------------------------------------------
+// 「一个实体命中了几条记忆」是这条路的强弱信号，必须在 SQL 里数。
+// 首版拿 entityIdsForMemories 的 DISTINCT 结果反推计数，每个实体恒为 1，
+// 排序静默失效、只剩名字序（评审指出）。判别点：limit=1 时返回的是宽实体。
+// 命名上必须让「宽实体」在字母序里排后面——首版把宽实体叫 AWide，于是字母序
+// 也选它，用例空转通过（变异自证抓到的）。
+test("findEntitiesByTags ranks entities by how many tagged memories they cover", async () => {
+  const { store, service } = makeService();
+  const m1 = putMemory(store, service, { title: "m1", content: "c1", tags: ["数据库迁移"] });
+  const m2 = putMemory(store, service, { title: "m2", content: "c2", tags: ["数据库迁移"] });
+  // ZWide 挂两条命中记忆；ANarrow 只挂一条。名字序让 ANarrow 排前面，
+  // 所以只要计数生效，返回的必然是 ZWide。
+  linkAttr(store, "ZWide", m1);
+  linkAttr(store, "ZWide", m2, { key: "k2" });
+  linkAttr(store, "ANarrow", m1);
+
+  const hits = store.findEntitiesByTags("数据库迁移", { limit: 1 });
+  assert.equal(hits.length, 1);
+  assert.equal(hits[0].name, "ZWide",
+    "the entity covering more tagged memories must win over the alphabetical order");
+});
+
+// ---- Tag 锚点的两个来源 ---------------------------------------------------
+// phaseRelations 只写 entity_relations.memory_id，不建 attr 行。所以「只通过关系
+// 挂到实体上」的记忆，若锚点只读 entity_attrs，关系两端一个种子都生不出来。
+// 判别点：这两个实体都没有任何 attr 行，只能从关系侧被看到。
+test("findEntitiesByTags sees relation endpoints, not only attr rows", () => {
+  const { store, service } = makeService();
+  const mem = putMemory(store, service, { title: "pg 调优", content: "一次调优", tags: ["postgres"] });
+  const a = store.createEntity({ name: "PgTuner", type: "module" });
+  const b = store.createEntity({ name: "PgCache", type: "module" });
+  store.saveRelation({
+    from_entity: a.id, to_entity: b.id, relation_type: "uses",
+    memory_id: mem.id, metadata: { source: "sleep_relation_completion" }
+  });
+
+  const names = store.findEntitiesByTags("postgres", { limit: 5 }).map((h) => h.name).sort();
+  assert.deepEqual(names, ["PgCache", "PgTuner"],
+    "a memory linked only through a relation must seed both endpoints");
+});
+
+// 同一 (实体, 记忆) 被 attr 与关系同时覆盖时只算一条：UNION 去的是对，不是行。
+test("findEntitiesByTags counts a memory once even when attr and relation both cover it", () => {
+  const { store, service } = makeService();
+  const m1 = putMemory(store, service, { title: "a", content: "b", tags: ["缓存"] });
+  const m2 = putMemory(store, service, { title: "c", content: "d", tags: ["缓存"] });
+  const wide = linkAttr(store, "ZBoth", m1);
+  store.saveRelation({ from_entity: wide.id, to_entity: wide.id, relation_type: "related_to", memory_id: m1.id });
+  linkAttr(store, "ABoth", m2);
+
+  const hits = store.findEntitiesByTags("缓存", { limit: 2 });
+  assert.deepEqual(hits.map((h) => h.name).sort(), ["ABoth", "ZBoth"]);
+  // 两边都是 1 条记忆时按名字序；若 m1 被数成 2 条，ZBoth 会排到前面。
+  assert.equal(hits[0].name, "ABoth",
+    "duplicate coverage of the same memory must not inflate the count");
+});
+
+// ---- 分块后计数仍然正确 ---------------------------------------------------
+// TAG_ID_CHUNK = 500，这条用例造 600 条命中记忆强制走两块：ZBulk 每块各 300 条
+// （合计 600），ABulk 只有 400 条（全在第一块）。判别点：正确累加时 ZBulk 胜出；
+// 若第二块覆盖而不是累加，ZBulk 只剩 300 < 400，字母序靠前的 ABulk 会赢。
+test("findEntitiesByTags accumulates counts across chunk boundaries", () => {
+  const { store } = makeService();
+  const zBulk = store.createEntity({ name: "ZBulk", type: "module" });
+  const aBulk = store.createEntity({ name: "ABulk", type: "module" });
+  const makeTagged = (i) => store.save({
+    type: "project", title: `t${i}`, content: `c${i}`, tags: ["分块测试"], importance: 3
+  });
+  // 600 条：前 300 条挂 ZBulk，后 300 条挂 ZBulk 的另一批 attr key，
+  // 其中前 400 条同时挂 ABulk（跨两块）。
+  for (let i = 0; i < 600; i++) {
+    const m = makeTagged(i);
+    store.saveAttr({ entity_id: zBulk.id, attr_key: `k${i % 2}`, attr_value: "v", memory_id: m.id });
+    if (i < 400) store.saveAttr({ entity_id: aBulk.id, attr_key: "k", attr_value: "v", memory_id: m.id });
+  }
+
+  const hits = store.findEntitiesByTags("分块测试", { limit: 1 });
+  assert.equal(hits.length, 1);
+  assert.equal(hits[0].name, "ZBulk",
+    "counts must be summed across chunks, not overwritten by the last batch");
+});

package/test/inject-pools.test.js

@@ -135,7 +135,8 @@ test("#249: capability guide registers exactly once, and stays off when the key
   assert.equal(on.sections.length, 1, "exactly one guide section");
   assert.equal(on.sections[0].name, "memory-guide");
   assert.equal(on.sections[0].order, 150, "插件指引段的既有 order 惯例");
-  assert.equal(on.sections[0].text, MEMORY_GUIDE_SECTION, "常量文本 → 同会话内稳定");
+  assert.equal(typeof on.sections[0].text, "function", "guide text resolves per prompt context so session gating can apply");
+  assert.equal(on.sections[0].text({}), MEMORY_GUIDE_SECTION, "normal sessions receive the same guide text");
   // 不可逆工具（memory_delete）的克制指引必须在场：这是全 guide 里唯一有数据
   // 损失后果的一句，被误删掉的回归要能立刻转红。
   assert.ok(MEMORY_GUIDE_SECTION.includes("memory_delete"), "guide keeps the irreversible-tool warning");

package/test/mint-source.test.js

@@ -200,3 +200,86 @@ test("mint source: rows are countable by source after minting", () => {
   assert.equal(bySource.get("manual"), undefined, "nothing minted here fell back to the default");
   store.close();
 });
+
+// ── Issue #512：铸造出来的记忆要能追到「哪一轮」 ──
+//
+// source 只说「哪条管道」，不说「哪一次运行」。同一管道跑过几百轮之后，
+// 「这条 pattern 是哪一轮抽出来的」在数据面上仍然不可读——这正是 #512 要补的。
+// 归因落在 memory_mints：dream/sleep 铸造的记忆没有会话区间（session/seq 都不存在），
+// 硬塞合成区间就是编的，所以窗口级归因（memory_provenance）与行级归因（本表）分层。
+
+test("issue#512: a created row remembers which run minted it", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "真模式", content: "规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "dream", runId: "run-abc" }
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "pattern minted");
+  const mints = store.mintsFor(row.id);
+  assert.equal(mints.length, 1, "one created row = one mint record");
+  assert.equal(mints[0].run_id, "run-abc");
+  assert.equal(mints[0].run_type, "dream");
+  assert.equal(mints[0].trigger_source, "autoDream");
+  store.close();
+});
+
+// 没有 run id 时什么都不写。旧装配（或直接调 applyDecisions 的调用方）没有 run 概念，
+// 这时候编一个 id 出来比留空更坏：它会让「能追到」变成一句谎话。
+test("issue#512: without a run id no mint record is fabricated", () => {
+  const { store, service } = setup();
+  applyDecisions(
+    [{ action: "create", type: "pattern", title: "无轮模式", content: "规律", importance: 3 }],
+    service,
+    null,
+    null,
+    { mintSource: "dream" }
+  );
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "pattern still minted — 记账缺失不该拦铸造");
+  assert.deepEqual(store.mintsFor(row.id), []);
+  store.close();
+});
+
+// 只记 create。merge/conflict/update/supersede 动的是既有行，receipt_chain 已按
+// (run_id, record_id) 记过一遍；再造一份就是第二套账，两边迟早对不上。
+test("issue#512: only creation is recorded — edits to existing rows stay in receipt_chain", () => {
+  const { store, service } = setup();
+  const existing = service.saveWithDedupe({ type: "project", title: "既有行", content: "旧内容", importance: 3 }).memory;
+  applyDecisions(
+    [{ action: "update", ids: [existing.id], content: "新内容", importance: 4 }],
+    service,
+    null,
+    null,
+    { mintSource: "dream", runId: "run-upd" }
+  );
+  assert.deepEqual(store.mintsFor(existing.id), [], "update 不是铸造，不进 memory_mints");
+  store.close();
+});
+
+// 端到端：sleep 真的跑一轮，铸造出来的行要指回那一轮的 runId（不是随便一个 id）。
+test("issue#512: sleep mints point back at the run that produced them", async () => {
+  const { store, service } = setup();
+  mint(service);
+  mint(service);
+  const ctx = sleepCtx(
+    JSON.stringify([{ action: "create", type: "pattern", title: "真模式", content: "从 a 和 b 提取", importance: 3 }])
+  );
+  const config = { sleepModeEnabled: true, sleepPatternMinMemories: 10, sleepMaxPatternPerRun: 3 };
+  const result = await runSleep(ctx, service, config, ctx.logger, null, null);
+  assert.equal(result.phases.patterns.status, "ok", "pattern phase minted");
+
+  const row = service.all().find((m) => m.type === "pattern");
+  assert.ok(row, "pattern minted");
+  const mints = store.mintsFor(row.id);
+  assert.equal(mints.length, 1);
+  assert.equal(mints[0].run_id, result.runId, "归因要指回这一轮的 runId，不是另编一个");
+  assert.equal(mints[0].run_type, "sleep");
+  assert.equal(mints[0].trigger_source, "sleep");
+  // 那一轮 run 台账本身也在：两边能对上，归因才成立。
+  assert.equal(store.getDreamRun(result.runId).run_type, "sleep");
+  store.close();
+});

package/test/pipeline-nudge-auto.test.js

@@ -1,6 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { createNudgeAutoRun } from "../src/pipeline-nudge-auto.js";
+import { createSessionGate } from "../src/session-gate.js";
 
 // 这组守的是**触发侧**（v0.9.3）：什么时候跑、跑几次、跑挂了怎么办。
 // 挖掘算法本身在 pipeline-nudge.test.js 里守，这里只守接线，所以 runNudge 全部用假的。
@@ -25,8 +26,8 @@ function fakeCtx() {
   };
 }
 
-function sessionAt(cwd) {
-  return { header: { cwd } };
+function sessionAt(cwd, id = undefined) {
+  return { ...(id ? { id } : {}), header: { cwd } };
 }
 
 /** 把 setTimeout(0) 排的活跑完：本模块刻意不用同步跑（见文件头）。 */
@@ -66,6 +67,29 @@ test("自动沉淀只认 turn/end：中途事件不排队、不预跑", async ()
   auto();
 });
 
+test("#539：无痕 turn/end 不触发全项目扫描，正常会话仍可触发", async () => {
+  const ctx = fakeCtx();
+  const calls = [];
+  const gate = createSessionGate({ sessionGateEnabled: true, sessionGateSessions: ["private"] });
+  const auto = createNudgeAutoRun({
+    ctx,
+    sessionGate: gate,
+    runNudge: (args) => { calls.push(args); return { counts: { savedProposals: 0 } }; },
+    now: () => 1_000_000
+  });
+
+  ctx.emit(sessionAt("D:/proj", "private"), { type: "turn/end" });
+  await tick();
+  assert.deepEqual(calls, [], "the incognito session itself cannot schedule a scan");
+  assert.equal(auto.pendingCount(), 0);
+
+  ctx.emit(sessionAt("D:/proj", "captain"), { type: "turn/end" });
+  await tick();
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].sessionGate, gate, "later project scans still exclude incognito session files");
+  auto();
+});
+
 test("自动跑永远是「只落提议、不落草稿」：materialize 恒 false", async () => {
   const ctx = fakeCtx();
   const calls = [];