@modusensus/dsh-mneme 0.8.11 → 0.8.13

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

package/test/inject-pools.test.js

@@ -173,3 +173,22 @@ test("#249: capability guide extends only the judgement-heavy tool descriptions"
     assert.ok(on.get(name).startsWith(off.get(name)), `${name}: guidance is appended, original text untouched`);
   }
 });
+
+test("#249: memory_save guidance states the scope default in the safe direction", () => {
+  // #164 口径：scope 参数漏填的后果是单向的——未标注 = 处处可见（NULL 恒可见），
+  // 而显式 scope 会让记忆在离开他 scope 时被降权（A2 软隔离 ×0.5，保留可见）或直接
+  // 过滤（A3 strictScope，默认关）。所以这一句必须同时给出「什么时候标注」与「不确定
+  // 就都别填」，只写前半句会把模型推向「能填就填」，正好制造那个单向损失。
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const registered = [];
+  createTools({ tools: { register(def) { registered.push(def); return () => {}; } } }, service, { injectGuidanceEnabled: true }, null);
+  const text = registered.find((t) => t.name === "memory_save").description;
+  assert.ok(text.includes("declare workspace_scope / agent_scope"), "scope declaration rule is present");
+  assert.ok(text.includes("otherwise leave both out"), "the no-scope default is stated, not just the declare case");
+  // 措辞回归锁：默认配置（strictScope 关）下他 scope 只是降权可见，不是消失。写成
+  // 「静默消失」既是错的，也会造出本来不存在的隐私预期。
+  assert.ok(!text.includes("silently disappears"), "must not claim a narrowed memory disappears silently");
+  // 回归锁：这句话不能只落在总则里（工具描述才是常驻、零注入成本的那个承载位）。
+  assert.ok(!MEMORY_GUIDE_SECTION.includes("declare workspace_scope / agent_scope"), "scope rule stays a per-tool rule, not a sixth general rule");
+});

package/test/scope-inject-soft.test.js

