@modusensus/dsh-mneme 0.7.32 → 0.8.0

package/test/inject.test.js

@@ -154,3 +154,96 @@ test("Issue #129: 扁平的 data.content 形状仍被兼容", () => {
   assert.ok(text.includes("问题"), "query present");
   assert.ok(text.includes("扁平形状的回答"), "flat content shape still supported");
 });
+
+// ---- issue #162: 注入边界花括号转义(v0.7.4 #40 修复被 v0.7.11 误删后恢复) ----
+
+test("issue #162: {{...}} in memory content is escaped at the injection boundary", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "模板记忆", content: "{{hl|highlight}} 和 {{挖空}} {{关键词}}", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("模板记忆"), "memory still rendered by title");
+  assert.ok(text.includes("{\\{hl|highlight}\\}"), "ASCII template braces escaped");
+  assert.ok(text.includes("{\\{挖空}\\}"), "CJK template braces escaped");
+  assert.ok(!text.includes("{{"), "no raw {{ survives into the prompt");
+  assert.ok(!text.includes("}}"), "no raw }} survives into the prompt");
+});
+
+test("issue #162: odd brace runs like {{{a}}} are escaped too", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "三层模板", content: "{{{a}}} 和 }}} 结尾", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(!text.includes("{{"), "no raw {{ for odd brace runs");
+  assert.ok(!text.includes("}}"), "no raw }} for odd brace runs");
+});
+
+test("issue #162: {{...}} in user profile/rules is escaped", () => {
+  const { contexts, settings } = setup();
+  settings.setProfile("我叫{{名字}}，前端开发者");
+  settings.setRules(["回答时用 {{hl|term}}", "以 }} 结尾的规则"]);
+  const settingsCtx = contexts.find((c) => c.name === "user-settings");
+  const text = settingsCtx.text({});
+  assert.ok(text.includes("{\\{名字}\\}"), "profile braces escaped");
+  assert.ok(text.includes("{\\{hl|term}\\}"), "rule braces escaped");
+  assert.ok(!text.includes("{{"), "no raw {{ in user-settings block");
+  assert.ok(!text.includes("}}"), "no raw }} in user-settings block");
+});
+
+test("issue #162: hot-context rounds with {{...}} are escaped", () => {
+  const { contexts } = setup();
+  const text = contexts[0].text({
+    agent: {
+      session: {
+        id: "s1",
+        events: [
+          { type: "user/message", data: { source: { kind: "user" }, content: ["用 {{hl|你好}} 测试"] } },
+          { type: "assistant/message", data: { source: { kind: "assistant" }, content: ["返回 {{答案}}"] } }
+        ]
+      }
+    }
+  });
+  assert.ok(text.includes("[短期上下文]"), "hot context rendered");
+  assert.ok(!text.includes("{{"), "no raw {{ in hot context");
+  assert.ok(!text.includes("}}"), "no raw }} in hot context");
+});
+
+test("issue #162: reasoning parts are excluded from hot memory (docker --format case)", () => {
+  const { contexts } = setup();
+  // issue #162 的触发源：assistant 的 reasoning part 是 { type: "reasoning", text }
+  // 结构，内容里出现 docker --format "{{.Server.Version}}" 时，若被注入 hot memory
+  // 会让 DSH interpolate() 扫到非法变量名 throw → 整轮永久失败。textOf 必须跳过它。
+  const text = contexts[0].text({
+    agent: {
+      session: {
+        id: "s1",
+        events: [
+          { type: "user/message", data: { source: { kind: "user" }, content: ["检查 docker 版本"] } },
+          {
+            type: "assistant/message",
+            data: {
+              source: { kind: "assistant" },
+              content: [
+                { type: "reasoning", text: "运行 docker version --format \"{{.Server.Version}}\" 查看版本" },
+                { type: "text", text: "已检查，Docker 版本 27.1.1。" }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  });
+  // reasoning 不应进入 hot memory
+  assert.ok(!text.includes("Server.Version"), "reasoning text excluded from hot memory");
+  // 正文保留
+  assert.ok(text.includes("27.1.1"), "assistant text part still injected");
+  // 整个注入块没有任何原始 {{ (双保险：即使将来 reasoning 被引入，也会被转义)
+  assert.ok(!text.includes("{{"), "no raw {{ anywhere in injected context");
+  assert.ok(!text.includes("}}"), "no raw }} anywhere in injected context");
+});
+
+test("issue #162: escapePromptVariables=false passes {{...}} through verbatim", () => {
+  const { contexts, service } = setup({ escapePromptVariables: false });
+  service.saveWithDedupe({ type: "preference", title: "模板", content: "{{挖空}} 与 {{hl|term}}", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("{{挖空}}"), "raw braces preserved when escaping disabled");
+  assert.ok(text.includes("{{hl|term}}"), "raw ASCII braces preserved when escaping disabled");
+});

package/test/scope-retrieval.test.js

@@ -0,0 +1,197 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+
+// v0.8.0 A2（issue #17）：检索加权 + occurred_at 时间过滤。
+// 当前 scope 加成、他 scope 降权但保留可见；occurred 窗在 store.list/count 与
+// 搜索融合池两处同口径（COALESCE 回退 created_at）。
+
+test("store.list/count filter by occurred_at with created_at fallback", () => {
+  const store = createStore(":memory:");
+  store.save({ type: "project", title: "aug", content: "x", occurred_at: "2026-08-15T00:00:00Z" });
+  store.save({ type: "project", title: "sep", content: "x", occurred_at: "2026-09-01T00:00:00Z" });
+  // 未标注 occurred_at → 回退 created_at（今天，2026-09-13）参与比较。
+  store.save({ type: "project", title: "legacy", content: "x" });
+
+  const aug = store.list({ occurredFrom: "2026-08-01", occurredTo: "2026-08-31" });
+  assert.deepEqual(aug.map((m) => m.title), ["aug"]);
+  assert.equal(store.count("project", { occurredFrom: "2026-08-01", occurredTo: "2026-08-31" }), 1);
+
+  // 回退方向：窗口从「今天」起（日期从刚写入行的 created_at 推导，不依赖
+  // 测试机时钟/时区），未标注行靠 created_at 落入；sep 的 occurred 是月初，
+  // 在窗口外。
+  const legacyRow = store.list({}).find((m) => m.title === "legacy");
+  const today = legacyRow.created_at.slice(0, 10);
+  const sinceToday = store.list({ occurredFrom: today }).map((m) => m.title);
+  assert.deepEqual(sinceToday, ["legacy"]);
+
+  // 非法边界值被忽略（不进 WHERE），三行都在。
+  assert.equal(store.list({ occurredFrom: "garbage", occurredTo: 42 }).length, 3);
+});
+
+test("service.list/count pass the occurred window through", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  store.save({ type: "decision", title: "old", content: "x", occurred_at: "2026-01-10T00:00:00Z" });
+  store.save({ type: "decision", title: "new", content: "x", occurred_at: "2026-06-10T00:00:00Z" });
+  const rows = service.list({ occurredFrom: "2026-06-01" });
+  assert.deepEqual(rows.map((m) => m.title), ["new"]);
+  assert.equal(service.count("decision", { occurredFrom: "2026-06-01" }), 1);
+});
+
+test("searchMemories applies the occurred window to the fused pool", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  store.save({ type: "project", title: "needle aug", content: "hit", occurred_at: "2026-08-15T00:00:00Z" });
+  store.save({ type: "project", title: "needle legacy", content: "hit" });
+
+  const all = await service.searchMemories("needle", { mode: "keyword" });
+  assert.equal(all.length, 2);
+
+  const windowed = await service.searchMemories("needle", {
+    mode: "keyword",
+    occurredFrom: "2026-08-01",
+    occurredTo: "2026-08-31"
+  });
+  assert.deepEqual(windowed.map((m) => m.title), ["needle aug"]);
+});
+
+test("searchMemories scope weighting: current scope boosted, foreign demoted but visible", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { scopeEnabled: true } });
+  // 打分构造（scoreKeyword：标题命中 1 × 0.8，正文命中 0.6 × 0.8）：
+  // 无加权时 alpha (0.8) 排在 beta (0.48) 前。
+  store.save({ type: "project", title: "alpha needle", content: "x", agent_scope: "coder" });
+  store.save({ type: "project", title: "beta", content: "needle", agent_scope: "novelist" });
+
+  // 当前会话是 novelist：beta 命中 ×1.25=0.6，alpha 他 scope ×0.5=0.4 → 翻转，
+  // 但 alpha 仍可见（降权不是过滤）。
+  const weighted = await service.searchMemories("needle", {
+    mode: "keyword",
+    scope: { agent_scope: "novelist", workspace_scope: null }
+  });
+  assert.deepEqual(weighted.map((m) => m.title), ["beta", "alpha needle"]);
+
+  // 无 scope 传参 → 不动分，保持基线排序。
+  const neutral = await service.searchMemories("needle", { mode: "keyword" });
+  assert.deepEqual(neutral.map((m) => m.title), ["alpha needle", "beta"]);
+
+  // scope 全 NULL（解析不出）→ 同样不动分。
+  const nullScope = await service.searchMemories("needle", {
+    mode: "keyword",
+    scope: { agent_scope: null, workspace_scope: null }
+  });
+  assert.deepEqual(nullScope.map((m) => m.title), ["alpha needle", "beta"]);
+});
+
+test("searchMemories weighting is off entirely when the flag is off", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  store.save({ type: "project", title: "alpha needle", content: "x", agent_scope: "coder" });
+  store.save({ type: "project", title: "beta", content: "needle", agent_scope: "novelist" });
+  const rows = await service.searchMemories("needle", {
+    mode: "keyword",
+    scope: { agent_scope: "novelist", workspace_scope: null }
+  });
+  assert.deepEqual(rows.map((m) => m.title), ["alpha needle", "beta"]);
+});
+
+test("unscoped rows rank with matched rows under weighting (never suppressed)", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { scopeEnabled: true } });
+  store.save({ type: "project", title: "global needle", content: "x" });
+  store.save({ type: "project", title: "foreign", content: "needle", agent_scope: "someone-else" });
+  const rows = await service.searchMemories("needle", {
+    mode: "keyword",
+    scope: { agent_scope: "me", workspace_scope: null }
+  });
+  // 未标注行与命中行同列吃 BOOST（×1.25），foreign 行 ×0.5——不被任何会话压掉。
+  assert.deepEqual(rows.map((m) => m.title), ["global needle", "foreign"]);
+});
+
+function setupTools(config) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const registered = [];
+  createTools(
+    { tools: { register(def) { registered.push(def); return () => {}; } } },
+    service,
+    config
+  );
+  const pick = (name) => registered.find((def) => def.name === name);
+  return { store, service, pick };
+}
+
+async function runHandler(def, args, exec) {
+  const handler = def.execute.bind(def);
+  return handler(args, exec);
+}
+
+test("toApiList surfaces scope annotation and occurred_at", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  store.save({
+    type: "pitfall",
+    title: "stamped",
+    content: "x",
+    agent_scope: "coder",
+    workspace_scope: "D:\\proj",
+    sensitivity: "personal",
+    occurred_at: "2026-09-12T08:00:00Z"
+  });
+  const [row] = service.toApiList([store.getById(
+    service.list({}).find((m) => m.title === "stamped").id
+  )]);
+  assert.equal(row.agent_scope, "coder");
+  assert.equal(row.workspace_scope, "D:\\proj");
+  assert.equal(row.sensitivity, "personal");
+  assert.equal(row.occurred_at, "2026-09-12T08:00:00.000Z");
+  // 未标注行四字段为 undefined（JSON 序列化时省略）。
+  store.save({ type: "pitfall", title: "plain", content: "x" });
+  const [plain] = service.toApiList([service.list({}).find((m) => m.title === "plain")]);
+  assert.equal(plain.agent_scope, undefined);
+  assert.equal(plain.occurred_at, undefined);
+});
+
+test("memory_search passes the session scope and occurred window through", async () => {
+  const { store, pick } = setupTools({ scopeEnabled: true });
+  store.save({ type: "project", title: "alpha needle", content: "x", agent_scope: "coder" });
+  store.save({
+    type: "project", title: "beta", content: "needle", agent_scope: "novelist",
+    occurred_at: "2026-08-15T00:00:00Z"
+  });
+  const search = pick("memory_search");
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "novelist", cwd: "D:\\p" } } } };
+  const args = { query: "needle", occurred_from: "2026-08-01", occurred_to: "2026-08-31" };
+  const out = await runHandler(search, args, exec);
+  // 窗口内只剩 beta；其 agent_scope 命中当前会话（novelist），标注随行透出。
+  assert.equal(out.items.length, 1);
+  assert.equal(out.items[0].title, "beta");
+  assert.equal(out.items[0].agent_scope, "novelist");
+  assert.equal(out.items[0].occurred_at, "2026-08-15T00:00:00.000Z");
+});
+
+test("memory_list filters by the occurred window and keeps total consistent", async () => {
+  const { store, pick } = setupTools({});
+  store.save({ type: "decision", title: "old", content: "x", occurred_at: "2026-01-10T00:00:00Z" });
+  store.save({ type: "decision", title: "new", content: "x", occurred_at: "2026-06-10T00:00:00Z" });
+  const list = pick("memory_list");
+  const args = { type: "decision", occurred_from: "2026-06-01" };
+  const out = await runHandler(list, args, undefined);
+  assert.deepEqual(out.items.map((m) => m.title), ["new"]);
+  assert.equal(out.total, 1);
+});
+
+test("memory_get returns scope annotation and occurred_at", async () => {
+  const { store, pick } = setupTools({});
+  const saved = store.save({
+    type: "pitfall", title: "t", content: "c",
+    agent_scope: "coder", occurred_at: "2026-09-12T08:00:00Z"
+  });
+  const get = pick("memory_get");
+  const out = await runHandler(get, { id: saved.id }, undefined);
+  assert.equal(out.memory.agent_scope, "coder");
+  assert.equal(out.memory.occurred_at, "2026-09-12T08:00:00.000Z");
+});

