@modusensus/dsh-mneme 0.14.0-beta.1 → 0.14.0-beta.2

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

@@ -1,106 +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");
-});
+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-optional-service.test.js

@@ -1,110 +1,110 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createScopeResolver } from "../src/scope.js";
-
-// issue #487：workspaceRegistry 不在 inject 声明里（src/index.js:45），而 cordis 4
-// 的 ctx 是 Proxy——裸读未注入属性会抛 "cannot get property ... without inject"，
-// 不返回 undefined。于是 scope.js 曾经那行 `ctx?.workspaceRegistry?.list?.()` 从
-// v0.8.0 起必然抛错走降级：canonical path 归一与成员资格校验静默失效，只剩
-// header.cwd。
-//
-// 为什么既有测试没拦住：scope-storage.test.js 里三处 registry 测试都用普通对象
-// 伪造 ctx（{ workspaceRegistry: {...} }），普通对象裸读不抛错。本文件改用
-// 「读未声明属性即抛」的 Proxy 复刻真实宿主形状，把两侧行为都钉死。
-
-/**
- * cordis 4 形状的 ctx：只有显式提供的属性可读，其余一律抛错（不是 undefined）。
- * @param {object} provided 已提供的属性（reflect / logger …）
- */
-function proxyCtx(provided) {
-  return new Proxy(provided, {
-    get(target, prop) {
-      if (typeof prop === "symbol" || prop === "then" || String(prop).startsWith("_")) {
-        return target[prop];
-      }
-      if (prop in target) return target[prop];
-      throw new Error(`cannot get property "${String(prop)}" without inject`);
-    }
-  });
-}
-
-/** 带 workspaceRegistry 服务的 reflect（免 inject 读取出口）。 */
-function reflectWith(services, seen = []) {
-  return {
-    get(name) {
-      seen.push(name);
-      return services[name];
-    }
-  };
-}
-
-const EXEC = { agent: { session: { id: "s1", header: { agentPreset: "coder", cwd: "D:\\raw" } } } };
-
-function loggerSpy() {
-  const warnings = [];
-  return { warnings, logger: { warn: (m) => warnings.push(String(m)) } };
-}
-
-test("#487: unregistered ctx property never throws out of the resolver (Proxy shape)", () => {
-  // 没有任何服务：裸读 workspaceRegistry 在真宿主里会抛。解析器必须吞掉并降级。
-  const { warnings, logger } = loggerSpy();
-  const ctx = proxyCtx({ reflect: reflectWith({}), logger });
-  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true }, logger });
-  // 不会抛；agentPreset 照常解析，workspace 落到 header.cwd。
-  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
-  // 服务缺失是合法状态（headless / 旧宿主），不是故障——不许刷 warn。
-  assert.deepEqual(warnings, [], "missing optional service must stay silent");
-});
-
-test("#487: registry reached through reflect.get restores the canonical path", () => {
-  // 修复的收益不只是消 warning：宿主确实提供 workspaceRegistry（@deepseek-ai/
-  // dsh-workspace），走免 inject 读取能取回 realpath 归一后的 canonical path，
-  // 而不是退化成原始 cwd 字符串。
-  const registry = { list: () => [{ path: "C:\\canon", sessionIds: ["s1"] }] };
-  const seen = [];
-  const ctx = proxyCtx({ reflect: reflectWith({ workspaceRegistry: registry }, seen) });
-  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true } });
-
-  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "C:\\canon" });
-  assert.ok(seen.includes("workspaceRegistry"), "registry must be read via reflect.get");
-});
-
-test("#487: membership miss still falls back to header cwd (registry hit is id-scoped)", () => {
-  const registry = { list: () => [{ path: "C:\\canon", sessionIds: ["other"] }] };
-  const ctx = proxyCtx({ reflect: reflectWith({ workspaceRegistry: registry }) });
-  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true } });
-
-  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
-});
-
-test("#487: hosts without ctx.reflect keep working through the plain-object shape", () => {
-  // 旧宿主：ctx 是普通对象、没有 reflect.get。普通对象裸读安全，行为必须和修复前一致。
-  const ctx = { workspaceRegistry: { list: () => [{ path: "C:\\canon", sessionIds: ["s1"] }] } };
-  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true } });
-  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "C:\\canon" });
-});
-
-test("#487: registry explosion still degrades to header cwd and warns exactly once", () => {
-  // 既有语义（scope-storage.test.js 已有同款普通对象版）：服务确实炸了要出声，
-  // 但每次写一个解析器实例只警告一次、绝不影响写入。
-  const { warnings, logger } = loggerSpy();
-  const registry = { list: () => { throw new Error("boom"); } };
-  const ctx = proxyCtx({ reflect: reflectWith({ workspaceRegistry: registry }), logger });
-  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true }, logger });
-
-  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
-  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
-  assert.equal(warnings.length, 1, "warn once per resolver instance, never on every write");
-});
-
-test("#487: resolver never throws even when reflect.get itself explodes", () => {
-  const { logger } = loggerSpy();
-  const ctx = proxyCtx({
-    reflect: { get() { throw new Error("reflect boom"); } },
-    logger
-  });
-  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true }, logger });
-  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
-  // 无会话时照旧全 NULL（fail-closed 读取侧依赖这个契约）。
-  assert.deepEqual(resolve(undefined), { agent_scope: null, workspace_scope: null });
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createScopeResolver } from "../src/scope.js";
+
+// issue #487：workspaceRegistry 不在 inject 声明里（src/index.js:45），而 cordis 4
+// 的 ctx 是 Proxy——裸读未注入属性会抛 "cannot get property ... without inject"，
+// 不返回 undefined。于是 scope.js 曾经那行 `ctx?.workspaceRegistry?.list?.()` 从
+// v0.8.0 起必然抛错走降级：canonical path 归一与成员资格校验静默失效，只剩
+// header.cwd。
+//
+// 为什么既有测试没拦住：scope-storage.test.js 里三处 registry 测试都用普通对象
+// 伪造 ctx（{ workspaceRegistry: {...} }），普通对象裸读不抛错。本文件改用
+// 「读未声明属性即抛」的 Proxy 复刻真实宿主形状，把两侧行为都钉死。
+
+/**
+ * cordis 4 形状的 ctx：只有显式提供的属性可读，其余一律抛错（不是 undefined）。
+ * @param {object} provided 已提供的属性（reflect / logger …）
+ */
+function proxyCtx(provided) {
+  return new Proxy(provided, {
+    get(target, prop) {
+      if (typeof prop === "symbol" || prop === "then" || String(prop).startsWith("_")) {
+        return target[prop];
+      }
+      if (prop in target) return target[prop];
+      throw new Error(`cannot get property "${String(prop)}" without inject`);
+    }
+  });
+}
+
+/** 带 workspaceRegistry 服务的 reflect（免 inject 读取出口）。 */
+function reflectWith(services, seen = []) {
+  return {
+    get(name) {
+      seen.push(name);
+      return services[name];
+    }
+  };
+}
+
+const EXEC = { agent: { session: { id: "s1", header: { agentPreset: "coder", cwd: "D:\\raw" } } } };
+
+function loggerSpy() {
+  const warnings = [];
+  return { warnings, logger: { warn: (m) => warnings.push(String(m)) } };
+}
+
+test("#487: unregistered ctx property never throws out of the resolver (Proxy shape)", () => {
+  // 没有任何服务：裸读 workspaceRegistry 在真宿主里会抛。解析器必须吞掉并降级。
+  const { warnings, logger } = loggerSpy();
+  const ctx = proxyCtx({ reflect: reflectWith({}), logger });
+  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true }, logger });
+  // 不会抛；agentPreset 照常解析，workspace 落到 header.cwd。
+  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
+  // 服务缺失是合法状态（headless / 旧宿主），不是故障——不许刷 warn。
+  assert.deepEqual(warnings, [], "missing optional service must stay silent");
+});
+
+test("#487: registry reached through reflect.get restores the canonical path", () => {
+  // 修复的收益不只是消 warning：宿主确实提供 workspaceRegistry（@deepseek-ai/
+  // dsh-workspace），走免 inject 读取能取回 realpath 归一后的 canonical path，
+  // 而不是退化成原始 cwd 字符串。
+  const registry = { list: () => [{ path: "C:\\canon", sessionIds: ["s1"] }] };
+  const seen = [];
+  const ctx = proxyCtx({ reflect: reflectWith({ workspaceRegistry: registry }, seen) });
+  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true } });
+
+  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "C:\\canon" });
+  assert.ok(seen.includes("workspaceRegistry"), "registry must be read via reflect.get");
+});
+
+test("#487: membership miss still falls back to header cwd (registry hit is id-scoped)", () => {
+  const registry = { list: () => [{ path: "C:\\canon", sessionIds: ["other"] }] };
+  const ctx = proxyCtx({ reflect: reflectWith({ workspaceRegistry: registry }) });
+  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true } });
+
+  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
+});
+
+test("#487: hosts without ctx.reflect keep working through the plain-object shape", () => {
+  // 旧宿主：ctx 是普通对象、没有 reflect.get。普通对象裸读安全，行为必须和修复前一致。
+  const ctx = { workspaceRegistry: { list: () => [{ path: "C:\\canon", sessionIds: ["s1"] }] } };
+  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true } });
+  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "C:\\canon" });
+});
+
+test("#487: registry explosion still degrades to header cwd and warns exactly once", () => {
+  // 既有语义（scope-storage.test.js 已有同款普通对象版）：服务确实炸了要出声，
+  // 但每次写一个解析器实例只警告一次、绝不影响写入。
+  const { warnings, logger } = loggerSpy();
+  const registry = { list: () => { throw new Error("boom"); } };
+  const ctx = proxyCtx({ reflect: reflectWith({ workspaceRegistry: registry }), logger });
+  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true }, logger });
+
+  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
+  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
+  assert.equal(warnings.length, 1, "warn once per resolver instance, never on every write");
+});
+
+test("#487: resolver never throws even when reflect.get itself explodes", () => {
+  const { logger } = loggerSpy();
+  const ctx = proxyCtx({
+    reflect: { get() { throw new Error("reflect boom"); } },
+    logger
+  });
+  const resolve = createScopeResolver({ ctx, config: { scopeEnabled: true }, logger });
+  assert.deepEqual(resolve(EXEC), { agent_scope: "coder", workspace_scope: "D:\\raw" });
+  // 无会话时照旧全 NULL（fail-closed 读取侧依赖这个契约）。
+  assert.deepEqual(resolve(undefined), { agent_scope: null, workspace_scope: null });
+});