@@ -0,0 +1,106 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// issue #339 / E7 考卷补齐：A2 软加权（foreign ×0.5 / 命中 ×1.25）此前只作用于
+// searchMemories——E7 实测「explicit 标注 + 软档」的注入集与无标注逐条相同
+// （80/80），主泄露面上软档形同虚设。本文件锁注入通道的软加权语义：
+//   - softScope 激活（scopeEnabled + scope 至少一维可解析）→ foreign 行在层内
+//     数值积上 ×0.5，压不过同档自己行；未标注行同列吃 BOOST 不被压制；
+//   - flag 关 / scope 两维全空 → 注入序与改动前逐字节一致（锁平价）；
+//   - strictScope 硬过滤先行，被滤行不会被二次降权；
+//   - 加权后的序流入 pin 池选取（pin 拿到的是加权后次序）。
+
+function setup(config) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+const SCOPE_ME = { agent_scope: "me", workspace_scope: null };
+
+test("injectCandidates soft weight demotes explicit foreign rows below same-importance own rows", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: false });
+  // 同 importance 档（E7 的同档设计）：无软加权时全靠插入序，foreign 在前。
+  store.save({ type: "decision", title: "foreign-a", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "mine-a", content: "x", importance: 4, agent_scope: "me", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "foreign-b", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+
+  const injected = service.injectCandidates({ maxItems: 5, threshold: 3, scope: SCOPE_ME });
+  const titles = injected.map((m) => m.title);
+  // foreign ×0.5 = 2.0 < 自己 ×1.25 = 5.0：自己行第一；两条 foreign 同分，
+  // 相对序随 store.list 的同分序（updated_at），不锁。
+  assert.equal(titles[0], "mine-a");
+  assert.deepEqual(titles.slice(1).sort(), ["foreign-a", "foreign-b"]);
+});
+
+test("injectCandidates soft tier keeps unlabeled rows ranked with matches, not suppressed", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: false });
+  store.save({ type: "decision", title: "global", content: "x", importance: 4 });
+  store.save({ type: "decision", title: "foreign", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+
+  const injected = service.injectCandidates({ maxItems: 5, threshold: 3, scope: SCOPE_ME });
+  // 未标注 = 全局可见，与命中行同列（×1.25）而非被压到 foreign 之后。
+  assert.deepEqual(injected.map((m) => m.title), ["global", "foreign"]);
+});
+
+test("injectCandidates order is byte-identical when scopeEnabled is off or scope is anonymous", () => {
+  const seed = (store) => {
+    store.save({ type: "decision", title: "foreign-a", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+    store.save({ type: "decision", title: "mine-a", content: "x", importance: 4, agent_scope: "me", agent_scope_source: "explicit" });
+    store.save({ type: "decision", title: "global", content: "x", importance: 3 });
+  };
+  // flag 关：不传 scope（改动前后必须同序——锁平价）。
+  const off = setup({ scopeEnabled: false, strictScope: false });
+  seed(off.store);
+  // flag 开但身份两维全空：软加权门不激活，也不得改序。
+  const anon = setup({ scopeEnabled: true, strictScope: false });
+  seed(anon.store);
+
+  // 平价锁：两种情况的注入序必须一致（比较器与改动前逐字节相同）。
+  const baseline = off.service.injectCandidates({ maxItems: 5, threshold: 3 }).map((m) => m.title);
+  assert.deepEqual(
+    anon.service.injectCandidates({ maxItems: 5, threshold: 3, scope: { agent_scope: null, workspace_scope: null } }).map((m) => m.title),
+    baseline
+  );
+});
+
+test("strictScope hard filter runs before soft weighting: filtered rows are not double-demoted", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: true });
+  store.save({ type: "decision", title: "foreign", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "global", content: "x", importance: 3 });
+
+  const injected = service.injectCandidates({ maxItems: 5, threshold: 3, scope: SCOPE_ME });
+  // 硬墙先删 foreign；剩下的 global（未标注）吃 BOOST 保留——若软加权先跑会把
+  // foreign 压到后面再被删，成员虽同但语义不同；此处锁成员与顺序。
+  assert.deepEqual(injected.map((m) => m.title), ["global"]);
+});
+
+test("soft-weighted order feeds the pin pool (pin picks the weighted-first candidates)", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: false, pinnedInjectBudget: 1 });
+  // pin 池只收 constraint/preference——两条都用 preference，同档靠软加权分序。
+  store.save({ type: "preference", title: "foreign-pin", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "preference", title: "mine", content: "x", importance: 4, agent_scope: "me", agent_scope_source: "explicit" });
+
+  const pinnedStats = {};
+  const injected = service.injectCandidates({
+    maxItems: 5, threshold: 3, scope: SCOPE_ME, pinnedStats,
+  });
+  // 加权后 mine 在前：pin 池取的是加权后次序的第一条。
+  assert.equal(pinnedStats.shown, 1);
+  assert.equal(injected[0].title, "mine");
+});
+
+test("first-round BM25 fallback applies the soft weight (no query vector yet)", () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: false });
+  // 同内容同长度（标题各 1 token 且不在查询词表）→ BM25 原始分相同；
+  // 未加权时同分序随 store.list（updated desc，foreign 后存先出）。
+  store.save({ type: "decision", title: "alpha", content: "plan the dinner party menu with care", importance: 4, agent_scope: "me", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "bravo", content: "plan the dinner party menu with care", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+
+  const injected = service.injectCandidates({
+    query: "dinner party menu", maxItems: 5, threshold: 3, scope: SCOPE_ME,
+  });
+  assert.equal(injected[0].title, "alpha", "BM25 hits are soft-weighted before the semantic-first merge");
+});

package/test/scope-strict.test.js

@@ -229,3 +229,115 @@ test("memory_list filters explicit rows and keeps total consistent under strictS
   assert.deepEqual(out2.items.map((m) => m.title), ["theirs"]);
   assert.equal(out2.total, 1);
 });