package/test/scope-storage.test.js

@@ -0,0 +1,247 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+import { createScopeResolver } from "../src/scope.js";
+
+// v0.8.0 A1（issue #17）：scope 隔离存储层。
+// 四列可空（agent_scope/workspace_scope/sensitivity/occurred_at）、迁移纯增量
+// 不带 DEFAULT；写入标注走 scopeEnabled 门控；去重键扩展 (type, title, scope…)。
+
+test("migration adds four nullable scope columns without defaults", () => {
+  const store = createStore(":memory:");
+  const cols = store.db.prepare("PRAGMA table_info(memories)").all();
+  for (const name of ["agent_scope", "workspace_scope", "sensitivity", "occurred_at"]) {
+    const col = cols.find((c) => c.name === name);
+    assert.ok(col, `column ${name} should exist`);
+    assert.equal(col.notnull, 0, `${name} must be nullable`);
+    assert.equal(col.dflt_value, null, `${name} must not carry a DEFAULT (存量零重写)`);
+  }
+});
+
+test("rows written without scope fields read back unscoped (legacy semantics)", () => {
+  const store = createStore(":memory:");
+  const row = store.save({ type: "project", title: "legacy shape", content: "body" });
+  assert.equal(row.agent_scope, undefined);
+  assert.equal(row.workspace_scope, undefined);
+  assert.equal(row.sensitivity, undefined);
+  assert.equal(row.occurred_at, undefined);
+});
+
+test("store.save persists and normalizes scope fields; dirty input lands as NULL", () => {
+  const store = createStore(":memory:");
+  const kept = store.save({
+    type: "project",
+    title: "scoped",
+    content: "c",
+    agent_scope: "  coder-agent  ",
+    workspace_scope: "D:\\proj",
+    sensitivity: "personal",
+    occurred_at: "2026-09-13T10:00:00+08:00"
+  });
+  assert.equal(kept.agent_scope, "coder-agent");
+  assert.equal(kept.workspace_scope, "D:\\proj");
+  assert.equal(kept.sensitivity, "personal");
+  // 时区归一：A2 的时间过滤按 ISO 字典序直接比较。
+  assert.equal(kept.occurred_at, "2026-09-13T02:00:00.000Z");
+
+  const dirty = store.save({
+    type: "project",
+    title: "dirty",
+    content: "c",
+    agent_scope: "   ",
+    workspace_scope: 42,
+    sensitivity: "",
+    occurred_at: "not-a-date"
+  });
+  assert.equal(dirty.agent_scope, undefined);
+  assert.equal(dirty.workspace_scope, undefined);
+  assert.equal(dirty.sensitivity, undefined);
+  assert.equal(dirty.occurred_at, undefined);
+});
+
+test("store.update keeps scope columns untouched (write-time annotation is immutable)", () => {
+  const store = createStore(":memory:");
+  const saved = store.save({ type: "decision", title: "t", content: "old", agent_scope: "a1", workspace_scope: "w1" });
+  store.update(saved.id, { content: "new", importance: 4 });
+  const row = store.getById(saved.id);
+  assert.equal(row.content, "new");
+  assert.equal(row.agent_scope, "a1");
+  assert.equal(row.workspace_scope, "w1");
+});
+
+test("scopeEnabled=false keeps legacy dedupe: cross-scope same-title still merges", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  store.save({ type: "project", title: "T", content: "scoped body", agent_scope: "agentA" });
+  const { action } = service.saveWithDedupe({ type: "project", title: "T", content: "new body" });
+  assert.equal(action, "merged");
+  assert.equal(store.count("project"), 1);
+});
+
+test("scopeEnabled=true: dedupe key extends with agent_scope/workspace_scope/sensitivity", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { scopeEnabled: true } });
+  const save = (fields) => service.saveWithDedupe({ type: "project", title: "T", content: "body", ...fields });
+
+  assert.equal(save({ agent_scope: "agentA" }).action, "created");
+  // 同标题、不同 agent_scope → 独立行，绝不互相合并。
+  assert.equal(save({ agent_scope: "agentB" }).action, "created");
+  // 不同 workspace_scope → 独立行。
+  assert.equal(save({ agent_scope: "agentA", workspace_scope: "D:\\proj-a" }).action, "created");
+  // 不同 sensitivity → 独立行。
+  assert.equal(save({ agent_scope: "agentA", sensitivity: "personal" }).action, "created");
+  // 三元组全同 → 合并。
+  assert.equal(save({ agent_scope: "agentA" }).action, "merged");
+  assert.equal(store.count("project"), 4);
+});
+
+test("scopeEnabled=true: unscoped writes match legacy NULL rows but not stamped ones", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { scopeEnabled: true } });
+  // 存量形状（NULL scope）。
+  store.save({ type: "preference", title: "P", content: "legacy" });
+  // 未标注新写入与存量 NULL 行互相匹配。
+  assert.equal(service.saveWithDedupe({ type: "preference", title: "P", content: "x" }).action, "merged");
+  // 已标注行与 NULL 行不匹配 → 独立新行。
+  assert.equal(service.saveWithDedupe({ type: "preference", title: "P", content: "x", agent_scope: "agentA" }).action, "created");
+  assert.equal(store.count("preference"), 2);
+});
+
+test("scopeEnabled=true: _mergeInto across scopes is rejected and falls back to a fresh row", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { scopeEnabled: true } });
+  const scoped = store.save({ type: "project", title: "S", content: "scoped", agent_scope: "agentA" });
+  const cross = service.saveWithDedupe({
+    type: "project", title: "S", content: "summary text", _mergeInto: scoped.id
+  });
+  assert.equal(cross.action, "created", "cross-scope semantic merge must not leak into the scoped row");
+  const same = service.saveWithDedupe({
+    type: "project", title: "S2", content: "more text", agent_scope: "agentA", _mergeInto: scoped.id
+  });
+  assert.equal(same.action, "merged", "same-scope explicit target still merges");
+  assert.equal(same.memory.id, scoped.id);
+});
+
+function setupTools(config) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const registered = [];
+  createTools(
+    { tools: { register(def) { registered.push(def); return () => {}; } } },
+    service,
+    config
+  );
+  const memorySave = registered.find((def) => def.name === "memory_save");
+  assert.ok(memorySave, "memory_save registered");
+  return { store, memorySave };
+}
+
+async function runMemorySave(memorySave, args, exec) {
+  const handler = memorySave.execute.bind(memorySave);
+  return handler(args, exec);
+}
+
+test("memory_save stamps resolved scope onto the row when the flag is on", async () => {
+  const { store, memorySave } = setupTools({ scopeEnabled: true });
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "coder", cwd: "D:\\proj" } } } };
+  const args = { type: "pitfall", title: "T", content: "c", sensitivity: "personal", occurred_at: "2026-09-12T00:00:00Z" };
+  const out = await runMemorySave(memorySave, args, exec);
+  const row = store.getById(out.id);
+  assert.equal(row.agent_scope, "coder");
+  assert.equal(row.workspace_scope, "D:\\proj");
+  assert.equal(row.sensitivity, "personal");
+  assert.equal(row.occurred_at, "2026-09-12T00:00:00.000Z");
+});
+
+test("memory_save without exec context writes unscoped rows (flag on, nothing resolvable)", async () => {
+  const { store, memorySave } = setupTools({ scopeEnabled: true });
+  const out = await runMemorySave(memorySave, { type: "pitfall", title: "T", content: "c" }, undefined);
+  const row = store.getById(out.id);
+  assert.equal(row.agent_scope, undefined);
+  assert.equal(row.workspace_scope, undefined);
+});
+
+test("memory_save with the flag off writes rows without any scope annotation", async () => {
+  const { store, memorySave } = setupTools({});
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "coder", cwd: "D:\\proj" } } } };
+  const out = await runMemorySave(memorySave, { type: "pitfall", title: "T", content: "c" }, exec);
+  const row = store.getById(out.id);
+  assert.equal(row.agent_scope, undefined);
+  assert.equal(row.workspace_scope, undefined);
+});
+
+test("createScopeResolver returns null when scopeEnabled is off", () => {
+  const resolve = createScopeResolver({ ctx: {}, config: {} });
+  assert.equal(resolve({ agent: { session: { id: "s1" } } }), null);
+});
+
+test("resolver stamps agentPreset and header cwd; registry hit wins over header cwd", () => {
+  const resolve = createScopeResolver({
+    config: { scopeEnabled: true },
+    ctx: { workspaceRegistry: { list: () => [{ path: "C:\\canon", sessionIds: ["s1"] }] } }
+  });
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "coder", cwd: "D:\\raw" } } } };
+  assert.deepEqual(resolve(exec), { agent_scope: "coder", workspace_scope: "C:\\canon" });
+
+  const resolveNoHit = createScopeResolver({
+    config: { scopeEnabled: true },
+    ctx: { workspaceRegistry: { list: () => [{ path: "C:\\canon", sessionIds: ["other"] }] } }
+  });
+  assert.deepEqual(resolveNoHit(exec), { agent_scope: "coder", workspace_scope: "D:\\raw" });
+});
+
+test("resolver falls back to the static .header property on old hosts", () => {
+  const resolve = createScopeResolver({ config: { scopeEnabled: true }, ctx: {} });
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "novelist" } } } };
+  assert.deepEqual(resolve(exec), { agent_scope: "novelist", workspace_scope: null });
+});
+
+test("session.header wins over requestHeader() (EpochHeader must not shadow the durable header)", () => {
+  const resolve = createScopeResolver({ config: { scopeEnabled: true }, ctx: {} });
+  // 本地 web 复验（2026-09-13）实测踩中的形状：requestHeader() 返回请求级
+  // EpochHeader（模型路由头，无 agentPreset/cwd），曾在首个请求后遮蔽
+  // session.header，导致标注全空。
+  const exec = {
+    agent: {
+      session: {
+        id: "s1",
+        header: { agentPreset: "coder", cwd: "D:\\proj" },
+        requestHeader: () => ({ config: { provider: "deepseek-official", model: "deepseek-v4-flash" } })
+      }
+    }
+  };
+  assert.deepEqual(resolve(exec), { agent_scope: "coder", workspace_scope: "D:\\proj" });
+});
+
+test("hosts without .header fall back to requestHeader().config shape", () => {
+  const resolve = createScopeResolver({ config: { scopeEnabled: true }, ctx: {} });
+  const exec = {
+    agent: {
+      session: {
+        id: "s2",
+        requestHeader: () => ({ config: { agentPreset: "legacy", cwd: "E:\\old" } })
+      }
+    }
+  };
+  assert.deepEqual(resolve(exec), { agent_scope: "legacy", workspace_scope: "E:\\old" });
+});
+
+test("resolver never throws: registry explosion degrades to header cwd and warns once", () => {
+  const warnings = [];
+  const resolve = createScopeResolver({
+    config: { scopeEnabled: true },
+    ctx: { workspaceRegistry: { list: () => { throw new Error("boom"); } } },
+    logger: { warn: (m) => warnings.push(String(m)) }
+  });
+  const exec = { agent: { session: { id: "s1", header: { agentPreset: "coder", cwd: "D:\\raw" } } } };
+  assert.deepEqual(resolve(exec), { agent_scope: "coder", workspace_scope: "D:\\raw" });
+  assert.equal(warnings.length, 1, "warn exactly once, never block the write path");
+});
+
+test("resolver without a session or header lands all-NULL", () => {
+  const resolve = createScopeResolver({ config: { scopeEnabled: true }, ctx: {} });
+  assert.deepEqual(resolve(undefined), { agent_scope: null, workspace_scope: null });
+  assert.deepEqual(resolve({ agent: { session: { id: "s2" } } }), { agent_scope: null, workspace_scope: null });
+});