@modusensus/dsh-mneme 0.8.13 → 0.8.15

package/test/inject-first-round-bm25.test.js

@@ -1,89 +1,89 @@
-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";
-
-// 回归（issue #198）：注入渲染是同步的（宿主 systemPrompt 不支持异步 text），
-// 查询向量只能异步 prefetch 给下一轮用——首轮 queryVectorCache 必 miss。
-// 此时 injectCandidates 落到静态 priority 排序（summary > preference >
-// importance×quality）：老的高重要性 preference 会占满全部槽位，当前话题的
-// decision/project 进不来（报告者库：427 活跃、29 条 imp=5 preference）。
-// 修复：首轮同步兜底用 BM25 词法召回领位（纯进程内、无需向量）；语义向量
-// 命中时行为不变（向量 > 缓存召回 > BM25 > 静态排序）。
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-// 与查询词法完全不相交的旧高价值 preference（双字组不重叠）
-function seedStalePreferences(service, n = 8) {
-  const ids = [];
-  for (let i = 0; i < n; i++) {
-    ids.push(service.saveWithDedupe({
-      type: "preference",
-      title: `旧偏好条目${i}`,
-      content: `用户喜欢深色界面与紧凑排版，这是第${i}条历史偏好存档`
-    , importance: 5 }).memory.id);
-  }
-  return ids;
-}
-
-test("#198: first round (no vector) leads with BM25 topical hits, not stale preferences", () => {
-  const { service, store } = setup();
-  seedStalePreferences(service, 8);
-  const onTopic = service.saveWithDedupe({
-    type: "decision",
-    title: "夜航限流选型",
-    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
-    importance: 3
-  }).memory;
-
-  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
-  assert.ok(picked.some((m) => m.id === onTopic.id), "on-topic decision must enter the first-round block");
-  assert.equal(picked[0].id, onTopic.id, "BM25 topical hit leads the block");
-  store.close();
-});
-
-test("#198: legacy static order is kept when bm25 is disabled", () => {
-  const { service, store } = setup({ bm25SearchEnabled: false });
-  seedStalePreferences(service, 8);
-  const onTopic = service.saveWithDedupe({
-    type: "decision",
-    title: "夜航限流选型",
-    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
-    importance: 3
-  }).memory;
-
-  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
-  assert.ok(!picked.some((m) => m.id === onTopic.id), "bm25 off -> legacy static order (preferences fill the slots)");
-  store.close();
-});
-
-test("#198: vector hits still outrank BM25 when a queryVector is available", async () => {
-  const { service, store } = setup();
-  seedStalePreferences(service, 3);
-  // 词法与查询不相交、但向量命中的记忆：语义路径必须压过 BM25 词法路径。
-  const vectorHit = service.saveWithDedupe({
-    type: "project",
-    title: "星图渲染重构",
-    content: "星图渲染重构记录：绘制管线迁移与图层合并",
-    importance: 3
-  }).memory;
-  const bm25Hit = service.saveWithDedupe({
-    type: "decision",
-    title: "夜航限流选型",
-    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
-    importance: 3
-  }).memory;
-  const vectorIndex = createVectorIndex({ store });
-  service.setVectorIndex(vectorIndex);
-  vectorIndex.saveEmbedding(vectorHit.id, [1, 0, 0]);
-
-  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3, queryVector: [1, 0, 0] });
-  assert.equal(picked[0].id, vectorHit.id, "vector hit leads; BM25 only fills the gap when no vector");
-  assert.ok(picked.some((m) => m.id === bm25Hit.id), "BM25 hit still present among candidates");
-  store.close();
-});
+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";
+
+// 回归（issue #198）：注入渲染是同步的（宿主 systemPrompt 不支持异步 text），
+// 查询向量只能异步 prefetch 给下一轮用——首轮 queryVectorCache 必 miss。
+// 此时 injectCandidates 落到静态 priority 排序（summary > preference >
+// importance×quality）：老的高重要性 preference 会占满全部槽位，当前话题的
+// decision/project 进不来（报告者库：427 活跃、29 条 imp=5 preference）。
+// 修复：首轮同步兜底用 BM25 词法召回领位（纯进程内、无需向量）；语义向量
+// 命中时行为不变（向量 > 缓存召回 > BM25 > 静态排序）。
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+// 与查询词法完全不相交的旧高价值 preference（双字组不重叠）
+function seedStalePreferences(service, n = 8) {
+  const ids = [];
+  for (let i = 0; i < n; i++) {
+    ids.push(service.saveWithDedupe({
+      type: "preference",
+      title: `旧偏好条目${i}`,
+      content: `用户喜欢深色界面与紧凑排版，这是第${i}条历史偏好存档`
+    , importance: 5 }).memory.id);
+  }
+  return ids;
+}
+
+test("#198: first round (no vector) leads with BM25 topical hits, not stale preferences", () => {
+  const { service, store } = setup();
+  seedStalePreferences(service, 8);
+  const onTopic = service.saveWithDedupe({
+    type: "decision",
+    title: "夜航限流选型",
+    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
+    importance: 3
+  }).memory;
+
+  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
+  assert.ok(picked.some((m) => m.id === onTopic.id), "on-topic decision must enter the first-round block");
+  assert.equal(picked[0].id, onTopic.id, "BM25 topical hit leads the block");
+  store.close();
+});
+
+test("#198: legacy static order is kept when bm25 is disabled", () => {
+  const { service, store } = setup({ bm25SearchEnabled: false });
+  seedStalePreferences(service, 8);
+  const onTopic = service.saveWithDedupe({
+    type: "decision",
+    title: "夜航限流选型",
+    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
+    importance: 3
+  }).memory;
+
+  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
+  assert.ok(!picked.some((m) => m.id === onTopic.id), "bm25 off -> legacy static order (preferences fill the slots)");
+  store.close();
+});
+
+test("#198: vector hits still outrank BM25 when a queryVector is available", async () => {
+  const { service, store } = setup();
+  seedStalePreferences(service, 3);
+  // 词法与查询不相交、但向量命中的记忆：语义路径必须压过 BM25 词法路径。
+  const vectorHit = service.saveWithDedupe({
+    type: "project",
+    title: "星图渲染重构",
+    content: "星图渲染重构记录：绘制管线迁移与图层合并",
+    importance: 3
+  }).memory;
+  const bm25Hit = service.saveWithDedupe({
+    type: "decision",
+    title: "夜航限流选型",
+    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
+    importance: 3
+  }).memory;
+  const vectorIndex = createVectorIndex({ store });
+  service.setVectorIndex(vectorIndex);
+  vectorIndex.saveEmbedding(vectorHit.id, [1, 0, 0]);
+
+  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3, queryVector: [1, 0, 0] });
+  assert.equal(picked[0].id, vectorHit.id, "vector hit leads; BM25 only fills the gap when no vector");
+  assert.ok(picked.some((m) => m.id === bm25Hit.id), "BM25 hit still present among candidates");
+  store.close();
+});

