@modusensus/dsh-mneme 0.8.6 → 0.8.7

package/test/document-dir.test.js

@@ -0,0 +1,233 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, unlinkSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { createDocumentIndex } from "../src/document-index.js";
+import { isManagedDocumentPath, resolveDocumentDir } from "../src/document.js";
+import { createMirror } from "../src/mirror.js";
+import { createService } from "../src/service.js";
+import { createStore } from "../src/store.js";
+
+// 回归（issue #296 第二批）：document 的落盘目录与归属。
+// ①`documentDir` 默认跟随 memoryDir 的 `<memoryDir>/documents/`，`~` 与相对路径
+//   按 memoryDir 同一套解析；②managed / external 的边界（目录内的文件是机器产物
+//   的一部分，目录外只登记指针行）；③`index.md` 整文件机器所有、可从库重建；
+//   ④镜像侧 documents.md 是只读指针视图（另见 test/mirror-types.test.js）。
+
+function tempDir() {
+  return mkdtempSync(join(tmpdir(), "dsh-mneme-docdir-"));
+}
+
+test("#296: documentDir 默认为 memoryDir 下的 documents，三种路径写法都可解析", () => {
+  const memoryDir = join(tmpdir(), "dsh-mneme-memory");
+  assert.equal(resolveDocumentDir(memoryDir, ""), resolve(memoryDir, "documents"), "空 = 跟随 memoryDir");
+  assert.equal(resolveDocumentDir(memoryDir), resolve(memoryDir, "documents"), "缺省同空串");
+  assert.equal(resolveDocumentDir(memoryDir, "./notes"), resolve(memoryDir, "notes"), "相对路径落在 memoryDir 下");
+  assert.equal(resolveDocumentDir(memoryDir, "docs"), resolve(memoryDir, "docs"));
+  assert.equal(resolveDocumentDir(memoryDir, join(tmpdir(), "elsewhere")), resolve(join(tmpdir(), "elsewhere")), "绝对路径原样用");
+  assert.equal(resolveDocumentDir(memoryDir, "~/docs"), resolve(homedir(), "docs"), "~ 展开到 home");
+});
+
+test("#296: managed 判定只认目录内的路径（前缀相像的不算）", () => {
+  const base = join(tmpdir(), "dsh-mneme-docroot");
+  const dir = join(base, "documents");
+  assert.equal(isManagedDocumentPath(dir, join(dir, "report.md")), true);
+  assert.equal(isManagedDocumentPath(dir, join(dir, "sub", "deep.md")), true, "子目录也算 managed");
+  assert.equal(isManagedDocumentPath(dir, dir), true);
+  assert.equal(isManagedDocumentPath(dir, join(base, "documents-old", "x.md")), false, "前缀相像的兄弟目录不是 managed");
+  assert.equal(isManagedDocumentPath(dir, join(base, "other.md")), false);
+  assert.equal(isManagedDocumentPath(dir, ""), false);
+  assert.equal(isManagedDocumentPath(dir, undefined), false);
+});
+
+test("#296: index.md 只列指针行、可整文件重建、内容不变不落盘", () => {
+  const dir = tempDir();
+  try {
+    const index = createDocumentIndex(join(dir, "documents"));
+    const managed = join(dir, "documents", "report.md");
+    const rows = [
+      { id: "d1", title: "报告", content: "第一句。第二句。", doc_path: managed, updated_at: "2026-02-01T00:00:00.000Z" },
+      { id: "d2", title: "外部文档", content: "正文不必进索引。", doc_path: join(dir, "notes.md"), updated_at: "2026-01-01T00:00:00.000Z" }
+    ];
+    assert.equal(index.sync(rows).changed, true);
+    const first = readFileSync(join(dir, "documents", "index.md"), "utf8");
+    assert.ok(first.includes("整文件机器所有"), "文件头说清归属");
+    assert.equal((first.match(/^- `/gm) ?? []).length, 2, "一行一个 document");
+    assert.ok(first.includes("d1") && first.includes("报告") && first.includes(managed), "带定位");
+    assert.ok(/\bd1\b.*managed/.test(first), "目录内的标 managed");
+    assert.ok(/\bd2\b.*external/.test(first), "目录外的标 external");
+    assert.ok(!first.includes("第一句"), "索引不带摘要正文（那是镜像视图的活）");
+    // 重建：删掉再同步得到逐字节相同的文件（所以文件里不写生成时间）
+    unlinkSync(index.filePath);
+    index.sync(rows);
+    assert.equal(readFileSync(index.filePath, "utf8"), first, "可从库重建，且逐字节一致");
+    // 内容没变就不重写（与镜像同一条「不无谓写盘」纪律）
+    assert.equal(index.sync(rows).changed, false);
+    // 空集也要有一份合法的索引（不是删文件）
+    assert.equal(index.sync([]).changed, true);
+    assert.ok(readFileSync(index.filePath, "utf8").includes("机器所有"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#296: 索引写不进去只报失败，不抛（写失败不能连累业务写）", () => {
+  const dir = tempDir();
+  try {
+    // 让目标目录的「父级」是一个普通文件：mkdir 必失败，且不依赖平台错误码
+    const blocker = join(dir, "blocker");
+    writeFileSync(blocker, "not a directory", "utf8");
+    const index = createDocumentIndex(join(blocker, "documents"));
+    const ensured = index.ensure();
+    assert.equal(ensured.ok, false, "建目录失败要如实返回（调用方据此 warn）");
+    assert.ok(ensured.error, "失败要带原因");
+    const result = index.sync([{ id: "d1", title: "t", content: "c", doc_path: "x", updated_at: "2026-01-01T00:00:00.000Z" }]);
+    assert.equal(result.ok, false, "失败要如实返回，不能假装成功");
+    assert.ok(result.error, "失败要带原因");
+    assert.ok(!existsSync(index.filePath));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#296: index.md 删掉后从库里重建，逐字节一致", () => {
+  const dir = tempDir();
+  let store;
+  try {
+    const documentDir = join(dir, "documents");
+    store = createStore(join(dir, "memory.db"));
+    const index = createDocumentIndex(documentDir);
+    const service = createService({
+      store, mirror: createMirror(dir), config: { documentMemoryEnabled: true }, documentIndex: index
+    });
+    writeFileSync(join(dir, "report.md"), "x", "utf8");
+    const doc = store.saveDocument({
+      type: "document", title: "报告", content: "第一句。第二句。", tags: [], importance: 3,
+      source: "tool", evidence: [], doc_path: join(documentDir, "report.md")
+    });
+    service.saveWithDedupe({ type: "pattern", title: "触发", content: "x" });
+    const first = readFileSync(index.filePath, "utf8");
+    // 真删文件，再从库同步一次：读数必须一样（这才是「可从库重建」，不是拿同一份
+    // 内存数组重算）
+    unlinkSync(index.filePath);
+    assert.ok(!existsSync(index.filePath));
+    service.saveWithDedupe({ type: "pattern", title: "触发2", content: "y" });
+    assert.equal(readFileSync(index.filePath, "utf8"), first, "删掉重建后逐字节一致");
+    assert.ok(first.includes(doc.id) && first.includes("managed"));
+  } finally {
+    store?.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#296: managed 文件走一次完整注册往返，字节哈希不变", async () => {
+  const dir = tempDir();
+  let store;
+  try {
+    const documentDir = join(dir, "documents");
+    mkdirSync(documentDir, { recursive: true });
+    const docFile = join(documentDir, "report.md");
+    writeFileSync(docFile, "# 报告\n\n正文由 agent 写。\n", "utf8");
+    const before = createHash("sha256").update(readFileSync(docFile)).digest("hex");
+    store = createStore(join(dir, "memory.db"));
+    const service = createService({
+      store, mirror: createMirror(dir), config: { documentMemoryEnabled: true },
+      documentIndex: createDocumentIndex(documentDir)
+    });
+    const result = await service.registerDocument({ path: docFile, title: "报告", summary: "第一句。第二句。" });
+    assert.equal(result.action, "created");
+    assert.equal(result.memory.doc_path, resolve(docFile), "指针行落在 managed 路径上");
+    assert.equal(
+      createHash("sha256").update(readFileSync(docFile)).digest("hex"), before,
+      "管线对正文零读零写：注册往返后 managed 文件必须逐字节不变"
+    );
+    // 同时也确认没有偷偷在 documentDir 里生成第二份「正文」（机器产物只有 index.md）
+    assert.deepEqual(readdirSync(documentDir).sort(), ["index.md", "report.md"]);
+  } finally {
+    store?.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#296: 两个落点共用 documentMemoryEnabled 闸，闸关时视图与索引一起清掉", () => {
+  const dir = tempDir();
+  let store;
+  try {
+    const documentDir = join(dir, "documents");
+    store = createStore(join(dir, "memory.db"));
+    const index = createDocumentIndex(documentDir);
+    const on = createService({
+      store, mirror: createMirror(dir), config: { documentMemoryEnabled: true }, documentIndex: index
+    });
+    writeFileSync(join(dir, "outside.md"), "x", "utf8");
+    const kept = store.saveDocument({
+      type: "document", title: "报告", content: "第一句。第二句。", tags: [], importance: 3,
+      source: "tool", evidence: [], doc_path: join(documentDir, "report.md")
+    });
+    store.saveDocument({
+      type: "document", title: "外部", content: "另一份。", tags: [], importance: 3,
+      source: "tool", evidence: [], doc_path: join(dir, "outside.md")
+    });
+    // 任意一次业务写触发写后语（镜像 + 索引一起）
+    on.saveWithDedupe({ type: "pattern", title: "触发", content: "x" });
+    assert.ok(existsSync(join(dir, "documents.md")), "闸开 → 镜像视图落盘");
+    const md = readFileSync(join(dir, "documents.md"), "utf8");
+    assert.ok(md.includes("报告") && md.includes(join(documentDir, "report.md")));
+    assert.ok(existsSync(index.filePath), "闸开 → 索引落盘");
+    assert.ok(readFileSync(index.filePath, "utf8").includes("managed"));
+
+    // 归档一行：索引只列活跃行（与镜像的 coverage: active-only 同口径）
+    store.setArchived(kept.id, true);
+    on.saveWithDedupe({ type: "pattern", title: "触发1b", content: "w" });
+    assert.ok(!readFileSync(index.filePath, "utf8").includes(kept.id), "已归档的行不进索引");
+
+    // 闸关：document 行不再进渲染集 → documents.md 被既有「空 type 删文件」清掉；
+    // index.md 归 syncDocumentIndex 清掉——留一份陈旧索引就是「看着还在、其实已关」
+    // 的视图，正是 documents.md 在闸关时要避免的那一类。
+    const off = createService({ store, mirror: createMirror(dir), config: {}, documentIndex: index });
+    off.saveWithDedupe({ type: "pattern", title: "触发2", content: "y" });
+    assert.ok(!existsSync(join(dir, "documents.md")), "闸关 → 镜像视图清掉");
+    assert.ok(!existsSync(index.filePath), "闸关 → 索引也清掉");
+
+    // 闸重开：下一次业务写从库重建索引（自愈，不需要手工删文件）
+    const back = createService({
+      store, mirror: createMirror(dir), config: { documentMemoryEnabled: true }, documentIndex: index
+    });
+    back.saveWithDedupe({ type: "pattern", title: "触发3", content: "z" });
+    assert.ok(readFileSync(index.filePath, "utf8").includes("外部"), "闸重开 → 索引从库重建");
+  } finally {
+    store?.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#296: 两条新文案的英文分支也要能渲染（en 实例）", () => {
+  const dir = tempDir();
+  try {
+    // 新文案是 per-language 的 lambda：en 分支此前零调用点，缺键或笔误只在
+    // memory.language=en 的实例上炸，而全量测试照样绿（审查指出）。
+    const index = createDocumentIndex(join(dir, "documents"), "en");
+    index.sync([{
+      id: "d1", title: "Report", content: "First sentence. Second.", updated_at: "2026-01-01T00:00:00.000Z",
+      doc_path: join(dir, "documents", "report.md")
+    }]);
+    const indexText = readFileSync(index.filePath, "utf8");
+    assert.match(indexText, /document index — dsh-mneme/, "en 的索引头");
+    assert.match(indexText, /Machine-owned as a whole/, "en 的归属说明");
+
+    const mirror = createMirror(dir, "en");
+    mirror.sync([{
+      id: "doc1", type: "document", title: "Report", content: "First sentence. Second.", tags: [],
+      importance: 3, forgotten: false, created_at: "2026-01-01T00:00:00.000Z",
+      updated_at: "2026-01-01T00:00:00.000Z", doc_path: join(dir, "documents", "report.md")
+    }]);
+    const docs = readFileSync(join(dir, "documents.md"), "utf8");
+    assert.match(docs, /read-only view/, "en 的只读视图文件头");
+    assert.match(docs, /never the full text/, "en 的只读说明");
+    assert.ok(docs.includes("First sentence") && !docs.includes("Second."), "en 下同样只留摘要首句");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/test/document.test.js

@@ -8,7 +8,7 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
+import { createService, PINNED_MEMORY_TYPES } from "../src/service.js";
 import { createDocumentRegistrar } from "../src/document.js";
 import { MEMORY_ITEM_SCHEMA } from "../src/tools.js";
 import { TYPE_DECAY_DEFAULTS } from "../src/heat.js";
@@ -30,7 +30,7 @@ async function makeDocDir() {
 }
 
 /** 单元级 registrar：注入假 embedQuery，隔离 vector 档行为。 */
-function makeRegistrar(store, config = {}, embedQuery = async () => null) {
+function makeRegistrar(store, config = {}, embedQuery = async () => null, { pinnedTypes = PINNED_MEMORY_TYPES } = {}) {
   const finalized = [];
   const register = createDocumentRegistrar({
     store,
@@ -42,7 +42,9 @@ function makeRegistrar(store, config = {}, embedQuery = async () => null) {
       ...(Array.isArray(existing?.content_history) ? existing.content_history : [])
     ].slice(0, 20),
     transaction: (fn) => fn(),
-    finalize: (rows) => finalized.push(...rows)
+    finalize: (rows) => finalized.push(...rows),
+    // #275 拍板 5：service.js 注入的 #249 逐字保真池（这里同款注入，保持行为一致）
+    pinnedTypes
   });
   return { register, finalized };
 }
@@ -147,6 +149,152 @@ test("evidence intersection: valid subset kept, unknown dropped + degraded tag,
   }
 });
 
+// ============================ 升格吸收的 evidence 归档（#275 拍板 5，同事务）
+
+// 拍板原文：registerDocument 成功后同一事务把 absorbed 的 evidence 行翻 archived
+// （可恢复、审计全留），带 opt-out；pinned（constraint / preference）永不自动归档；
+// supersede 的 loser 行同样翻 archived（后者本来就是本模块既有行为，这里一并锁住）。
+
+test("absorbed evidence rows are archived with the document; pinned rows are exempt", async () => {
+  const { store, service, close } = makeService({ documentMemoryEnabled: true });
+  const { writeDoc, cleanup } = await makeDocDir();
+  try {
+    const pinned = service.saveWithDedupe({ type: "constraint", title: "C", content: "边界条件" }).memory;
+    const decision = service.saveWithDedupe({ type: "decision", title: "D", content: "一个决定" }).memory;
+    const p = await writeDoc("absorb.md");
+
+    const res = await service.registerDocument({
+      path: p, title: "Absorb", summary: "summary", evidence: [pinned.id, decision.id]
+    });
+
+    assert.equal(res.evidence_kept, 2, "引用本身照旧全留下：doc 行的 evidence 数组是正向链");
+    assert.equal(res.evidence_archived, 1, "只有非 pinned 的那条被动");
+    const after = service.getById(decision.id);
+    assert.equal(after.archived, true, "被吸收的行退出活跃面（「21 行不是 1 行」）");
+    assert.equal(after.content, "一个决定", "只翻标志位：内容与审计全留（可恢复）");
+    assert.equal(service.getById(pinned.id).archived, false, "#249 的逐字保真池，升格不能绕过");
+    assert.equal(store.list().some((m) => m.id === decision.id), false, "默认面不再列出吸收行");
+  } finally {
+    cleanup();
+    close();
+  }
+});
+
+test("archiveEvidence: false（工具侧 keep_evidence_active）保留吸收行的活跃面", async () => {
+  const { service, close } = makeService({ documentMemoryEnabled: true });
+  const { writeDoc, cleanup } = await makeDocDir();
+  try {
+    const d = service.saveWithDedupe({ type: "decision", title: "D", content: "c" }).memory;
+    const res = await service.registerDocument(
+      { path: await writeDoc("optout.md"), title: "OptOut", summary: "s", evidence: [d.id] },
+      { archiveEvidence: false }
+    );
+    assert.equal(res.evidence_kept, 1);
+    assert.equal(res.evidence_archived, 0, "opt-out 时不归档");
+    assert.equal(service.getById(d.id).archived, false);
+  } finally {
+    cleanup();
+    close();
+  }
+});
+
+test("re-registering a document whose evidence was absorbed keeps the references", async () => {
+  // 这条防的是「补丁把常规路径打坏」：吸收行一旦归档，重注册同一份文档（出新版）
+  // 时同一批 evidence 会全落 dropped，进而撞上捏造判据——最常规的路径反而报错。
+  const { service, close } = makeService({ documentMemoryEnabled: true });
+  const { writeDoc, cleanup } = await makeDocDir();
+  try {
+    const d = service.saveWithDedupe({ type: "decision", title: "D", content: "c" }).memory;
+    const p = await writeDoc("ver.md");
+    const first = await service.registerDocument({ path: p, title: "Ver", summary: "v1", evidence: [d.id] });
+    assert.equal(first.evidence_archived, 1);
+
+    const second = await service.registerDocument({ path: p, title: "Ver", summary: "v2", evidence: [d.id] });
+    assert.equal(second.action, "superseded");
+    assert.deepEqual(second.memory.evidence, [d.id], "吸收行仍为它所属的那份文档背书");
+    assert.equal(second.evidence_kept, 1);
+    assert.equal(second.degraded, false, "不误报成捏造证据");
+    // 认回是窄口径的：已归档行只为**吸收它的那份**文档背书。别的文档（新注册、无
+    // 同名目标）拿它当证据，照旧走既有的捏造判据——不因为这条补丁放宽。
+    const other = await writeDoc("other.md");
+    await assert.rejects(
+      () => service.registerDocument({ path: other, title: "Other", summary: "s", evidence: [d.id] }),
+      /fabricated evidence is rejected/
+    );
+  } finally {
+    cleanup();
+    close();
+  }
+});
+
+test("registrar without the pinned pool wiring archives nothing (fail-safe)", async () => {
+  // 拿不到 pinned 集合就不做这一步：宁可少做，也不能把保真池当普通行收走。
+  const store = createStore(":memory:");
+  const { writeDoc, cleanup } = await makeDocDir();
+  try {
+    const d = store.save({ type: "decision", title: "D", content: "c" });
+    const { register } = makeRegistrar(store, { documentMemoryEnabled: true }, async () => null, { pinnedTypes: null });
+    const res = await register({ path: await writeDoc("noset.md"), title: "NoSet", summary: "s", evidence: [d.id] });
+    assert.equal(res.evidence_archived, 0);
+    assert.equal(store.getById(d.id).archived, false);
+  } finally {
+    cleanup();
+    store.close();
+  }
+});
+
+test("自有生命周期的类型不被吸收：document 行保持活跃，同 path 的 supersede 链不断", async () => {
+  // 回归点（单盲审查 H1）：把另一份 document 行当 evidence 时，若照普通行吸收，它会
+  // 被静默归档——走不到 loser 分支（没有 [superseded by] 指针与 content_history），
+  // 而 supersede 探测只看活跃行，于是重注册同 path 会再铸一行、同一个文件留下两行。
+  const { store, service, close } = makeService({ documentMemoryEnabled: true });
+  const { writeDoc, cleanup } = await makeDocDir();
+  try {
+    const pA = await writeDoc("a.md");
+    const docA = (await service.registerDocument({ path: pA, title: "DocA", summary: "v1" })).memory;
+    const docB = await service.registerDocument({
+      path: await writeDoc("b.md"), title: "DocB", summary: "grounded in A", evidence: [docA.id]
+    });
+    assert.equal(docB.evidence_archived, 0, "document 行不参与吸收");
+    assert.equal(service.getById(docA.id).archived, false, "被引用不改变它的活跃状态");
+
+    const again = await service.registerDocument({ path: pA, title: "DocA", summary: "v2" });
+    assert.equal(again.action, "superseded", "指针行仍能被 supersede 探测看到");
+    assert.equal(again.superseded.id, docA.id);
+    assert.ok(again.superseded.content.includes(again.memory.id), "旧行拿到 [superseded by] 指针");
+    assert.equal(store.all().filter((m) => m.doc_path === pA).length, 2, "同一 path 一行新版 + 一行带指针的旧版，没有多余的第三行");
+  } finally {
+    cleanup();
+    close();
+  }
+});
+
+test("自有生命周期的类型不被吸收：summary（dream 总览）保持活跃，不会被当成不存在重铸", async () => {
+  // 回归点：summary 按 source 身份去重（dream 总览）且按注入档位常驻。被吸收归档后
+  // 去重候选集（store.list 默认排除归档）看不到它 → 下一次做梦会再铸一行同源总览。
+  const { service, close } = makeService({ documentMemoryEnabled: true });
+  const { writeDoc, cleanup } = await makeDocDir();
+  try {
+    const digest = service.saveWithDedupe({
+      type: "summary", title: "当前项目状态", content: "resident digest", source: "dream", importance: 5
+    }).memory;
+    const res = await service.registerDocument({
+      path: await writeDoc("with-digest.md"), title: "DocW", summary: "s", evidence: [digest.id]
+    });
+    assert.equal(res.evidence_archived, 0, "summary 不参与吸收");
+    assert.equal(service.getById(digest.id).archived, false);
+
+    const again = service.saveWithDedupe({
+      type: "summary", title: "当前项目状态", content: "resident digest v2", source: "dream", importance: 5
+    });
+    assert.equal(again.action, "merged", "下一次做梦仍认得出这行，不会铸出第二行同源总览");
+    assert.equal(again.memory.id, digest.id);
+  } finally {
+    cleanup();
+    close();
+  }
+});
+
 // ============================================================ supersede 记账（DoD 2）
 
 test("re-registering the same path supersedes: old row archived + traceable, file untouched", async () => {

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

@@ -0,0 +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 白名单里`);
+  }
+});

package/test/inject-pools.test.js

@@ -12,7 +12,9 @@ import { MEMORY_GUIDE_SECTION } from "../src/guide.js";
 //   总则段（常驻段必须同会话稳定，不逐轮复读）；
 // ②B1 pin 池（pinnedInjectBudget）：约束/偏好不进相关性竞争与跨轮轮换、逐字
 //   保真、排在块内排序之前，且有独立小预算（不占 maxInjectedItems 名额）。
-// 两个键都默认关/零，默认档下注入块与改动前逐字节一致（本文件第一例锁这条）。
+// 本文件给的是裸 config，两个键缺省时都按关/零算：能力说明的解析默认值由 config.js
+// 的 schema 给出（#249 第二批起为开，另见 test/inject-parent-gate.test.js），pin 池
+// 的默认值是 0。
 
 const userMsg = (text) => ({
   type: "user/message",
@@ -122,9 +124,12 @@ test("#249: pinned content does not eat the general block budget", () => {
   assert.ok(body.includes("总览正文必须带出来"), "普通候选照旧拿完整正文：pin 不占共享预算");
 });
 
-test("#249: capability guide is off by default, registered once when on", () => {
+test("#249: capability guide registers exactly once, and stays off when the key is absent", () => {
+  // 这里给的是裸 config（不经 schema 解析），所以「缺键 = 不生效」；生产默认值
+  // 由 config.js 的 schema 给出（#249 第二批起为 true），那条锁在
+  // test/inject-parent-gate.test.js。
   const off = setup({});
-  assert.equal(off.sections.length, 0, "default off → no prompt section registered");
+  assert.equal(off.sections.length, 0, "缺键 → 不注册提示段");
 
   const on = setup({ injectGuidanceEnabled: true });
   assert.equal(on.sections.length, 1, "exactly one guide section");

package/test/llm-audit.test.js

@@ -1,7 +1,13 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
+import { DatabaseSync } from "node:sqlite";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
 import { createStore } from "../src/store.js";
+import * as mneme from "../src/index.js";
 import { createService } from "../src/service.js";
 import { createDreamScheduler } from "../src/dream.js";
 import { createSummarizer } from "../src/summarize.js";
@@ -554,3 +560,39 @@ test("entity extraction writes no audit row when llmAudit.enabled === false", as
   assert.equal(service.listLlmAudits().length, 0, "no audit rows when disabled");
   store.close();
 });
+
+// 启动期保留清理（Bug8）必须与写入侧读**同一份**配置。面板把 llmAudit.enabled 写进
+// kv、经 nestedFlags 合进 cfg，bundle 里可能是关的：清理若读 rawCfg，就会出现「面板
+// 说开 → 各写入点照写，raw 说关 → 不清理」这种无保留期的增长（写入准入 #254 也是读
+// cfg 的写入点之一）。所以这条锁的是「清理跟着装配后的 cfg 走」。
+test("boot retention purge reads the assembled config, not rawCfg", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-audit-retention-"));
+  const dbPath = join(dir, "memory.db");
+
+  const seed = createStore(dbPath);
+  createSettings(seed.db).setFeatureFlags({ "llmAudit.enabled": true });
+  seed.saveLlmAudit({
+    timestamp: new Date(Date.now() - 2 * 86400000).toISOString(),
+    trigger_source: "autoDream",
+    operation_type: "dream_consolidate",
+    model_id: "m",
+    status: "success"
+  });
+  assert.equal(seed.listLlmAudits().length, 1, "先放一行过期审计");
+  seed.close();
+
+  const ctx = new Context();
+  ctx.provide("tools", { register() { return () => {}; } });
+  ctx.provide("commands", { register() { return () => {}; } });
+  ctx.provide("systemPrompt", { context() { return () => {}; } });
+  ctx.provide("agentDefaultModel", { currentSelection() { return { provider: "mock", model: "mock" }; } });
+  ctx.provide("llm", { async *stream() { yield { type: "finish", reason: { kind: "stop" } }; } });
+  ctx.provide("webServer", { register() { return () => {}; } });
+  // bundle 说关、面板说开，保留期 1 天而那行已过期 2 天：只有读装配后的 cfg 才会清掉它
+  await ctx.plugin(mneme, { memoryDir: dir, llmAudit: { enabled: false, retentionDays: 1 } });
+
+  const after = new DatabaseSync(dbPath);
+  const left = after.prepare("SELECT count(*) AS c FROM llm_audit_logs").get().c;
+  after.close();
+  assert.equal(left, 0, "面板开着的审计必须按 cfg 清理，否则审计行只增不减");
+});