+
+// --- entity: / attr: 前缀路的 scope 闸 ----------------------------------------
+// 回归锁：这两条前缀路在 searchMemories 的入口就 return，早于融合池那道 strictScope
+// 过滤，曾经整条绕过硬墙——显式他者 scope 的记忆用 `entity:` / `attr:` 就能原样读出，
+// 而且是满分返回（连 A2 的 ×0.5 都没有）。所以除了「出局」，还要钉住「auto / 存量
+// 他者保留」这条 A2 语义没有跟着塌掉。
+
+/** 把若干记忆挂到同一个实体上。
+ *  属性键必须各不相同：同一 (实体, 键) 有时间轴语义，后写的一条会把前一条作废，
+ *  那样只有最后一条会被链接上（写这个测试时踩过，别改成同一个键）。 */
+function linkToEntity(store, name, memories) {
+  const entity = store.createEntity({ name, type: "person" });
+  memories.forEach((mem, i) => {
+    store.saveAttr({ entity_id: entity.id, attr_key: `attr${i}`, attr_value: `value${i}`, memory_id: mem.id });
+  });
+  return entity;
+}
+
+/** 五条覆盖各种 scope 来源的记忆，供下面两条用。 */
+function saveScopeBattery(store) {
+  return {
+    global: store.save({ type: "project", title: "global", content: "x" }),
+    mine: store.save({ type: "project", title: "mine", content: "x", agent_scope: "me", agent_scope_source: "explicit" }),
+    theirs: store.save({ type: "project", title: "theirs", content: "x", agent_scope: "other", agent_scope_source: "explicit" }),
+    autoForeign: store.save({ type: "project", title: "auto", content: "x", agent_scope: "other", agent_scope_source: "auto" }),
+    legacyForeign: store.save({ type: "project", title: "legacy", content: "x", agent_scope: "other" })
+  };
+}
+
+test("searchMemories entity: prefix honours the strictScope hard filter", async () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: true, entitySearchEnabled: true });
+  const rows = saveScopeBattery(store);
+  linkToEntity(store, "阿尔托", Object.values(rows));
+
+  const asMe = await service.searchMemories("entity:阿尔托", { scope: { agent_scope: "me", workspace_scope: null } });
+  assert.deepEqual(asMe.map((m) => m.title).sort(), ["auto", "global", "legacy", "mine"], "显式他者出局，auto / 存量他者按 A2 保留");
+
+  // 原主人自己查：显式那条必须还在（否则上面是「谁都搜不到」的假绿）。
+  const asOther = await service.searchMemories("entity:阿尔托", { scope: { agent_scope: "other", workspace_scope: null } });
+  assert.ok(asOther.some((m) => m.title === "theirs"), "命中当前 agent 的显式行必须可见");
+});
+
+test("searchMemories attr: prefix honours the strictScope hard filter", async () => {
+  const { store, service } = setup({ scopeEnabled: true, strictScope: true, entitySearchEnabled: true });
+  const rows = saveScopeBattery(store);
+  // 每条挂到各自实体上、共用一个属性键：这样 attr:key=value 能一次覆盖全部五条
+  // （同实体同键会被时间轴作废，见 linkToEntity 的注释）。
+  Object.values(rows).forEach((mem, i) => {
+    const entity = store.createEntity({ name: `entity-${i}`, type: "person" });
+    store.saveAttr({ entity_id: entity.id, attr_key: "国籍", attr_value: "芬兰", memory_id: mem.id });
+  });
+
+  const asMe = await service.searchMemories("attr:国籍=芬兰", { scope: { agent_scope: "me", workspace_scope: null } });
+  assert.deepEqual(asMe.map((m) => m.title).sort(), ["auto", "global", "legacy", "mine"], "显式他者出局，auto / 存量他者按 A2 保留");
+
+  const asOther = await service.searchMemories("attr:国籍=芬兰", { scope: { agent_scope: "other", workspace_scope: null } });
+  assert.ok(asOther.some((m) => m.title === "theirs"), "命中当前 agent 的显式行必须可见");
+});
+
+test("entity: / attr: 的 scope 闸在触达之前：出局的行不被回温，也不 bump 关联边", async () => {
+  // 闸门若只加在「返回前」，出局的行仍会先被 touchRecalled 摸一遍——一次越权检索
+  // 照样给它刷回温时钟、并在被动确认开启时 bump 它的关联边。所以这条钉的是次序。
+  const { store, service } = setup({
+    scopeEnabled: true, strictScope: true, entitySearchEnabled: true,
+    heatEnabled: true, graphWeightEnabled: true, graphPassiveConfirm: true, graphWeightDelta: 0.1
+  });
+  const theirs = store.save({ type: "project", title: "theirs", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
+  const global = store.save({ type: "project", title: "global", content: "x" });
+  linkToEntity(store, "阿尔托", [theirs, global]);
+
+  const a = store.createEntity({ name: "A", type: "technology" });
+  const b = store.createEntity({ name: "B", type: "technology" });
+  for (const mem of [theirs, global]) {
+    store.saveRelation({ from_entity: a.id, to_entity: b.id, relation_type: "uses", memory_id: mem.id, source: "llm" });
+  }
+
+  const rows = await service.searchMemories("entity:阿尔托", { scope: { agent_scope: "me", workspace_scope: null } });
+  assert.deepEqual(rows.map((m) => m.title), ["global"], "只剩可见那条");
+
+  // 正向对照：可见那条确实被触达了——否则下面两个「没被触达」可能是假绿。
+  assert.ok(store.getRelationsByMemory(global.id)[0].weight > 0.4, "可见行照常 bump 关联边");
+  assert.ok(store.getById(global.id).last_accessed_at, "可见行照常回温");
+
+  assert.equal(store.getRelationsByMemory(theirs.id)[0].weight, 0.4, "出局行不该 bump 关联边");
+  assert.equal(store.getById(theirs.id).last_accessed_at ?? null, null, "出局行不该被回温");
+});
+
+test("scope 闸先于 topK 截断：出局的候选不占名额（topK=1 仍有可见结果）", async () => {
+  // 回归锁（评审发现）：先 slice 再 filter 的话，排在前面那条被闸掉的候选会占住唯一的
+  // 槽位，明明还有可见匹配却返回空数组。用 topK=1 把次序钉死——排序不动，只是闸门要插
+  // 在截断之前。
+  const me = { agent_scope: "me", workspace_scope: null };
+
+  const { store, service } = setup({ scopeEnabled: true, strictScope: true, entitySearchEnabled: true });
+  const theirsE = store.save({ type: "project", title: "theirs", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
+  const mineE = store.save({ type: "project", title: "mine", content: "x", agent_scope: "me", agent_scope_source: "explicit" });
+  // 先挂 theirs、后挂 mine：前者排在候选前面，正好充当那个「占位」的候选。
+  linkToEntity(store, "阿尔托", [theirsE, mineE]);
+  const viaEntity = await service.searchMemories("entity:阿尔托", { topK: 1, scope: me });
+  assert.deepEqual(viaEntity.map((m) => m.title), ["mine"], "entity: 在 topK=1 下不该被出局候选挤空");
+
+  // attr: 同理——两条挂同一个属性键、各挂自己的实体，theirs 先写入。
+  const { store: s2, service: svc2 } = setup({ scopeEnabled: true, strictScope: true, entitySearchEnabled: true });
+  const theirsA = s2.save({ type: "project", title: "theirs", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
+  const mineA = s2.save({ type: "project", title: "mine", content: "x", agent_scope: "me", agent_scope_source: "explicit" });
+  for (const [i, mem] of [theirsA, mineA].entries()) {
+    const entity = s2.createEntity({ name: `e${i}`, type: "person" });
+    s2.saveAttr({ entity_id: entity.id, attr_key: "国籍", attr_value: "芬兰", memory_id: mem.id });
+  }
+  const viaAttr = await svc2.searchMemories("attr:国籍=芬兰", { topK: 1, scope: me });
+  assert.deepEqual(viaAttr.map((m) => m.title), ["mine"], "attr: 在 topK=1 下不该被出局候选挤空");
+});