package/test/inject-heat.test.js

@@ -1,61 +1,77 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-// #218 v1：heat 作为注入排序的**同级内乘数**（issue #218 拍板口径）。
-// 规则路 comparator 的层内权重 importance×quality 乘 heat；priority 分层
-// （summary=0 / preference=1 / coding 同级 / 其余 2）与 store 的 order=chrono
-// 分页序不动。heatEnabled=false（默认）时权重恒 1，排序与改动前一致——
-// 本文件的关闭用例与 heat.test.js 的曲线断言共同锁住验收第 1 条。
-
-const HOUR = 3600000;
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-const titles = (candidates) => candidates.map((c) => c.title);
-
-test("heat off（默认）：层内维持 importance 序，与改动前一致", () => {
-  const { store, service } = setup();
-  const cold = service.saveWithDedupe({ type: "decision", title: "冷的高重要性决策", content: "旧", importance: 4 }).memory;
-  service.saveWithDedupe({ type: "decision", title: "新的低重要性决策", content: "新", importance: 3 });
-  service.touchLastAccess(cold.id, new Date(Date.now() - 3000 * HOUR).toISOString());
-  // 新记忆不触达：ref 退 created_at（≈现在），heat≈1，不影响本用例
-  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
-  store.close();
-});
-
-test("heat on：同层内新鲜低重要性记忆越过冷的高重要性记忆", () => {
-  const { store, service } = setup({ heatEnabled: true });
-  const cold = service.saveWithDedupe({ type: "decision", title: "冷的高重要性决策", content: "旧", importance: 4 }).memory;
-  service.saveWithDedupe({ type: "decision", title: "新的低重要性决策", content: "新", importance: 3 });
-  service.touchLastAccess(cold.id, new Date(Date.now() - 3000 * HOUR).toISOString());
-  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  // λ=0.002、3000h → 冷记忆权重 4×e^-6≈0.01，新鲜记忆 3×≈1 → 反超
-  assert.deepEqual(titles(picked), ["新的低重要性决策", "冷的高重要性决策"]);
-  store.close();
-});
-
-test("heat on 且 λ=0（免疫类型）：乘数恒 1，importance 序不受影响", () => {
-  const { store, service } = setup({ heatEnabled: true, heatTypeDecay: { decision: 0 } });
-  const cold = service.saveWithDedupe({ type: "decision", title: "冷的高重要性决策", content: "旧", importance: 4 }).memory;
-  service.saveWithDedupe({ type: "decision", title: "新的低重要性决策", content: "新", importance: 3 });
-  service.touchLastAccess(cold.id, new Date(Date.now() - 3000 * HOUR).toISOString());
-  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
-  store.close();
-});
-
-test("heat 不跨层：再热的 decision 也不越过 summary 层", () => {
-  const { store, service } = setup({ heatEnabled: true });
-  service.saveWithDedupe({ type: "summary", title: "会话总览", content: "总览", importance: 2 });
-  service.saveWithDedupe({ type: "decision", title: "滚烫决策", content: "新", importance: 3 });
-  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  assert.equal(picked[0].type, "summary", "priority 分层不被 heat 打破");
-  store.close();
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// #218 v1：heat 作为注入排序的**同级内乘数**（issue #218 拍板口径）。
+// 规则路 comparator 的层内权重 importance×quality 乘 heat；priority 分层
+// （summary=0 / preference=1 / coding 同级 / 其余 2）与 store 的 order=chrono
+// 分页序不动。
+//
+// issue #218 / E5 效用考卷：heat 乘进注入排序在真实年龄混合下饿死老约束
+// （现行量级 ≡ 拟合参数，importance-only 遵从 +12.7pp），注入侧 heat 拆出
+// 独立开关 injectHeatEnabled（默认关）——默认关档下 heatEnabled=true 的库
+// 注入排序与 heat 关闭逐字节一致（平价锁）；显式开启才恢复旧序。
+// 召回侧时钟（touchLastAccess）与 sleep 降级联判不受本键影响。
+
+const HOUR = 3600000;
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+const titles = (candidates) => candidates.map((c) => c.title);
+
+// 三个用例共用的「冷高重要性 + 新低重要性」库。
+function seedColdAndFresh(service) {
+  const cold = service.saveWithDedupe({ type: "decision", title: "冷的高重要性决策", content: "旧", importance: 4 }).memory;
+  service.saveWithDedupe({ type: "decision", title: "新的低重要性决策", content: "新", importance: 3 });
+  service.touchLastAccess(cold.id, new Date(Date.now() - 3000 * HOUR).toISOString());
+  // 新记忆不触达：ref 退 created_at（≈现在），heat≈1，不影响本用例
+}
+
+test("heat off（默认）：层内维持 importance 序，与改动前一致", () => {
+  const { store, service } = setup();
+  seedColdAndFresh(service);
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
+  store.close();
+});
+
+test("heat on 且 injectHeatEnabled 关（新默认）：注入序与 heat 关闭逐字节一致（E5 平价锁）", () => {
+  const { store, service } = setup({ heatEnabled: true });
+  seedColdAndFresh(service);
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  // E5 效用考卷：heat 乘进注入排序饿死老约束——默认不再乘，冷的高重要性决策
+  // 回到它 importance 应在的位置（与 heat off 用例逐条相同）。
+  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
+  store.close();
+});
+
+test("heat on 且 injectHeatEnabled 开：恢复旧序（老用户回滚口）", () => {
+  const { store, service } = setup({ heatEnabled: true, injectHeatEnabled: true });
+  seedColdAndFresh(service);
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  // λ=0.002、3000h → 冷记忆权重 4×e^-6≈0.01，新鲜记忆 3×≈1 → 反超
+  assert.deepEqual(titles(picked), ["新的低重要性决策", "冷的高重要性决策"]);
+  store.close();
+});
+
+test("heat on 且 injectHeatEnabled 开 且 λ=0（免疫类型）：乘数恒 1，importance 序不受影响", () => {
+  const { store, service } = setup({ heatEnabled: true, injectHeatEnabled: true, heatTypeDecay: { decision: 0 } });
+  seedColdAndFresh(service);
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
+  store.close();
+});
+
+test("heat 不跨层：再热的 decision 也不越过 summary 层（injectHeatEnabled 开）", () => {
+  const { store, service } = setup({ heatEnabled: true, injectHeatEnabled: true });
+  service.saveWithDedupe({ type: "summary", title: "会话总览", content: "总览", importance: 2 });
+  service.saveWithDedupe({ type: "decision", title: "滚烫决策", content: "新", importance: 3 });
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  assert.equal(picked[0].type, "summary", "priority 分层不被 heat 打破");
+  store.close();
+});

package/test/inject-parent-gate.test.js

@@ -1,106 +1,106 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createInjector } from "../src/inject.js";
-import { createSettings, FEATURE_FLAG_SPEC } from "../src/settings.js";
-import { createTools } from "../src/tools.js";
-import { Config, INJECT_CHILD_FLAGS, applyLightModePreset, injectChildEnabled } from "../src/config.js";
-
-// 回归（issue #249 第二批）：注入形态的父／子开关。
-// 父 = autoInject（既有挂载总闸，默认开）；子项按 #249 §10 的判据分档——是否
-// 引入新的注入时机／新表面／额外成本。只修正既有位的能力说明随父生效，本批
-// 默认值由关翻到开（显式产品决定，见 CHANGELOG）；父关 = 子项一律不生效，
-// 但子项的持久值保留（父关是「不生效」，不是「重置用户配置」）。
-//
-// 能力说明有两个落点：系统提示段住在注入器内（父关时注入器根本不挂载，天然
-// 不生效），工具描述住在注入器之外，是父闸唯一会漏的地方——本文件用真实工具
-// 描述钉住它。
-
-const CHILDREN = Object.values(INJECT_CHILD_FLAGS).flat();
-const GUIDE_TOOLS = ["memory_search", "memory_save"];
-
-function injectorSections(config) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  const sections = [];
-  const ctx = {
-    systemPrompt: {
-      context() { return () => {}; },
-      section(def) { sections.push(def); return () => {}; }
-    }
-  };
-  createInjector(ctx, service, createSettings(store.db), config);
-  return sections;
-}
-
-function toolDescriptions(config) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  const registered = [];
-  const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
-  createTools(ctx, service, config, null);
-  return new Map(registered.map((t) => [t.name, t.description]));
-}
-
-test("#249 第二批：解析后的默认配置里能力说明是开的", () => {
-  assert.equal(Config({}).injectGuidanceEnabled, true, "基础档默认开（随父生效）");
-  // 轻量档不因这次翻转多付常驻提示成本：预设把它压回 false。
-  assert.equal(applyLightModePreset({ lightMode: true }).injectGuidanceEnabled, false);
-});
-
-test("#249 第二批：父关时子项在两个落点上都不生效", () => {
-  assert.equal(injectorSections({ autoInject: true, injectGuidanceEnabled: true }).length, 1, "父开 → 注册提示段");
-  assert.equal(injectorSections({ autoInject: false, injectGuidanceEnabled: true }).length, 0, "父关 → 不注册提示段");
-
-  const plain = toolDescriptions({ injectGuidanceEnabled: false });
-  const guided = toolDescriptions({ autoInject: true, injectGuidanceEnabled: true });
-  const gated = toolDescriptions({ autoInject: false, injectGuidanceEnabled: true });
-  for (const name of GUIDE_TOOLS) {
-    assert.notEqual(guided.get(name), plain.get(name), `${name}：子项开 → 描述补了判断指引`);
-    assert.equal(gated.get(name), plain.get(name), `${name}：父关 → 描述逐字节回到未开状态`);
-  }
-});
-
-test("#249 第二批：闸门只认显式关掉的父，子项自己缺省即关", () => {
-  const key = "injectGuidanceEnabled";
-  assert.equal(injectChildEnabled({ [key]: true }, key), true, "父未出现 → 只按子项判");
-  assert.equal(injectChildEnabled({}, key), false, "子项未开");
-  assert.equal(injectChildEnabled({ autoInject: false, [key]: true }, key), false, "父显式关 → 子不生效");
-  assert.equal(injectChildEnabled({ autoInject: false, [key]: false }, key), false);
-});
-
-test("#249 第二批：父关只停用，不改写子项的持久值", () => {
-  const store = createStore(":memory:");
-  const settings = createSettings(store.db);
-  settings.setFeatureFlags({ autoInject: false, injectGuidanceEnabled: true });
-  const stored = settings.getFeatureFlags();
-  assert.equal(stored.autoInject, false);
-  assert.equal(stored.injectGuidanceEnabled, true, "父关不是重置用户配置");
-  assert.equal(injectChildEnabled(stored, "injectGuidanceEnabled"), false, "值留着，当下不生效");
-  settings.setFeatureFlags({ autoInject: true });
-  assert.equal(injectChildEnabled(settings.getFeatureFlags(), "injectGuidanceEnabled"), true, "重开父开关恢复上次选择");
-});
-
-test("#249 第二批：面板的父子关系与后端同源（漏一处就静默消失）", () => {
-  const client = readFileSync(new URL("../lib/client.js", import.meta.url), "utf8");
-  // 渲染点：子项靠 flagRow 展开。只断言「声明与文案出现过」是恒真检查——把
-  // 2236 行改回 g.items.map(boolRow)，子项既不在 group.core 的 items 里、也不经
-  // flagRow 渲染，面板上彻底消失，而字符串断言全绿。这一条才是那道门。
-  assert.ok(/g\.items\.map\(flagRow\)/.test(client), "分组渲染必须走 flagRow，否则子项不渲染");
-  const children = client.match(/const FEATURE_CHILDREN = (\{[^}]*\})/)?.[1] ?? "";
-  assert.ok(children.includes("autoInject"), "面板未声明父开关 autoInject");
-  const core = client.match(/\{ key: "group\.core", items: \[([^\]]*)\]/)?.[1] ?? "";
-  for (const child of CHILDREN) {
-    assert.ok(children.includes(`"${child}"`), `面板 FEATURE_CHILDREN 漏了 ${child}`);
-    assert.ok(!core.includes(`"${child}"`), `${child} 同时在 items 与 FEATURE_CHILDREN 里，会被渲染两次`);
-    // 双语文案：与 test/client.test.js 的路由键同款计数（zh + en 各一份 = 2）。
-    const named = client.split(`"memory.features.${child}"`).length - 1;
-    const hinted = client.split(`"memory.features.${child}.hint"`).length - 1;
-    assert.ok(named >= 2, `${child} 的文案要中英各一份（got ${named}）`);
-    assert.ok(hinted >= 2, `${child} 的提示要中英各一份（got ${hinted}）`);
-    // 白名单：面板给的开关必须真能写进 kv，否则点了只会拿到 400。
-    assert.ok(FEATURE_FLAG_SPEC.booleans.includes(child), `${child} 不在 settings 白名单里`);
-  }
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings, FEATURE_FLAG_SPEC } from "../src/settings.js";
+import { createTools } from "../src/tools.js";
+import { Config, INJECT_CHILD_FLAGS, applyLightModePreset, injectChildEnabled } from "../src/config.js";
+
+// 回归（issue #249 第二批）：注入形态的父／子开关。
+// 父 = autoInject（既有挂载总闸，默认开）；子项按 #249 §10 的判据分档——是否
+// 引入新的注入时机／新表面／额外成本。只修正既有位的能力说明随父生效，本批
+// 默认值由关翻到开（显式产品决定，见 CHANGELOG）；父关 = 子项一律不生效，
+// 但子项的持久值保留（父关是「不生效」，不是「重置用户配置」）。
+//
+// 能力说明有两个落点：系统提示段住在注入器内（父关时注入器根本不挂载，天然
+// 不生效），工具描述住在注入器之外，是父闸唯一会漏的地方——本文件用真实工具
+// 描述钉住它。
+
+const CHILDREN = Object.values(INJECT_CHILD_FLAGS).flat();
+const GUIDE_TOOLS = ["memory_search", "memory_save"];
+
+function injectorSections(config) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  const sections = [];
+  const ctx = {
+    systemPrompt: {
+      context() { return () => {}; },
+      section(def) { sections.push(def); return () => {}; }
+    }
+  };
+  createInjector(ctx, service, createSettings(store.db), config);
+  return sections;
+}
+
+function toolDescriptions(config) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const registered = [];
+  const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
+  createTools(ctx, service, config, null);
+  return new Map(registered.map((t) => [t.name, t.description]));
+}
+
+test("#249 第二批：解析后的默认配置里能力说明是开的", () => {
+  assert.equal(Config({}).injectGuidanceEnabled, true, "基础档默认开（随父生效）");
+  // 轻量档不因这次翻转多付常驻提示成本：预设把它压回 false。
+  assert.equal(applyLightModePreset({ lightMode: true }).injectGuidanceEnabled, false);
+});
+
+test("#249 第二批：父关时子项在两个落点上都不生效", () => {
+  assert.equal(injectorSections({ autoInject: true, injectGuidanceEnabled: true }).length, 1, "父开 → 注册提示段");
+  assert.equal(injectorSections({ autoInject: false, injectGuidanceEnabled: true }).length, 0, "父关 → 不注册提示段");
+
+  const plain = toolDescriptions({ injectGuidanceEnabled: false });
+  const guided = toolDescriptions({ autoInject: true, injectGuidanceEnabled: true });
+  const gated = toolDescriptions({ autoInject: false, injectGuidanceEnabled: true });
+  for (const name of GUIDE_TOOLS) {
+    assert.notEqual(guided.get(name), plain.get(name), `${name}：子项开 → 描述补了判断指引`);
+    assert.equal(gated.get(name), plain.get(name), `${name}：父关 → 描述逐字节回到未开状态`);
+  }
+});
+
+test("#249 第二批：闸门只认显式关掉的父，子项自己缺省即关", () => {
+  const key = "injectGuidanceEnabled";
+  assert.equal(injectChildEnabled({ [key]: true }, key), true, "父未出现 → 只按子项判");
+  assert.equal(injectChildEnabled({}, key), false, "子项未开");
+  assert.equal(injectChildEnabled({ autoInject: false, [key]: true }, key), false, "父显式关 → 子不生效");
+  assert.equal(injectChildEnabled({ autoInject: false, [key]: false }, key), false);
+});
+
+test("#249 第二批：父关只停用，不改写子项的持久值", () => {
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  settings.setFeatureFlags({ autoInject: false, injectGuidanceEnabled: true });
+  const stored = settings.getFeatureFlags();
+  assert.equal(stored.autoInject, false);
+  assert.equal(stored.injectGuidanceEnabled, true, "父关不是重置用户配置");
+  assert.equal(injectChildEnabled(stored, "injectGuidanceEnabled"), false, "值留着，当下不生效");
+  settings.setFeatureFlags({ autoInject: true });
+  assert.equal(injectChildEnabled(settings.getFeatureFlags(), "injectGuidanceEnabled"), true, "重开父开关恢复上次选择");
+});
+
+test("#249 第二批：面板的父子关系与后端同源（漏一处就静默消失）", () => {
+  const client = readFileSync(new URL("../lib/client.js", import.meta.url), "utf8");
+  // 渲染点：子项靠 flagRow 展开。只断言「声明与文案出现过」是恒真检查——把
+  // 2236 行改回 g.items.map(boolRow)，子项既不在 group.core 的 items 里、也不经
+  // flagRow 渲染，面板上彻底消失，而字符串断言全绿。这一条才是那道门。
+  assert.ok(/g\.items\.map\(flagRow\)/.test(client), "分组渲染必须走 flagRow，否则子项不渲染");
+  const children = client.match(/const FEATURE_CHILDREN = (\{[^}]*\})/)?.[1] ?? "";
+  assert.ok(children.includes("autoInject"), "面板未声明父开关 autoInject");
+  const core = client.match(/\{ key: "group\.core", items: \[([^\]]*)\]/)?.[1] ?? "";
+  for (const child of CHILDREN) {
+    assert.ok(children.includes(`"${child}"`), `面板 FEATURE_CHILDREN 漏了 ${child}`);
+    assert.ok(!core.includes(`"${child}"`), `${child} 同时在 items 与 FEATURE_CHILDREN 里，会被渲染两次`);
+    // 双语文案：与 test/client.test.js 的路由键同款计数（zh + en 各一份 = 2）。
+    const named = client.split(`"memory.features.${child}"`).length - 1;
+    const hinted = client.split(`"memory.features.${child}.hint"`).length - 1;
+    assert.ok(named >= 2, `${child} 的文案要中英各一份（got ${named}）`);
+    assert.ok(hinted >= 2, `${child} 的提示要中英各一份（got ${hinted}）`);
+    // 白名单：面板给的开关必须真能写进 kv，否则点了只会拿到 400。
+    assert.ok(FEATURE_FLAG_SPEC.booleans.includes(child), `${child} 不在 settings 白名单里`);
+  }
+});