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

package/test/client.test.js

@@ -82,40 +82,53 @@ test("memory entry registers the host panel seats and keeps the footer fallback"
   );
 });
 
-// chorography（仓库地志）第二个座位（M1）：与记忆面板同一个 panellist inject 块
-// 里注册，成对规则逐字相同——id 与 main 的 key 必须同为 "dsh-mneme-wiki"，否则
-// 宿主点面板行直接抛 "main panel … is not registered"（#562 在记忆座位上实测过
-// 的同一堵墙）。座位无条件注册（P11）：inject 同名二次注册的 cordis 语义没验证
-// 过，不赌；开关关时由内容层渲染空态（路由 409 disabled），生效走重启纪律。
-test("chorography wiki entry registers its own seat pair in the same panellist block", () => {
-  assert.ok(
-    clientSource.includes('id: "dsh-mneme-wiki"'),
-    "the wiki sidebar seat must use its own id"
-  );
+// chorography（仓库地志）第二个座位（M1）。#598 起成对规则拆成两半：
+// main 的 key 仍逐字同为 "dsh-mneme-wiki" 且无条件注册——#562 的墙（布局存着
+// activePanelId 时少注册，宿主 selectPanel 直接抛）；侧栏 glyph 改读 features
+// 按 chorographyEnabled 决定，与 M.O.（v0.9.0）/日记（v0.13）的座位闸同一形态，
+// fail-closed。默认关的功能不该常驻一个点进去只有「未启用」的入口。
+test("chorography wiki main stays unconditional; the sidebar glyph is feature-gated (#598)", () => {
   assert.ok(
     clientSource.includes('key: "dsh-mneme-wiki"'),
-    "the wiki main seat key must match the wiki sidebar id verbatim"
+    "the wiki main seat key must stay verbatim and unconditional (#562)"
   );
   assert.ok(
     clientSource.includes("h(WikiMainPanel, { t })"),
     "the wiki main seat must render WikiMainPanel"
   );
+  assert.ok(
+    clientSource.includes('id: "dsh-mneme-wiki"'),
+    "the wiki sidebar seat keeps its own id (now registered by the gate)"
+  );
+  assert.ok(
+    clientSource.includes('"dsh-mneme: chorography seat gate"'),
+    "the glyph registration must live behind the features gate"
+  );
+  assert.ok(
+    /if \(!\(\(j && j\.effective\) \|\| \{\}\)\.chorographyEnabled\) return;/.test(clientSource),
+    "the gate must fail-closed on the chorographyEnabled flag"
+  );
+  assert.ok(
+    clientSource.includes("chorography seat stays off"),
+    "a failed features fetch must leave the seat off, not guess"
+  );
   assert.ok(
     clientSource.includes('phase: "disabled"'),
-    "with chorographyEnabled off the wiki page must render the disabled empty state (409 from /choro/repos)"
+    "the disabled empty state must survive for layouts that still point at the wiki panel (#562 keeps main alive for exactly this)"
   );
-  // wiki 座位与记忆座位的清理在同一把扫帚下：漏一个就留下一个挂着的 glyph，
-  // 宿主折叠该槽后指向一个死面板。
+  // wiki glyph 的清理随登记进了座位闸（cordis 上下文销毁时一并回收）；
+  // panellist 回调的扫帚只剩记忆对 + wiki 的 main + kb 对。
   assert.ok(
-    /return \(\) => \{\s*disposeGlyph\(\);\s*disposeMain\(\);\s*disposeWikiGlyph\(\);\s*disposeWikiMain\(\);/.test(clientSource),
-    "the panellist cleanup must dispose both seat pairs"
+    /return \(\) => \{\s*disposeGlyph\(\);\s*disposeMain\(\);[\s\S]*?disposeWikiMain\(\);/.test(clientSource),
+    "the panellist cleanup must dispose the memory pair and wiki main, in order"
   );
 });
 
-// 收尾档（P34）：面板的生成触发点只接 T0（秒级同步回执）；T1 是 30–240s 起步的
-// 长任务，不上 HTTP——这条边界同时是安全边界（token-write 只罩秒级写）与体验
-// 边界（面板请求不挂死）。锁三件事：按钮打到 /choro/run、rebuilding 态防连点、
-// t1Loss/指引文案存在（spec §3「现在生成」的落点 + M2 补洞的警告透出）。
+// 收尾档（P34）留下的边界：面板的「重建」触发点只接 T0（秒级同步回执）。
+// T1 后来按契约 §3.5 单开了自己的路由（/choro/t1 + 轮询），所以这里的
+// 「不上 HTTP」只对重建按钮成立，不再是整个面板的规矩——重建仍然是同步回执，
+// 锁三件事：按钮打到 /choro/run、rebuilding 态防连点、t1Loss/指引文案存在
+// （spec §3「现在生成」的落点 + M2 补洞的警告透出）。
 test("chorography wiki page exposes the rebuild action against /choro/run", () => {
   assert.ok(
     clientSource.includes('"/api/dsh-mneme/choro/run"'),
@@ -135,6 +148,265 @@ test("chorography wiki page exposes the rebuild action against /choro/run", () =
   );
 });
 
+// issue #607 正面修复：空态（phase === "no-repo"）以前只有一句「去跑 CLI」的
+// 纯文字，一个可点的东西都没有，而那句命令在 PATH 里根本不存在。回归表现：
+//  · 空态退回纯文字 → 用户第一次进这块只能自己去翻文档；
+//  · 命令示例写回裸 CLI 名 → 抄进终端就是 "command not found"；
+//  · 文案出现「cd 进目录」→ 命令收的是路径参数，cd 进去反而找不着仓库。
+test("#607: the no-repo empty state offers a clickable path-to-generate entry", () => {
+  assert.ok(
+    clientSource.includes("mneme-wikirunrow"),
+    "the no-repo empty state must render an input+button row, not a bare paragraph"
+  );
+  assert.ok(
+    clientSource.includes('t("wiki.empty.generate")'),
+    "the empty state must carry its own generate button label"
+  );
+  assert.ok(
+    clientSource.includes('t("wiki.empty.pathPlaceholder")'),
+    "the empty state must ask for the repository's absolute path (the CLI takes a path argument)"
+  );
+  // 命令要给绝对路径：dsh-mneme-choro 不在 PATH 里，裸名抄进终端必然找不到。
+  // 值里含转义引号（路径要用引号包住），所以逐字取到未转义的那个收尾引号。
+  const cmds = [...clientSource.matchAll(/"wiki\.empty\.cliCmd":\s*"((?:[^"\\]|\\.)+)"/g)].map((m) => m[1]);
+  assert.equal(cmds.length, 2, "wiki.empty.cliCmd must exist in both dictionaries");
+  for (const cmd of cmds) {
+    assert.ok(
+      cmd.includes("node ") && cmd.includes("dsh-mneme-choro.mjs"),
+      "the CLI example must be a node call on the bin script, got: " + cmd
+    );
+    assert.ok(cmd.includes("--apply"), "the example must carry --apply, otherwise it only previews");
+  }
+  // 收的是路径参数，不能教用户 cd 进目录：cd 进去再传 "." 又会因为命令不在
+  // PATH 里失败，这是 #607 报告里最常被踩的一步。判据落在两处：旧的「在仓库
+  // 目录里跑」这句必须消失；剩下的提及只允许是「不必先 cd」这种反例澄清。
+  const noRepos = [...clientSource.matchAll(/"wiki\.empty\.noRepo":\s*"((?:[^"\\]|\\.)+)"/g)].map((m) => m[1]);
+  assert.equal(noRepos.length, 2, "wiki.empty.noRepo must exist in both dictionaries");
+  for (const copy of noRepos) {
+    assert.equal(
+      /在仓库目录里跑|inside the repository|run this inside/i.test(copy),
+      false,
+      "the copy must not tell the user to run the command from inside the repository, got: " + copy
+    );
+    // #607 的三件事缺一不可：是什么、在哪里开、命令要给绝对路径。
+    assert.ok(copy.includes("mneme"), "the copy must say which plugin this belongs to");
+  }
+  const hints = [...clientSource.matchAll(/"wiki\.empty\.cliHint":\s*"((?:[^"\\]|\\.)+)"/g)].map((m) => m[1]);
+  assert.equal(hints.length, 2, "wiki.empty.cliHint must exist in both dictionaries");
+  for (const hint of hints) {
+    assert.ok(
+      /不必先 cd|no need to cd/i.test(hint),
+      "a mention of cd must be the explicit disclaimer, got: " + hint
+    );
+  }
+  assert.ok(
+    clientSource.includes('t("wiki.run.notGit")'),
+    "a not-git rejection must be translated into an explanation, not echoed as a bare code"
+  );
+});
+
+// 空态那条 POST 要带 path 字段（契约 §3.2）：老实现只认 repo，新实现认 path，
+// 两个都带上才能同时跑在两版后端上。回归表现：只发 repo → 第一次进来自报家门
+// 的目录永远登记不上。
+test("#607: generating from the empty state posts the absolute path to /choro/run", () => {
+  const fn = sliceComponent("WikiMainPanel");
+  assert.ok(/body = \{ path: p \}/.test(fn), "the run body must carry the path field");
+  assert.ok(fn.includes("body.repo = "), "the run body must still carry repo when one is already loaded");
+  assert.ok(fn.includes('"/api/dsh-mneme/choro/run"'), "both entry points share the token-write route");
+});
+
+// 失败也要能读懂（#607 的另一半：原文案把错误码直接糊在屏幕上）。
+// 后端把 wiki 层的 err.code "not-git" 翻成了对外契约的 "not-a-git-repo"，两个码
+// 都要认——只认一个就会出现「同一个失败，换个后端版本就只剩错误码」的半修状态。
+test("#607: run failures explain themselves instead of echoing a bare error code", () => {
+  const fn = sliceComponent("WikiMainPanel");
+  assert.ok(fn.includes('data.error === "not-git"'), "the wiki-layer code must still be understood");
+  assert.ok(fn.includes('data.error === "not-a-git-repo"'), "the public API code is the one the server actually sends");
+  assert.ok(fn.includes('t("wiki.run.notGit")'), "not-git must resolve to an explanation, not a code");
+  assert.ok(fn.includes('t("wiki.run.notAbsolute")'), "a relative path must say it has to be absolute");
+  assert.ok(fn.includes('t("wiki.run.notFound")'), "a missing directory must say so");
+
+  // 解释本身要讲清「为什么」：非 git 没有可比基线，且不含「cd 进目录」这类误导。
+  const notGit = clientSource.match(/"wiki\.run\.notGit":\s*"((?:[^"\\]|\\.)+)"/g) || [];
+  assert.equal(notGit.length, 2, "wiki.run.notGit must exist in zh and en");
+  for (const line of notGit) {
+    assert.ok(/git/.test(line), "the not-git copy must mention git");
+    assert.ok(/基线|baseline/.test(line), "the not-git copy must explain the missing baseline, i.e. why it is refused");
+  }
+});
+
+// 契约 §3.5-2：面板顶栏两枚子开关 + T1 长任务。
+//  · T1 是 30–240s 起步的长任务，POST 只负责起跑，进度必须靠轮询；
+//  · 轮询依赖取 jobId 而不是整个 t1 对象，否则每拍 setState 都把定时器拆了重建；
+//  · stale 的仓库要在行内标出来，否则用户以为页面和代码同步。
+test("choro page wires the two feature toggles, the T1 job and the stale marker", () => {
+  const fn = sliceComponent("WikiMainPanel");
+  assert.ok(fn.includes('toggleFlag("chorographyAutoRefresh")'), "the auto-refresh toggle must ride on chorographyAutoRefresh");
+  // 两枚都是「面板就地能改」的开关，不是只读回显：点一下要把同一个键 PUT 回 /features。
+  assert.ok(fn.includes('toggleFlag("chorographyT1FromPanel")'), "the T1 permission is its own toggle, not a read-only echo");
+  assert.ok(fn.includes('"/api/dsh-mneme/features"'), "toggling must write back through /features, not a local-only flag");
+  assert.ok(fn.includes('"/api/dsh-mneme/choro/t1"'), "the T1 button must POST /choro/t1");
+  assert.ok(fn.includes("/api/dsh-mneme/choro/t1/status?jobId="), "T1 progress must be polled from /choro/t1/status");
+  assert.ok(fn.includes("setInterval(tick, 2000)"), "the poll interval is 2s per contract §3.5");
+  assert.ok(fn.includes("clearInterval"), "the poller must be torn down when the job ends or the panel unmounts");
+  assert.ok(
+    fn.includes("mneme-badge--pending") && fn.includes('t("wiki.stale")'),
+    'stale repos need an inline "code changed" badge'
+  );
+});
+
+// 证据复核（Grounded Claims）：用 git diff 判「哪条结论被改动碰到了」。
+// 这条锁的是三件在屏幕上看不见但一错就骗人的事：
+//  · 三种结局（干净 / 基线找不到 / 比对失败）必须走三条分支，不能并成一句；
+//  · 四种命中原因各自有文案，尤其 touched 与 shifted 不许混成一个「失效」；
+//  · 「没算」不许长得像「没事」——#607 的病根就是把没做成说成做成了。
+test("claim evidence check reports three distinct outcomes instead of one reassuring blob", () => {
+  const fn = sliceComponent("WikiMainPanel");
+  assert.ok(fn.includes("/api/dsh-mneme/choro/claims?repo="), "the check must read the /choro/claims route");
+  // 手动触发，不进 useEffect：每次切页都跑 git diff 会把浏览拖慢，而且这个面板
+  // 第一次就自动跑的话，「没点过」和「点过没事」在屏幕上就长一个样了。
+  assert.ok(
+    !/useEffect\(\(\) => \{[^}]*checkDrift/.test(fn),
+    "the check must not run automatically on mount — an unasked check cannot be told apart from an unrun one"
+  );
+  for (const key of ["wiki.drift.clean", "wiki.drift.anchorStale", "wiki.drift.blocked", "wiki.drift.summary"]) {
+    assert.ok(fn.includes(`t("${key}")`), `each outcome needs its own sentence, missing ${key}`);
+  }
+  for (const key of ["wiki.drift.touched", "wiki.drift.shifted", "wiki.drift.deleted", "wiki.drift.unverifiable"]) {
+    assert.ok(fn.includes(`t("${key}")`), `each hit reason needs its own sentence, missing ${key}`);
+  }
+  // touched 与 shifted 分家：混成「失效」会让只是行号挪了的结论也被喊去重写。
+  assert.ok(
+    fn.includes('c.reason === "touched"') && fn.includes('c.reason === "shifted"'),
+    "touched and shifted must stay two verdicts"
+  );
+  // 正文有语义段、库里零条结论（T1 落盘非原子留下的残局）要单独说出来，
+  // 否则这页会永远显示成干净。
+  assert.ok(fn.includes('t("wiki.drift.inconsistent")'), "a page with prose but no claims must say so");
+  // 每页的条数挂在树里，用户不用先点开才知道哪页被改动碰到。
+  assert.ok(fn.includes("mneme-wikidriftn"), "the tree must carry a per-page count badge");
+
+  // 文案本身也要能区分「没算」与「没事」：干净那句必须提到 HEAD/基线，
+  // 失败那句必须提到失败——两者措辞相同就等于没区分。
+  const clean = [...clientSource.matchAll(/"wiki\.drift\.clean":\s*"((?:[^"\\]|\\.)+)"/g)].map((m) => m[1]);
+  const blocked = [...clientSource.matchAll(/"wiki\.drift\.blocked":\s*"((?:[^"\\]|\\.)+)"/g)].map((m) => m[1]);
+  assert.equal(clean.length, 2, "wiki.drift.clean must exist in both dictionaries");
+  assert.equal(blocked.length, 2, "wiki.drift.blocked must exist in both dictionaries");
+  for (const line of clean) {
+    assert.ok(/HEAD|基线|baseline/.test(line), "the clean copy must say what it compared against");
+  }
+  for (const line of blocked) {
+    assert.ok(/失败|failed/i.test(line), "the blocked copy must admit the comparison did not happen");
+  }
+  assert.notEqual(clean[0], blocked[0], "the two outcomes must not share copy");
+});
+
+// 自动刷新被主动跳过（仓库里有富化页）。这条锁的是「拒绝不许长得像失败」：
+// 服务端已经把 autoRefreshSkipped 与 autoRefreshError 分成两个字段，面板必须
+// 跟着分——合成一句「刷新失败」就是在报一个没发生过的故障，而真正的后果
+// （语义段还在、快照还是旧的）反而没人说。
+test("auto-refresh skip is shown as a standing reason, not as a failure toast", () => {
+  const fn = sliceComponent("WikiMainPanel");
+  assert.ok(fn.includes("autoRefreshSkipped"), "the panel must read the skip signal");
+  assert.ok(fn.includes("autoRefreshNote"), "the skip reason needs a visible home");
+  assert.ok(
+    !/autoRefreshError[^\n]*autoRefreshSkipped|autoRefreshSkipped[^\n]*autoRefreshError/.test(fn),
+    "skipped and error must not be merged into one branch"
+  );
+  // 提示条不能只在 toast 里：toast 2.5 秒就没了，而「为什么没刷」是一个
+  // 仍然成立的状态（库里还有富化页），用户回头还要能看到。
+  assert.ok(fn.includes("mneme-wikidriftbar") && fn.includes("state.autoRefreshNote"),
+    "the skip note must render as a bar, not a self-clearing toast");
+  const zh = [...clientSource.matchAll(/"wiki\.autoRefresh\.skipped":\s*"((?:[^"\\]|\\.)+)"/g)].map((m) => m[1]);
+  const en = zh.length;
+  assert.equal(en, 2, "wiki.autoRefresh.skipped must exist in both dictionaries");
+  assert.ok(/没.*做|没有做/.test(zh[0]), "the Chinese copy must say it did not happen");
+  assert.ok(!/失败/.test(zh[0]), "the skip copy must not claim a failure");
+  assert.ok(/skipped/i.test(zh[1]), "the English copy must say skipped");
+});
+
+// 知识库页（契约 §3.6）。这条锁的是「路由与就近文案都在」，不是布局：
+//  · 409/503 各有自己的空态，不把裸状态码丢屏幕上；
+//  · disabled 那句必须说清去哪儿开（#607 的教训：只说「未启用」等于没说）；
+//  · 地志页导入要拼绝对路径，根路径只从 /choro/repos 取，拿不到就停手。
+test("knowledge base page exposes the §3.6 routes and explains every empty state", () => {
+  const fn = sliceComponent("KbMainPanel");
+  for (const route of [
+    '"/api/dsh-mneme/kb/collections',
+    '"/api/dsh-mneme/kb/docs?collection=',
+    '"/api/dsh-mneme/kb/ingest"',
+    '"/api/dsh-mneme/kb/search"'
+  ]) {
+    assert.ok(fn.includes(route), "the knowledge base page must call " + route);
+  }
+  assert.ok(fn.includes('t("kb.empty.disabled")'), "409 must render the disabled explanation");
+  assert.ok(fn.includes('t("kb.empty.unavailable")'), "503 must render the unavailable explanation");
+  assert.ok(fn.includes('t("kb.empty.collections")'), "an empty collection list must explain what to do next");
+  assert.ok(fn.includes('t("kb.repo.noPath")'), "a missing rootPath must stop before composing a guaranteed 404");
+  // 后端 /choro/modules 曾只回 snake_case 的 page_rel_path，面板读 mod.relPath 恒 undefined，
+  // 于是「选完模块点导入」永远弹「请先选模块」——把后端缺陷说成用户没点（#607 同型）。
+  // 现在后端补了 relPath，缺字段时也必须落到独立的解释上，不许复用 pickFirst。
+  assert.ok(fn.includes('t("kb.repo.noRelPath")'), "a module without relPath needs its own explanation");
+  assert.ok(
+    !/if \(!relPath\) \{ patch\(\{ toast: t\("kb\.repo\.pickFirst"\) \}\); return; \}/.test(fn),
+    "a missing relPath must not be reported as 'pick a module first'"
+  );
+  assert.ok(fn.includes("kb/collections?key="), "deleting a collection addresses it by key");
+
+  // 文案本身锁一次：说清这是 mneme 的功能、开关在哪儿。
+  assert.ok(
+    clientSource.includes("设置 → 记忆(mneme) → 功能 → 知识库"),
+    "the Chinese disabled copy must name the exact toggle path"
+  );
+  assert.ok(
+    clientSource.includes("Settings → Memory (mneme) → Features → Knowledge base"),
+    "the English disabled copy must name the same path"
+  );
+});
+
+// 仓库卡片 + 一键整理（#607 反馈：希望「在这里选择整理知识」，照 Qoder Repo Wiki 那样）。
+// 这条锁四件事，都是「假成功」的高发点：
+//  · /choro/repos 的 409/503 不能并进「还没有仓库」，否则地志没开被说成用户没生成；
+//  · 批量整理的失败必须逐条留名（toast 2.5 秒就没了，名字一多读不完）；
+//  · 只有 relPath 存在的模块才去灌（没骨架页硬灌 = 一串 file-not-found）；
+//  · 手动入库降级为可折叠的高级入口，卡片才是首屏路径。
+test("knowledge base organises a whole repo from cards and never fakes a clean result", () => {
+  const fn = sliceComponent("KbMainPanel");
+  assert.ok(fn.includes('"/api/dsh-mneme/choro/repos"'), "the cards read the repo list (the only route with rootPath)");
+  assert.ok(fn.includes('"/api/dsh-mneme/choro/modules?repo="'), "organising needs each repo's page relative paths");
+  // 409/503 必须各走各的 reposPhase，不许落进空列表。
+  assert.ok(/status === 409[^}]*reposPhase: "disabled"/.test(fn), "409 must set reposPhase=disabled, not an empty list");
+  assert.ok(/status === 503[^}]*reposPhase: "unavailable"/.test(fn), "503 must set reposPhase=unavailable, not an empty list");
+  assert.ok(fn.includes('t("kb.repos.empty")'), "a genuinely empty repo list gets its own copy");
+  // 三档回执：新增 / 未变 / 失败，合并成一句「整理完成」就是假回声。
+  assert.ok(fn.includes('t("kb.repos.new")') && fn.includes('t("kb.repos.same")') && fn.includes('t("kb.repos.failedN")'),
+    "the batch receipt must report added, unchanged and failed separately");
+  assert.ok(fn.includes("organizeErrors"), "failed pages must stay on the page, not only in a 2.5s toast");
+  // 只灌有 relPath 的页。
+  assert.ok(/\.filter\(\(m\) => m\.relPath\)/.test(fn), "only modules with a relPath may be ingested");
+  // 高级入口：手动表单常驻，但折叠在按钮后面。
+  assert.ok(fn.includes("mneme-kbadvtoggle") && fn.includes('t("kb.advanced")'),
+    "manual ingest stays available behind one explicit toggle");
+  // 卡片上的「已整理 N/M」按当前集合的 relKey 前缀数，不额外打请求。
+  assert.ok(fn.includes("organizedCount") && fn.includes("state.docs"), "the organised count reads the loaded docs, not a new request");
+});
+
+// 知识库是第三个座位：id 与 main 的 key 必须逐字同名，否则宿主 selectPanel
+// 直接抛 "main panel ... is not registered"（#562 在记忆座位上踩过）。
+test("knowledge base entry registers its own seat pair in the same panellist block", () => {
+  assert.ok(clientSource.includes('id: "dsh-mneme-kb"'), "the kb sidebar seat must use its own id");
+  assert.ok(clientSource.includes('key: "dsh-mneme-kb"'), "the kb main seat key must match the sidebar id verbatim");
+  assert.ok(clientSource.includes("h(KbMainPanel, { t })"), "the kb main seat must render KbMainPanel");
+  assert.ok(
+    clientSource.includes("h(KbGlyph, { size: props && props.size })"),
+    "the kb glyph takes its size from the host"
+  );
+  assert.ok(
+    /return \(\) => \{\s*disposeGlyph\(\);\s*disposeMain\(\);[\s\S]*?disposeWikiMain\(\);\s*disposeKbGlyph\(\);\s*disposeKbMain\(\);/.test(clientSource),
+    "the panellist cleanup must dispose the remaining seat pairs (the wiki glyph moved to the feature gate)"
+  );
+});
+
 // v0.11.1 美化：文件清单的竖线等宽行换成真 table（用户实测反馈「文件名排列
 // 太难看」）。锁渲染器三件事：真 <table>、分隔行（--- | ---:）按对齐元数据消费
 // 而不是画成可见行、数字列右对齐。回归表现：改回竖线等宽行画法 → 红在缺 table。
@@ -189,8 +461,10 @@ test("panel seats: the fallback mounts and unmounts with the host's declaration"
   // spec 存在时点火：一把全点会把新座位的注册塞进老宿主，测出来的就不是真行为。
   const fire = (ctx, key) => ctx.injected.filter((i) => i.key === key).map((i) => i.cb());
 
-  // 新宿主：panellist 已声明。panellist + main 各两份（记忆 + chorography 两个
-  // 座位，M1），每对各自 id/key 逐字同名；footer 回落不装。
+  // 新宿主：panellist 已声明。panellist + main 各三份（记忆 + chorography +
+  // 知识库三个座位），每对各自 id/key 逐字同名；footer 回落不装。
+  // 日记本原有第四对座位，2026-11-09 按桉桉要求撤掉——它现在是记忆面板内的
+  // 一个标签页，与人格页并列，不再占侧边栏；人格页同理（面板内标签页，不是座位）。
   {
     const { ctx, regs } = makeCtx((key) => (key === "sidebar.panellist" ? { kind: "list" } : undefined));
     const api = boot(ctx, (k) => k, () => null);
@@ -199,10 +473,10 @@ test("panel seats: the fallback mounts and unmounts with the host's declaration"
     fire(ctx, "sidebar.footer.action");
     assert.equal(disposes.length, 1);
     const ids = (name) => regs.filter((r) => r.alive && r.opts.name === name).map((r) => r.opts.id ?? r.opts.key).sort();
-    assert.equal(alive(regs, "sidebar.panellist"), 2, "memory + wiki glyphs");
-    assert.deepEqual(ids("sidebar.panellist"), ["dsh-mneme", "dsh-mneme-wiki"], "每对座位各自 id 逐字唯一");
-    assert.equal(alive(regs, "main"), 2, "memory + wiki pages");
-    assert.deepEqual(ids("main"), ["dsh-mneme", "dsh-mneme-wiki"], "main key 与侧栏 id 逐字同名");
+    assert.equal(alive(regs, "sidebar.panellist"), 2, "memory + kb glyphs — the wiki glyph is feature-gated (#598), not unconditional");
+    assert.deepEqual(ids("sidebar.panellist"), ["dsh-mneme", "dsh-mneme-kb"], "每对座位各自 id 逐字唯一；wiki glyph 走座位闸，不在无条件集合里");
+    assert.equal(alive(regs, "main"), 3, "memory + wiki + kb pages — wiki main stays unconditional (#562)");
+    assert.deepEqual(ids("main"), ["dsh-mneme", "dsh-mneme-kb", "dsh-mneme-wiki"], "main key 与侧栏 id 逐字同名（wiki 的 main 无条件保留，#562）");
     assert.equal(alive(regs, "sidebar.footer.action"), 0, "the footer fallback must not mount on a host that has the seat");
   }
 
@@ -336,6 +610,33 @@ test("memory library opens as a centered sheet with backdrop", () => {
   );
 });
 
+// #597：分类栏与页头的数字源必须来自服务端（typeCounts / total）——浏览页被
+// type 筛过又分了页，页内现数两头都数不出真分布：选中一类后其它类计数为 0 被
+// filter 整条滤掉（分类栏塌剩两枚），页头停在已加载行数（滚动一次后恒 200）。
+// 降级路径必须同时在：老服务端没有 typeCounts 时退回页内现数，功能不炸。
+test("explorer counts read the server distribution with an in-page fallback (#597)", () => {
+  assert.ok(
+    clientSource.includes("setTypeCounts(d.typeCounts || null)"),
+    "the browse fetch must capture the server distribution"
+  );
+  assert.ok(
+    clientSource.includes("for (const k of EXPLORER_TYPES) counts[k] = typeCounts[k] || 0"),
+    "the type rail must read the server distribution (missing types are 0, never collapse)"
+  );
+  assert.ok(
+    clientSource.includes("for (const m of items) counts[m.type] = (counts[m.type] || 0) + 1"),
+    "the in-page fallback must stay for servers without typeCounts"
+  );
+  assert.ok(
+    clientSource.includes("String(allCount)"),
+    "the all chip must use the distribution sum, not the loaded page length"
+  );
+  assert.ok(
+    /String\(remoteItems \? visible\.length : total\)/.test(clientSource),
+    "the header count must use the server total in browse mode (not visible.length)"
+  );
+});
+
 // The sidebar hands each entry only its column state: a wide row (icon +
 // label) when expanded, a bare rail icon when collapsed — for both the
 // portalled top button and the footer fallback.
@@ -989,8 +1290,8 @@ test("consolidation chart: own 56-day window, null-vs-empty split, and a narrow-
     "two columns must collapse to one in a narrow container"
   );
   // 两根柱的语义色必须走语义层，不能直接拿宿主 label token 当填充色（#178）。
-  assert.ok(clientSource.includes(".mneme-sinkbar--added{background:var(--mneme-chart-3)}"));
-  assert.ok(clientSource.includes(".mneme-sinkbar--merged{background:var(--mneme-chart-2)}"));
+  assert.ok(clientSource.includes(".mneme-sinkbar--added{background:var(--mneme-sink-added)}"));
+  assert.ok(clientSource.includes(".mneme-sinkbar--merged{background:var(--mneme-sink-merged)}"));
 });
 
 // 巩固/睡眠模型路由 UI：下拉数据来自宿主侧已注册适配器（/llm-providers，
@@ -1304,18 +1605,57 @@ test("scope isolation ships panel switches and provenance surfaces (A4)", () =>
 // 默认值），面板自判、不加后端字段；④分组与折叠键中英成对。验收口径：首屏
 // 可点项 = 3 总开关 + autoInject 的 2 个子开关 + scope 2 开关 + 「全部设置」
 // 按钮 = 8（≤ 8），由 ①② 的组成正则共同钉死，不另数 DOM。
-// v0.9.0 复验修订：首屏加 group.mo（M.O. 独立组），可点项预算 8→9。这不是
-// 悄悄放宽——是产品主人点名「别藏在里面」：M.O. 独立成组却仍折在「全部
-// 设置」后等于换个地方继续藏。≤8 原为 #427 自设软预算，owner 豁免一项。
+// v0.9.0 复验修订：首屏加 group.mo（M.O. 独立组），可点项预算 8→9——产品
+// 主人点名「别藏在里面」，M.O. 独立成组却仍折在「全部设置」后等于换个地方
+// 继续藏。**v0.13.x 反转**：主人决定把 M.O. 下架，那一组连同首屏位一起摘掉，
+// 预算回到 8，本锁随之收紧回两组。反转是产品决策、不是放宽，注释留档防下次
+// 有人照着旧注释把组加回来。
+// **v0.13.x 第二次产品豁免（#607 后续）**：首屏加 group.ext（仓库地志 / 知识库 /
+// 日记本三个扩展子系统的总闸），可点项预算 8→11（3 总开关 + autoInject 2 子 +
+// 扩展 3 闸 + scope 2 + 「全部设置」按钮）。理由：这三个子系统此前分别散在
+// enhance 组尾（choro/diary）或压根没进 FEATURE_GROUPS（kb），用户「开了才
+// 找得到、找不到就没法开」——#607 报的「知识库没成型」一半是入口问题。它们
+// 是「装不装这个子系统」而非「每轮付多少」，与 enhance 的行为开关不同级，
+// 所以单列一组并提到首屏。**再往首屏塞东西前先问：它是不是同级子系统？**
 test("settings card folds everything beyond the first screen behind All settings (issue #427)", () => {
-  // ① 首屏层组成：三组都要在（basic 总开关 / mo 座位闸门 / scope 必答题），
+  // ① 首屏层组成：三组都要在（basic 总开关 / ext 子系统总闸 / scope 必答题），
   // 且 basic 的成员是从 core/dream 移走的。
-  assert.ok(/const FEATURE_FIRST_SCREEN = \["group\.basic", "group\.mo", "group\.scope"\];/.test(clientSource),
-    "the first screen must be exactly the basic, mo and scope groups");
+  assert.ok(/const FEATURE_FIRST_SCREEN = \["group\.basic", "group\.ext", "group\.scope"\];/.test(clientSource),
+    "the first screen must be the basic, ext and scope groups (M.O. taken down in v0.13.x; ext added as the second product exemption)");
+  // M.O. 下架锁：组从 FEATURE_GROUPS 摘掉 ≠ 只把首屏位去掉。少了这一条，下次
+  // 有人「顺手把组加回来」时会折进「全部设置」，测试照绿而 M.O. 又出现在面板上。
+  assert.ok(!/\{ key: "group\.mo", items: \[/.test(clientSource),
+    "M.O. must stay off the panel: group.mo is deliberately absent from FEATURE_GROUPS (taken down in v0.13.x)");
+  // 但键本身不能删——config schema / settings 白名单里还在，恢复时零改动。
+  assert.ok(clientSource.includes("actionPipelineEnabled"),
+    "the M.O. flags must remain reachable (config + settings whitelist) so the takedown stays reversible");
   assert.ok(/key: "group\.basic", items: \["autoInject", "autoSummarize", "autoDream"\]/.test(clientSource),
     "group.basic must carry exactly the three master switches");
-  assert.ok(!/key: "group\.core", items: \["autoInject/.test(clientSource) && !/key: "group\.dream", items: \["autoDream/.test(clientSource),
-    "basic members must be MOVED out of their old groups (render-once), not filtered at render time");
+  // 扩展组必须同时收三个子系统的总闸，且一个都不能漏：漏掉哪个，那个子系统就
+  // 退回 #607 的状态——后端接好了、面板上没有入口，用户只能靠改配置文件打开。
+  assert.ok(/key: "group\.ext", items: \["chorographyEnabled", "kbEnabled", "diaryEnabled"\]/.test(clientSource),
+    "group.ext must carry the three subsystem master switches (chorography / kb / diary)");
+  // 迁移锁：choro/diary 从 enhance 组移出（render-once，同一项只渲染一次）。
+  // 只把首屏位加上而不移成员，会让两个开关同时出现在两组里，状态还可能不同步。
+  // #427 revamp（2026-11-11）：group.enhance 进一步拆成 safety/pipeline/retrieve/
+  // persona——它曾是设置页「难找难看」的重灾区（14 个异质开关混装），拆完不许
+  // 有人顺手把旧组名加回来。
+  assert.ok(!/group\.enhance", items: \[/.test(clientSource),
+    "group.enhance must stay split into safety/pipeline/retrieve/persona (the revamp's core move)");
+  assert.ok(!/group\.core", items: \[/.test(clientSource),
+    "group.core must stay split too (its audit/defense rows moved to group.safety)");
+  for (const moved of ["chorographyEnabled", "diaryEnabled"]) {
+    const extItems = clientSource.match(/key: "group\.ext", items: \[([^\]]*)\]/)?.[1] ?? "";
+    assert.ok(extItems.includes(`"${moved}"`), `${moved} must stay in group.ext`);
+    const occurrencesInGroups = [...clientSource.matchAll(/items: \[([^\]]*)\]/g)]
+      .filter((m) => m[1].includes(`"${moved}"`)).length;
+    assert.equal(occurrencesInGroups, 1, `${moved} must render exactly once across all groups (render-once)`);
+  }
+  // 四个新组都在：少了哪个，那批开关就退回「没座位」状态。
+  for (const groupKey of ["group.safety", "group.pipeline", "group.retrieve", "group.persona"]) {
+    assert.ok(clientSource.includes(`key: "${groupKey}", items: [`),
+      `${groupKey} must exist in FEATURE_GROUPS (the revamp's regrouping)`);
+  }
   // ② 两层折叠的接线：restGroups 只在 showAll 展开后渲染；「高级」按钮出现在
   // 「全部设置」之后（同一渲染分支内），showAdv 展开的条目走第二层。
   assert.ok(/showAll && h\(react\.Fragment, null,\s*restGroups\.map\(renderGroup\)/.test(clientSource),
@@ -1323,16 +1663,24 @@ test("settings card folds everything beyond the first screen behind All settings
   const allBtn = clientSource.indexOf('t("memory.features.allToggle")');
   const advBtn = clientSource.indexOf('t("memory.features.advancedToggle")');
   assert.ok(allBtn >= 0 && advBtn > allBtn, "the advanced fold must be nested after All settings");
-  assert.equal(clientSource.match(/const FEATURE_ADVANCED_BOOLS = \[([^\]]*)\];/)[1].split(",").filter((s) => s.trim()).length, 7,
-    "the advanced second tier must hold exactly the 7 rarer switches the label promises");
+  assert.equal(clientSource.match(/const FEATURE_ADVANCED_BOOLS = \[([^\]]*)\];/)[1].split(",").filter((s) => s.trim()).length, 9,
+    "the advanced second tier must hold exactly the 9 rarer switches the label promises (entityRecall + graphAnchoring joined in the revamp)");
   // ③ 徽标：两类各一套中英文案；判定读 overrides 本地判，不引入后端字段。
-  for (const key of ["memory.features.tagDefault", "memory.features.tagChanged",
+  // #427 revamp：tagDefault 的徽标不再渲染（默认态由开关位置本身表达），i18n
+  // 键随之下线——这里锁的是「不再渲染」这件事本身，防止有人把灰字墙加回来。
+  for (const key of ["memory.features.tagChanged", "memory.features.tagPending",
     "memory.features.group.basic", "memory.features.allToggle", "memory.features.advancedToggle"]) {
     const occurrences = clientSource.split("\"" + key + "\"").length - 1;
     assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
   }
   assert.ok(clientSource.includes("Object.prototype.hasOwnProperty.call(ovr, k)"),
-    "the default/changed badge must be decided from overrides, not a new backend field");
+    "the changed badge must be decided from overrides, not a new backend field");
+  // 「默认」徽标的下线锁：flagTag 对默认态必须 return null（CSS 类本身保留——
+  // 事实卡的 actor 徽标还用它），禁的是功能开关行再挂灰字墙。
+  assert.ok(/if \(!Object\.prototype\.hasOwnProperty\.call\(ovr, k\)\) return null;/.test(clientSource),
+    "flagTag must return null on default rows (no more always-grey 「默认」 chips)");
+  assert.ok(!clientSource.includes("memory.features.tagDefault"),
+    "the tagDefault copy must stay deleted along with its render site");
 });
 
 // #481：面板开关「改了不生效」的体验坑。开关在宿主启动时合并进冻结 cfg，
@@ -1394,11 +1742,30 @@ test("conflict queue ships a central review surface on the status tab", () => {
     assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
   }
   assert.ok(/function ConflictsQueue\(\{ t \}\)/.test(clientSource), "ConflictsQueue component must exist");
-  assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts"'), "queue must fetch the conflicts endpoint");
+  assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts?limit=200"'), "queue must fetch the conflicts endpoint");
   assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts/resolve"'), "queue must call the resolve endpoint");
   assert.ok(clientSource.includes("h(ConflictsQueue, { t })"), "status tab must render the queue");
 });
 
+// Issue #603 第 3 层：服务端一直返回 { items, total }，面板此前既不带 limit 也不读
+// total——列 50 条而徽章 60，第 51–60 条翻不到、也没有任何提示。这条锁三件事：
+// 请求要取满服务端上限、total 要存下来、被截断时要说出来。
+test("#603 conflict queue: the panel asks for the server cap and admits truncation", () => {
+  assert.ok(clientSource.includes('"/api/dsh-mneme/conflicts?limit=200"'),
+    "the queue must request the server's 200-row cap, not the 50-row default");
+  assert.ok(clientSource.includes("setTotal(typeof d.total === \"number\" ? d.total : null)"),
+    "the response total must be kept (it was dropped before)");
+  assert.ok(clientSource.includes("memory.status.conflictQueue.truncated"),
+    "a truncated list must say so");
+  for (const key of ["memory.status.conflictQueue.truncated"]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  // 差额才提示：总数等于行数时不该多出一行噪声。
+  assert.ok(clientSource.includes("total > shown ? total - shown : 0"),
+    "the notice must only appear when rows are actually hidden");
+});
+
 // --- issue #178 批次一：无障碍（aria-live 网络 / 语义标题 / 焦点管理 / 图摘要） ---
 
 // 面板瞬时反馈（保存/裁决/刷新/复制）不能只靠纯视觉 span：announce() 单例
@@ -1446,10 +1813,12 @@ test("a11y: entity graph svg exposes a count summary", () => {
 
 // --- issue #177：冲突队列交互与视觉重做 ---
 
-// 相似度进度条：只从「相似度 X / similarity X」锚定短语回收数字（防把年份当
-// 相似度），A/B 卡片带侧色类，冻结徽章替代预裁决阶段的「已归档」徽章。
+// 相似度进度条：优先取服务端落列的 similarity（#603 第 2 层），老行才回落到
+// 「相似度 X / similarity X」锚定短语（防把年份当相似度）；A/B 卡片带侧色类，
+// 冻结徽章替代预裁决阶段的「已归档」徽章。
 test("conflict queue: similarity bar, side colors and frozen badge", () => {
-  assert.ok(clientSource.includes("similarityOf(it.reason)"), "reason must be parsed for similarity");
+  assert.ok(clientSource.includes("similarityOf(it)"), "the whole item must be parsed, not just reason");
+  assert.ok(clientSource.includes("typeof it.similarity === \"number\""), "the server-side column wins over text parsing");
   assert.ok(clientSource.includes("/(?:相似度|similarity)\\s*([01](?:\\.\\d+)?)/i"), "parse must anchor on the similarity phrase");
   for (const key of ["memory.status.conflictQueue.similarity", "memory.status.conflictQueue.frozenBadge"]) {
     const occurrences = clientSource.split(`"${key}"`).length - 1;
@@ -1650,6 +2019,43 @@ test("mirror health: card wired with fail-closed unknown rendering", () => {
   }
 });
 
+// --- issue #275：库体积卡（容量预警，空间维度）---
+// 预警卡的关健不变量同样是 fail-closed：fetch 失败、老宿主没有 capacity 块、后端
+// status:"unknown" 三种情况都渲染「未知」，绝不显示「正常」；过线的检查逐条列出
+// 且值/阈值都给全（报警要能对上数字）。这里锁死派生表达式与 i18n 双语键，
+// 防止未来被「简化」成把未知当正常、或把过线行折成一句空话。
+test("capacity warning: card wired with fail-closed unknown rendering", () => {
+  assert.ok(clientSource.includes("function CapacityCard"), "库体积卡必须存在");
+  assert.ok(clientSource.includes("h(CapacityCard, { t })"), "overview grid must render the capacity card");
+  // 与镜像卡同一条 /health 路径读 capacity 块（「加一个库体积卡是同一条路径」）
+  const fetches = clientSource.split('"/api/dsh-mneme/health"').length - 1;
+  assert.ok(fetches >= 2, "capacity card must fetch the health endpoint (mirror card + capacity card)");
+  const unknown = clientSource.match(/const unknown = !c \|\| c\.status === "unknown";/);
+  assert.ok(unknown, "missing block / backend unknown must collapse to unknown, never ok");
+  // 过线行必须带 warn 标记走预警色，大数字同样（class 由 StatusCard 拼接）
+  assert.ok(clientSource.includes('"mneme-statrow mneme-statrow--warn"'), "tripped check rows must carry the warn class");
+  assert.ok(clientSource.includes('"mneme-statusnum mneme-statusnum--warn"'), "warned big number must carry the warn class");
+  // 三种检查的标签显式映射（不按键名拼 i18n key，缺键时会把键名漏给用户）
+  assert.ok(clientSource.includes('"memory.status.capacity.check.dbSize"'));
+  assert.ok(clientSource.includes('"memory.status.capacity.check.archivedRows"'));
+  assert.ok(clientSource.includes('"memory.status.capacity.check.archivedRatio"'));
+  for (const key of [
+    "memory.status.capacity",
+    "memory.status.capacity.unknown",
+    "memory.status.capacity.unknownFoot",
+    "memory.status.capacity.active",
+    "memory.status.capacity.archived",
+    "memory.status.capacity.reclaimable",
+    "memory.status.capacity.check.dbSize",
+    "memory.status.capacity.check.archivedRows",
+    "memory.status.capacity.check.archivedRatio",
+    "memory.status.capacity.foot"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+});
+
 // --- issue #386 第 1 条：独立服务只读卡片 ---
 // 卡片展示 dsh-mneme-serve 示例命令并支持复制。关键锁：命令不能写成
 // `npx dsh-mneme-serve …` —— bin 名与包名不同，裸 npx 会尝试安装一个不存在
@@ -2017,17 +2423,24 @@ test("client bundle parses: 面板产物必须是合法 JS（无重复声明等
 test("distill retention switches are reachable from the panel (#399)", () => {
   // 认「组里有没有」不要用 `"key"]` 这种子串——`eff["distillRecords.enabled"]`
   // 也长这样，把组里那一项删掉它照样命中（变异验证实测：删项后仍全绿）。
-  // 必须把 core 组的 items 数组抠出来单独看。
-  const coreGroup = clientSource.match(/key: "group\.core", items: \[([\s\S]*?)\]/);
-  assert.ok(coreGroup, "the core group must be declared");
+  // 必须把所属组的 items 数组抠出来单独看。#427 revamp 后归属 pipeline 组。
+  const pipelineGroup = clientSource.match(/key: "group\.pipeline", items: \[([\s\S]*?)\]/);
+  assert.ok(pipelineGroup, "the pipeline group must be declared");
   assert.ok(
-    coreGroup[1].includes('"distillRecords.enabled"'),
-    "distillRecords.enabled must be an item of the core group, not merely referenced elsewhere"
+    pipelineGroup[1].includes('"distillRecords.enabled"'),
+    "distillRecords.enabled must be an item of the pipeline group, not merely referenced elsewhere"
   );
-  assert.ok(
-    /const FEATURE_NUMBERS = \["distillRecords\.retentionDays", "dreamMaxTokens", "sleepMaxTokens"\]/.test(clientSource),
-    "retentionDays must be in the numeric key list (dreamMaxTokens/sleepMaxTokens joined by #478)"
+  // 数值清单会随新键增长（v0.13 加了 diaryWriteEveryMinutes），所以钉「这三个都在、
+  // 且顺序不变」，不钉整行字面量——否则每加一个数值键这条锁就假红一次。
+  const numList = clientSource.match(/const FEATURE_NUMBERS = \[([\s\S]*?)\];/);
+  assert.ok(numList, "the numeric key list must be declared");
+  const numKeys = (numList[1].match(/"[^"]+"/g) || []).map((k) => k.slice(1, -1));
+  assert.deepEqual(
+    numKeys.slice(0, 3),
+    ["distillRecords.retentionDays", "dreamMaxTokens", "sleepMaxTokens"],
+    "retentionDays must stay in the numeric key list, after dreamMaxTokens/sleepMaxTokens (#478)"
   );
+  assert.ok(numKeys.includes("distillRecords.retentionDays"), "retentionDays must be in the numeric key list");
   assert.ok(
     /for \(const key of FEATURE_NUMBERS\) numDraft\[key\] = String\(e\[key\] \?\? ""\);/.test(clientSource)
       && /setNums\(numDraft\);/.test(clientSource),
@@ -2037,15 +2450,19 @@ test("distill retention switches are reachable from the panel (#399)", () => {
     /const distillSub = eff\["distillRecords\.enabled"\] && h\("div", \{ className: "mneme-featsub" \},\s*\n\s*numRow\("distillRecords\.retentionDays"\)/.test(clientSource),
     "the retention-days row must be gated on the parent switch and live in its sub-block"
   );
-  // 定义了不等于接线了：把 distillSub 从组尾子块里摘掉，上面每条断言照样全绿
-  // （变异验证实测：摘掉后仍全绿）。子块是在 items.map 之后按组尾追加的，所以必须确认
-  // 它真的出现在那一个渲染点上。
-  const coreTail = clientSource.match(/g\.key === "group\.core" && h\(react\.Fragment, null, ([^)]*)\)/);
-  assert.ok(coreTail, "the core group must append its sub-blocks at the group tail");
+  // 定义了不等于接线了：把 distillSub 从 subAfter 里摘掉，上面每条断言照样全绿
+  // （变异验证实测：摘掉后仍全绿）。#427 revamp 后子块一律走 subAfter 紧贴自己的
+  // 总闸（core 组已拆、组尾挂法退役），所以锁的是 subAfter 这条接线本身。
+  const subAfterMap = clientSource.match(/const subAfter = \{([^}]*)\}/);
+  assert.ok(subAfterMap, "the subAfter map must exist (sub-blocks ride next to their master switches)");
   assert.ok(
-    /\bdistillSub\b/.test(coreTail[1]),
-    "distillSub must be rendered at the core group tail, not merely declared above"
+    /\bdistillSub\b/.test(subAfterMap[1]) && subAfterMap[1].includes('"distillRecords.enabled"'),
+    "distillSub must be wired to distillRecords.enabled via subAfter, not merely declared above"
   );
+  for (const wired of ["entitySub", "summarizeSub", "choroSub", "diarySub"]) {
+    assert.ok(new RegExp(`\\b${wired}\\b`).test(subAfterMap[1]),
+      `${wired} must ride next to its master switch via subAfter (detached sub-blocks are the old mess)`);
+  }
   assert.ok(
     /if \(!\/\^\\d\+\$\/\.test\(raw\)\) \{\s*\n\s*setNums\(\(c\) => \(\{ \.\.\.c, \[key\]: String\(eff\[key\] \?\? ""\) \}\)\);\s*\n\s*return;\s*\n\s*\}/.test(clientSource),
     "a non-integer draft must be rejected locally and reverted to the effective value"
@@ -2231,6 +2648,217 @@ test("right-pane tab renders a named component instead of a bare hook callback",
 // 「仓库里还没有工作流」与「一条运行记录都没有」是两句不同的话，都得中英齐全——
 // i18n 掉一边，界面上就是一行 key 裸奔。作用域那三句尤其不能缺：清单行上「项目」
 // 与「全局」是唯一的来源提示，缺了它，人分不清手里这条是本项目的还是跟着插件来的。
+// 日记本（v0.13）的四条形状锁。为什么值得单独立锁而不是靠上面的通用闸门：
+// ① 它的旗标闸必须**独立**——M.O. 那条 effect 读的是 actionPipelineEnabled，
+//    把日记塞进同一个 then 里，关掉 M.O. 会连带关掉日记，而两者毫无关系；
+// ② 右栏正文同样必须是具名组件（同 PipelinePane 的理由，hook 顺序只在运行时炸）；
+// ③ 「写成 / 今天写过 / 没素材」是三种不同结果，混成一句「成功」就是假成功；
+// ④ 503（没装配）与 409（没开）是两种不同的「不能用」，合并文案用户会以为日记坏了。
+test("diary pane: own gate, named component, and distinct outcomes", () => {
+  assert.match(clientSource, /function DiaryPane\(/, "DiaryPane must exist");
+  // 回调必须把「这个会话是谁」一路传进正文：project 定位素材、agent 定位人格卡。
+  // 少传 agent 就会退回 default 卡——自动轮是带 agentId 的，两个入口写同一天
+  // 会变成两个声音，这正是「只以这个人格的口吻写日记」没做到的那一半。
+  assert.match(
+    clientSource,
+    /\}, \(props\) => \{[\s\S]{0,400}?return h\(DiaryPane, \{[\s\S]{0,200}?project: sessionProject\(ctx, sid\),[\s\S]{0,200}?agent: sessionAgent\(ctx, sid\),[\s\S]{0,200}?session: sid \|\| null[\s\S]{0,40}?\}\);\s*\}\);/,
+    "the diary tab callback must delegate to the named DiaryPane component and pass agent + session"
+  );
+  assert.match(clientSource, /function sessionAgent\(ctx, sessionId\)/, "sessionAgent must exist to resolve the persona card");
+
+  // 从日记那段注释起算、到自己的 effect 名止：不能退 1600 字符去数，
+  // 那会把上面 M.O. 那段（它本来就写着 actionPipelineEnabled）一起框进来。
+  const gateHead = clientSource.indexOf("// --- v0.13 日记本（beta）：独立旗标门控 ---");
+  const gateAt = clientSource.indexOf('"dsh-mneme: diary gate"');
+  assert.ok(gateHead > -1, "the diary gate comment must exist");
+  assert.ok(gateAt > gateHead, "the diary must carry its own flag gate, after that comment");
+  // 只审代码、不审注释：那段注释本身就在解释「为什么不复用 M.O. 那条」，
+  // 会把 actionPipelineEnabled 这个字放进来说明——按注释判会把这个正确的说明当成违规。
+  const gateBody = clientSource
+    .slice(gateHead, gateAt)
+    .split("\n")
+    .filter((line) => !line.trim().startsWith("//"))
+    .join("\n");
+  assert.ok(gateBody.includes("eff.diaryEnabled"), "the diary gate must read its own flag");
+  assert.ok(
+    !gateBody.includes("actionPipelineEnabled"),
+    "the diary gate must not ride on actionPipelineEnabled — the two features are unrelated"
+  );
+
+  // 三种结果必须各有自己的分支，不能都落进同一句「成功」
+  for (const marker of ['b.status === "written"', '"already-written"', '"no-material"']) {
+    assert.ok(clientSource.includes(marker), "diary write outcome must be handled explicitly: " + marker);
+  }
+  // 503 与 409 分开成两种 gate 文案
+  assert.ok(
+    clientSource.includes("r.status === 503") && clientSource.includes("r.status === 409"),
+    "diary unavailable (503) and disabled (409) must be told apart"
+  );
+});
+
+// 日记本重做（2026-11-09，桉桉：「像本子一样的UI风格」/「导航应该是人格名」）。
+// 两件事都必须由测试锁住，因为它们都只错在「看起来还行」：
+// ①导航拿 frontmatter 括号里的 agent 名当人格名——本机旧数据里五个桶都写着
+//   `default (ptc)`，于是导航栏出现一排项目键加一个 ptc。正确名字只能从人格卡取。
+// ②纸张只存内存或只存一处，两个入口各选各的，同一本日记看起来像两个东西。
+test("diary book: navigation names come from persona cards, never from the agent tag", () => {
+  const start = clientSource.indexOf("function diaryBucketName(");
+  assert.ok(start > -1, "diaryBucketName must exist");
+  const end = clientSource.indexOf("function DiaryLibraryPanel(");
+  assert.ok(end > start, "diaryBucketName must sit before the panel");
+  // 注释里本来就要出现 `persona: default (ptc)` 这个反例，只审代码行。
+  const body = clientSource.slice(start, end).split("\n")
+    .filter((line) => !line.trim().startsWith("//")).join("\n");
+  const fn = new Function(body + "\n return diaryBucketName;")();
+  const store = {
+    default: { name: "Amarre" },
+    byAgent: { ptc: null, studio: { name: "Studio" } },
+    bySession: {}
+  };
+  // 括号里是 agent 名：必须换成人格卡的名字，不是 agent 名，也不是桶键。
+  assert.equal(fn({ key: "amarre-c836db6a", project: "amarre-c836db6a", persona: "default (ptc)" }, store), "Amarre",
+    "an agent tag must resolve to the default card's name, not to 'ptc'");
+  assert.equal(fn({ key: "x-1", project: "x-1", persona: "settings (studio)" }, store), "Studio",
+    "a named card must win over the default card");
+  // 还没挂卡（或卡被删了）时走默认卡，这是写日记时真实的回落口径。
+  assert.equal(fn({ key: "y-2", project: "y-2", persona: "settings (gone)" }, store), "Amarre",
+    "a missing agent card falls back to the default card, the same way writing does");
+  // 没有 store（人格卡还没读到）时绝不把 agent 名顶上，退回项目名。
+  assert.equal(fn({ key: "z-3", project: "z-3", persona: "default (ptc)" }, null), "z-3",
+    "without a card store the name must fall back to the project, never leak the agent tag");
+  // 完全没有 persona 行的老日记：项目名，再不行桶键。
+  assert.equal(fn({ key: "old-4", project: "老项目", persona: "" }, store), "老项目");
+  assert.equal(fn({ key: "only-5", project: "", persona: "" }, store), "only-5");
+});
+
+test("diary book: paper choice is one shared setting across both entries", () => {
+  // 一个 localStorage 键、一处读、一处写：两个入口看的是同一本日记。
+  assert.ok(clientSource.includes('const DIARY_BOOK_KEY = "dsh-mneme-diary-book"'),
+    "the paper choice needs a single storage key");
+  assert.equal((clientSource.match(/localStorage\.getItem\(DIARY_BOOK_KEY\)/g) || []).length, 1,
+    "reading the paper must go through readDiaryBook only");
+  assert.ok(clientSource.includes("function readDiaryBook()") && clientSource.includes("function writeDiaryBook("),
+    "read and write helpers must both exist");
+  // 右栏 DiaryPane 也要套同一套纸：只改左面板等于两处观感打架。
+  const pane = clientSource.slice(clientSource.indexOf("function DiaryPane("), clientSource.indexOf("function DiaryLibraryPanel("));
+  assert.ok(pane.includes("readDiaryBook"), "the right-side pane must read the same paper choice");
+  assert.ok(/mneme-diary-paper mneme-diary-paper--" \+ book/.test(pane),
+    "the right-side pane must apply the selected paper texture");
+  // 同页另一处入口收不到 storage 事件（那只在别的标签页触发），必须自己广播。
+  assert.ok(clientSource.includes('new CustomEvent("mneme:diary-book-changed")'),
+    "a same-page change must be broadcast, storage events never fire in the same document");
+  assert.ok(clientSource.includes('addEventListener("mneme:diary-book-changed"'),
+    "the other entry must listen for that broadcast");
+  // 三种纸都要有文案，否则按钮上是裸 key（牛皮已删：它只是同一层上色的换色相，
+  // 与素纸差 1.01:1，且是这块唯一硬编码 hex）。
+  for (const key of ["memory.diary.bookLabel", "memory.diary.book.plain", "memory.diary.book.ruled",
+    "memory.diary.book.grid"]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  // 本子观感：正文用衬线、行高与纸纹 26px 网格对齐，否则横线会穿字。
+  // 源文件里这段 CSS 在 JS 字符串内，引号是转义的；这里只钉字体族的骨架。
+  assert.ok(clientSource.includes("font-family:Georgia,") && clientSource.includes("Songti SC") &&
+    clientSource.includes("Noto Serif SC") && clientSource.includes("serif"),
+    "the diary body needs a serif typeface to read like a notebook");
+  assert.ok(clientSource.includes("background-size:100% 26px"),
+    "the ruled texture must be locked to the 26px line height");
+});
+
+// 2026-11-11 查出来的真 bug：四条纸面风格（--ruled/--grid/--kraft/--plain）与基础规则
+// `.mneme-diary-paper` 同为 (0,1,0)、基础规则在数组里更靠后、且用 background 简写——
+// 前四条设的 background-image/color 被整条重置，四种纸实测全是 background-image:none，
+// 所以「几种风格毫无变化」不是没做完。修法两层：纹理挪到 .mneme-diary-text（后代选择器，
+// 结构上不再和基础规则抢同一个元素），基础规则只用 background-color。
+test("diary paper: 纹理挂在正文元素上，基础规则不许退回 background 简写", () => {
+  const at = clientSource.indexOf('".mneme-diary-paper{');
+  assert.ok(at > -1, "the base paper rule must exist");
+  const rule = clientSource.slice(at + 1, clientSource.indexOf('",', at));
+  assert.ok(rule.includes("background-color:"),
+    "the base rule must paint its tint with background-color");
+  assert.ok(!/(^|;|\s)background:/.test(rule),
+    "the base rule must not use the background shorthand — it resets every texture above it");
+  for (const key of ["--ruled", "--grid"]) {
+    assert.ok(clientSource.includes(".mneme-diary-paper" + key + " .mneme-diary-text{"),
+      "the " + key + " texture must hang off .mneme-diary-text, not off the base class");
+  }
+  assert.ok(clientSource.includes("--mneme-rule:"),
+    "the rule colour needs its own token (border-l1 is 1.09:1 on paper — invisible)");
+  assert.ok(!clientSource.includes("memory.diary.book.kraft"),
+    "kraft was removed; it only differed from plain by hue (1.01:1) and carried the block's only hardcoded hex");
+});
+
+// 走查发现：savedAt 只写不清 —— 保存成功后再改字段仍显示「已保存」，先成功后失败会
+// 「已保存」+「保存失败」两行并存。三处清零缺一处就会复现，所以按处数锁。
+test("persona save: 改任何字段都把「已保存」收回去（假成功回归锁）", () => {
+  const zeros = (clientSource.match(/setSavedAt\(0\)/g) || []).length;
+  assert.ok(zeros >= 3, "save 开头 / setField / toggleEnabled 三处都要清零（现有 " + zeros + " 处）");
+  assert.ok(clientSource.includes("setSavedAt(Date.now())"), "the success path still stamps the time");
+});
+
+// 窄侧栏（约 400px）下日记与人格原来是横向分栏：正文纸被挤到 250px、人格编辑区
+// 只剩 180px；六个页签还会各自折成两行。这两条都在 480 档容器查询里修，锁住防回退。
+test("窄容器：日记与人格上下堆叠，页签不折行", () => {
+  const at = clientSource.indexOf('"@container (max-width: 480px){');
+  assert.ok(at > -1, "the 480 container query must exist");
+  const block = clientSource.slice(at, clientSource.indexOf('"', at + 2));
+  assert.ok(block.includes(".mneme-diary-body{flex-direction:column}"),
+    "the diary list + paper must stack in a narrow panel");
+  assert.ok(block.includes(".mneme-persona-body{flex-direction:column}"),
+    "the persona card rail + editor must stack in a narrow panel");
+  assert.ok(block.includes("white-space:nowrap}"),
+    "panel tabs must not wrap their label onto two lines");
+});
+
+// 日记本不再占侧边栏座位（2026-11-09 桉桉：还保留旧版本的侧边栏打开，这个要去掉）。
+// 它现在是记忆面板内的一个标签页，和人格页并列；右栏那个入口是另一回事，保留。
+test("diary is a panel tab now, not a sidebar seat", () => {
+  assert.ok(!clientSource.includes('id: "dsh-mneme-diary"') && !clientSource.includes('key: "dsh-mneme-diary"'),
+    "the sidebar seat pair must be gone");
+  assert.ok(!clientSource.includes("disposeDiaryGlyph") && !clientSource.includes("disposeDiaryMain"),
+    "the seat disposers must be gone too, not just left dangling");
+  // 面板内必须有 diary 这个标签页，否则入口只剩下右栏那一个。
+  assert.match(clientSource, /\{ key: "diary", label: t\("memory\.diary\.title"\) \}/,
+    "the memory panel must carry the diary tab");
+  assert.match(clientSource, /view === "diary"[\s\S]{0,200}?DiaryLibraryPanel/,
+    "the diary tab must render the library panel");
+  // 右栏入口照旧保留：那是会话内的快速入口，不是侧边栏座位。
+  assert.ok(clientSource.includes("function registerDiarySeats(ctx, t) {"),
+    "the right-sidebar entry must stay");
+});
+
+// v0.13.0 第一次发出去时右栏页签类型注册了、正文座位也注册了，却没有任何一个
+// 能调 openTab 的按钮——页签永远打不开。当时的修法是往会话头塞一个入口按钮；
+// 2026-11-09 桉桉又要求把它撤掉：日记已经进了记忆面板当标签页，会话头顶再挂一个
+// 指向右栏的按钮，就是同一件事有两个入口。所以现在锁的是「没有第二个入口」。
+test("diary has exactly one entry: the panel tab, not a session header button", () => {
+  const start = clientSource.indexOf("function registerDiarySeats(ctx, t) {");
+  const end = clientSource.indexOf("function apply(ctx) {", start);
+  assert.ok(start > -1 && end > start, "registerDiarySeats must sit before apply()");
+  const body = clientSource.slice(start, end);
+
+  // ① 会话头入口必须彻底消失：座位、按钮组件、打开动作、失败文案一个都不留。
+  assert.ok(
+    !body.includes("conversation.session.header.actions"),
+    "the diary must not register a second entry in the session header"
+  );
+  assert.ok(!body.includes("openPane"), "the openPane helper only existed for the header button");
+  assert.ok(!body.includes("hasPane"), "hasPane only gated the header button");
+  assert.ok(
+    !/function DiaryEntryButton\s*\(/.test(clientSource),
+    "the header entry component must be gone, not just unregistered"
+  );
+  assert.ok(
+    !clientSource.includes("memory.diary.openFailed"),
+    "the \"cannot open\" copy is dead once nothing can fail to open it"
+  );
+
+  // ② 右栏那套照旧：页签类型 + 正文 + 标题都还在（宿主若有自己的页签选择器仍可达）。
+  assert.ok(body.includes('ctx.get("sidebarRightTabs")'), "tab type registration stays");
+  assert.ok(body.includes('name: "sidebar.right.pane.tab"'), "pane body stays registered");
+  assert.ok(body.includes('name: "sidebar.right.pane.tab.title"'), "pane title stays registered");
+});
+
 test("M.O. empty-state, list and scope copy exist in both languages", () => {
   for (const key of [
     "memory.actions.empty.title",
@@ -2388,6 +3016,21 @@ test("panel copy and icons must not silently vanish (missing dict lines, unregis
     for (const b of expr.matchAll(/[?:]\s*"([a-zA-Z]+)"/g)) iconNames.add(b[1]);
   }
   for (const m of clientSource.matchAll(/feedRow\(\s*"([a-zA-Z]+)"/g)) iconNames.add(m[1]);
+  // 页签图标走 TAB_ICONS 查表（子视图 key -> 图标名），不是 h(Icon, ...) 字面量，
+  // 上面两条提取器看不见它。这里把表里的值按 ICON_PATHS 的同形状收进来——否则
+  // 改表时把某个 key 指向未注册名字，闸门照绿而屏幕上那格图标是空的。
+  const tabTable = clientSource.match(/const TAB_ICONS = \{((?:[^}]|\n)*?)\}/);
+  assert.ok(tabTable, "TAB_ICONS must be parseable (subview key -> icon name)");
+  const tabEntries = [...tabTable[1].matchAll(/([a-zA-Z]+):\s*"([a-zA-Z]+)"/g)];
+  assert.ok(tabEntries.length >= 7, `TAB_ICONS must cover every subview (saw ${tabEntries.length})`);
+  for (const m of tabEntries) iconNames.add(m[2]);
+  // 反向：每个 subviews 的 key 都得在表里有一行，否则那一格掉到 ?? "settings" 上。
+  const subviewsBlock = clientSource.match(/const subviews = \[((?:[^\]]|\n)*?)\]/);
+  assert.ok(subviewsBlock, "subviews must be parseable");
+  const subviewKeys = [...subviewsBlock[1].matchAll(/key: "([a-zA-Z]+)"/g)].map((m) => m[1]);
+  assert.ok(subviewKeys.length >= 7, `subviews must be parseable (saw ${subviewKeys.length})`);
+  const unmapped = subviewKeys.filter((k) => !tabEntries.some((m) => m[1] === k));
+  assert.deepEqual(unmapped, [], `页签没有图标映射（会退化成设置齿轮）：${unmapped.join(", ")}`);
   assert.ok(iconNames.size >= 8, `icon usage must be parseable (saw ${iconNames.size})`);
   const noIcon = [...iconNames].filter((n) => !registered.has(n)).sort();
   assert.deepEqual(noIcon, [], `Icon 静默 return null 的未注册名：${noIcon.join(", ")}`);
@@ -2395,94 +3038,104 @@ test("panel copy and icons must not silently vanish (missing dict lines, unregis
 
 // 人格定义页（beta）面板面回归：形状沿用 A4 的「分组 + i18n 双语 occurrences ≥ 2
 // + 关键接线」断言风格（只做源码断言，不挂 React 渲染环境）。
-test("persona page ships settings card, master switch and i18n (beta v1)", () => {
-  // 开关进 FEATURE_GROUPS 的 enhance 组（行为开关非座位闸门）。按组解析成员再逐个点名，
-  // 而不是把某一行写成字面量正则——那样往组里加第二个键就会把这条护栏弄红（实测踩过）。
-  const enhance = clientSource.match(/group\.enhance", items: \[((?:[^\]]|\n)*)\]/);
-  assert.ok(enhance, "FEATURE_GROUPS group.enhance must be parseable");
+test("persona page is a panel tab, not a settings card (beta v2)", () => {
+  // 开关进 FEATURE_GROUPS 的 persona 组（#427 revamp：从 enhance 拆出）。按组解析
+  // 成员再逐个点名，而不是把某一行写成字面量正则——那样往组里加第二个键就会把
+  // 这条护栏弄红（实测踩过）。
+  const personaGroup = clientSource.match(/group\.persona", items: \[((?:[^\]]|\n)*)\]/);
+  assert.ok(personaGroup, "FEATURE_GROUPS group.persona must be parseable");
   for (const flag of ["personaEnabled", "personaStrictAddressing"]) {
-    assert.ok(enhance[1].includes(`"${flag}"`), `FEATURE_GROUPS group.enhance must carry ${flag}`);
+    assert.ok(personaGroup[1].includes(`"${flag}"`), `FEATURE_GROUPS group.persona must carry ${flag}`);
   }
   // i18n 键中英双语齐备（occurrences ≥ 2 模式；label + .hint 两路由字典锁统一覆盖）
   for (const key of [
     "memory.features.personaEnabled",
     "memory.features.personaEnabled.hint",
-    "memory.settings.persona",
-    "memory.settings.personaHint",
-    "memory.settings.personaName",
-    "memory.settings.personaPersonality",
-    "memory.settings.personaReplyStyle",
-    "memory.settings.personaSave",
-    "memory.settings.personaSaved",
-    "memory.settings.personaEnabledToggle",
-    "memory.settings.personaView",
-    "memory.settings.personaViewHint",
-    "memory.settings.personaViewEmpty",
-    // 预览改由后端渲染之后新增的读数文案（缺一种语言就是半边界面裸奔键名）
     "memory.features.personaStrictAddressing",
     "memory.features.personaStrictAddressing.hint",
-    "memory.settings.personaViewUnknown",
-    "memory.settings.personaViewSourceDefault",
-    "memory.settings.personaViewSourceCard",
-    "memory.settings.personaViewSourceNone",
-    "memory.settings.personaViewSourceFallback",
-    "memory.settings.personaViewGateOff",
-    "memory.settings.personaViewRefresh"
+    "memory.explorer.tabPersona",
+    "memory.persona.title",
+    "memory.persona.hint",
+    "memory.persona.cards",
+    "memory.persona.defaultCard",
+    "memory.persona.name",
+    "memory.persona.personality",
+    "memory.persona.replyStyle",
+    "memory.persona.scenario",
+    "memory.persona.mesExample",
+    "memory.persona.save",
+    "memory.persona.saved",
+    "memory.persona.saveFailed",
+    "memory.persona.enabled",
+    "memory.persona.preview",
+    "memory.persona.previewEmpty",
+    "memory.persona.previewUnknown",
+    "memory.persona.diary",
+    "memory.persona.diaryHint",
+    "memory.persona.loading"
   ]) {
     const occurrences = clientSource.split(`"${key}"`).length - 1;
     assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
   }
-  // 设置卡接线：保存走 PUT /persona、卡内开关改 enabled 即保存、只读卡渲染
-  assert.ok(clientSource.includes('apiFetch("/api/dsh-mneme/persona"'), "persona card must talk to /persona");
-  assert.ok(clientSource.includes("method: \"PUT\""), "persona save must PUT");
-  assert.ok(clientSource.includes("t(\"memory.settings.personaView\")"), "read-only injected-view card must exist");
-  // 双闸门提示：hint 文案必须说明「总闸与卡内开关同时打开才生效」
-  assert.ok(
-    clientSource.includes("memory.features.personaEnabled.hint"),
-    "the master-switch hint must document the two-gate semantics"
-  );
-  // 「注入生效文本」必须由后端给：前端再拼一份就是第二张皮（原来正是这段前端拼接
-  // 没有人格行、没有表头与前缀，却自称生效文本）。
-  assert.ok(clientSource.includes("injectedPreview.text"), "the view must render the backend-rendered block");
+  // 形态：面板自己的第五个标签页，设置页那张卡搬走（不是并存）
+  assert.ok(clientSource.includes('{ key: "persona", label: t("memory.explorer.tabPersona") }'),
+    "the persona view must be registered in the panel's subviews");
+  assert.ok(clientSource.includes('view === "persona" &&'), "the panel must route a persona view branch");
+  assert.ok(clientSource.includes("h(PersonaMainPanel, { t })"), "the persona tab must render PersonaMainPanel");
+  assert.ok(!clientSource.includes('t("memory.settings.persona")'),
+    "the settings card must be gone, not duplicated next to the new page");
+  // 只读卡「Agent 眼中的你」的职能并进本页预览：它自己的键与渲染都不许残留
+  assert.ok(!clientSource.includes("memory.settings.personaView"),
+    "the read-only injected-view card must be removed; this page's preview owns that job");
+  // 保存走 PUT /persona，且必须三维全量（settings.setPersona 是全量替换）
+  assert.ok(clientSource.includes('apiFetch("/api/dsh-mneme/persona"'), "persona page must talk to /persona");
+  assert.ok(clientSource.includes('method: "PUT"'), "persona save must PUT");
+  assert.ok(clientSource.includes("bySession"), "the store shape must carry bySession through saves");
+  // 预览必须由后端渲染：前端再拼一份就是第二张皮
+  assert.ok(clientSource.includes("preview.text"), "the preview must render the backend-rendered block");
   assert.ok(!clientSource.includes('"- " + profile.trim()'), "frontend hand-splicing of the injected block must be gone");
-  assert.ok(clientSource.includes("setInjectedPreview(null)"), "a failed preview must fail closed to 未知, not to a stale or guessed block");
+  // 读不到就说读不到：失败不许停在上一张卡的旧文本
+  assert.ok(clientSource.includes("setPreview(null)"), "a failed preview must fail closed to 未知, not to a stale block");
   // 预览只能有一个所有者，且要丢掉过期响应：先切卡 A 再切卡 B 时，A 的 GET 可能后回来。
-  // 这张卡的标题是「注入生效文本」，显示另一张卡的文本比不显示更糟。
   assert.ok(clientSource.includes("if (seq !== previewSeq.current) return;"), "preview must drop stale responses");
-  assert.equal(clientSource.split("setInjectedPreview(").length - 1, 2, "loadPreview must be the only preview writer (success + failure)");
-  // source=default 有两种来路：带了 ?agent=<身份> 却回落 ≠ 真的解析不到身份。
-  assert.ok(clientSource.includes("injectedPreview.agent"), "the fallback label must separate a resolved-but-fallen-back identity from an unresolvable one");
+  // #514：轻量档压制要有告示，且这一页自己得说（人是在这里开关人格的）
+  assert.ok(clientSource.includes('t("memory.status.minimalPresetTitle")'), "the page must carry the minimal-preset notice");
 });
 
-// v1.2 多卡回归：卡列表 CRUD 可见、字段标签渲染为可见元素（v1.1 反馈：
-// aria-label 看不见）、保存失败必须冒可见错误（v1 静默 catch 吞 404 教训）。
-test("persona card is multi-card with visible field labels and save-failure error", () => {
+test("persona page is multi-card with visible field labels and save-failure error", () => {
   for (const key of [
-    "memory.settings.personaDefaultCard",
-    "memory.settings.personaAdd",
-    "memory.settings.personaAddPlaceholder",
-    "memory.settings.personaEditingDefault",
-    "memory.settings.personaEditingFor",
-    "memory.settings.personaDeleteCard",
-    "memory.settings.personaSaveFailed",
-    "memory.settings.personaEnabledOn",
-    "memory.settings.personaEnabledOff"
+    "memory.persona.cards",
+    "memory.persona.defaultCard",
+    "memory.persona.add",
+    "memory.persona.newPlaceholder",
+    "memory.persona.delete",
+    "memory.persona.saveFailed",
+    "memory.persona.saved",
+    "memory.persona.enabledOn",
+    "memory.persona.enabledOff"
   ]) {
     const occurrences = clientSource.split(`"${key}"`).length - 1;
     assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
   }
-  // 多卡接线：加卡/删卡/切换/保存全链函数存在
-  for (const fn of ["addPersonaCard", "removePersonaCard", "savePersonaCards", "setPersonaEditing"]) {
+  // 多卡接线：加卡/删卡/改字段/保存全链函数存在
+  for (const fn of ["addCard", "removeCard", "saveEditing", "setField"]) {
     assert.ok(clientSource.includes(fn), `multi-card wiring must include ${fn}`);
   }
-  // 可见字段标签：三个字段名的 t() 调用出现在 label 元素（mneme-featnumlabel）
-  const labelBlock = clientSource.match(/mneme-featnumlabel[^]{0,120}personaName/);
-  assert.ok(labelBlock, "persona field labels must be visible (featnumlabel class), not aria-only");
-  // 保存失败提示：personaError 状态有渲染路径（非仅 setState）
-  assert.ok(clientSource.includes("t(\"memory.settings.personaSaveFailed\")"), "save failure must render an error line");
+  // 可见字段标签：五处字段都走同一个 field() helper，helper 里必须是真 <label>
+  // （v1.1 反馈：aria-label 看不见）。分别锁「字段被渲染成 label」与「builder 用 label 元素」。
+  for (const f of ["name", "personality", "replyStyle", "scenario", "mesExample"]) {
+    assert.ok(
+      new RegExp('field\\("' + f + '", t\\("memory\\.persona\\.' + f + '"\\)').test(clientSource),
+      "persona field " + f + " must go through the labeled field builder"
+    );
+  }
+  assert.ok(/h\("label", \{ className: "mneme-persona-label", htmlFor:/.test(clientSource),
+    "the field builder must render a real label element, not an aria-only name");
+  // 保存失败提示：error 状态有渲染路径（非仅 setState）
+  assert.ok(clientSource.includes('t("memory.persona.saveFailed")'), "save failure must render an error line");
   // 卡删除 × 常显回归锁 v2（#457 内联覆写被 #459 回滚的教训）：× 不得复用
   // mneme-set-del（opacity:0 仅在 .mneme-set-row:hover 解除，卡标签不在该容器
-  // → 永远不可见），必须用独立类 mneme-persona-del 且该类常显（opacity:1）。
+  // → 永远不可见），必须用独立类 mneme-persona-del 且该类常显（opacity 不得为 0）。
   assert.ok(
     /className: "mneme-persona-del"/.test(clientSource),
     "persona card delete × must use the dedicated always-visible class"
@@ -2492,11 +3145,12 @@ test("persona card is multi-card with visible field labels and save-failure erro
   assert.ok(!/opacity:0/.test(delStyle[0]), "mneme-persona-del must not be transparent");
   // 不许再把 mneme-set-del 挂回卡删除按钮（防 #457 式修法回归）；直接锁按钮
   // 的 className 值（onClick 前最近的 className 属性，注释文字不参与）。
-  const delBtn = clientSource.match(/className: "([^"]+)"[\s\S]{0,300}?onClick: \(\) => removePersonaCard\(id\)/);
+  const delBtn = clientSource.match(/className: "([^"]+)"[\s\S]{0,300}?onClick: \(\) => removeCard\(id\)/);
   assert.ok(delBtn, "card delete button wiring must exist");
   assert.strictEqual(delBtn[1], "mneme-persona-del", "card delete × must use mneme-persona-del, not mneme-set-del");
 });
 
+
 // 回归锁（复验实测踩中）：面板「检测更新」的状态名必须与后端 classify
 // （src/version-check.js）逐字对齐。此前前端误写 "latest"/"up_to_date"（后端
 // 从未返回过），检测成功也掉进 error 兜底——按钮永远报「检测失败」。
@@ -2532,6 +3186,28 @@ test("update-check status names match the backend classify contract verbatim", (
 
 // 画像提取草稿（#497）面板面：路由对齐、四种结局各有自己的话、按钮坐在哪张卡上、
 // 以及草稿**只出副本**（2026-11-04 改口径：不再把草稿写进画像字段）。
+// 严格寻址的「第一张卡」陷阱（Persis 复验）：live 库 personaStrictAddressing=true，
+// 现在 byAgent/bySession 都空，走 #587 例外回落 default，所以注入正常。但只要在这个
+// 页面建出第一张卡，anyCard 就变 true，strict 立刻生效——所有没建卡的会话（含主会话）
+// 人格静默不再注入，界面一个字都不报。这种「改一个开关，别处的行为跟着变且无提示」
+// 必须在建卡之前就写在脸上，所以锁三件事：①两个阶段的文案都在；②按现有卡数选话；
+// ③文案确实渲染进人格页，而不是定义完没人读。
+test("strict addressing warns before the first card quietly changes everyone else", () => {
+  for (const key of ["memory.persona.strictBefore", "memory.persona.strictAfter"]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  // 生效值来自 /features 的真实快照，不许前端猜默认
+  assert.ok(/personaStrictAddressing === true/.test(clientSource),
+    "the guardrail must read the effective flag from /features, not assume a default");
+  // 两条话按「现在有几张卡」分流：没有卡时说「建第一张会变严」，有了之后说「已经变严」
+  assert.ok(clientSource.includes('t(cardCount > 0 ? "memory.persona.strictAfter" : "memory.persona.strictBefore")'),
+    "the notice must pick its wording from the current card count");
+  // 只有严格寻址真的开着才说，否则是假警报
+  assert.ok(/strict \? h\("div"/.test(clientSource),
+    "the notice must be gated on the effective strict flag");
+});
+
 test("profile extraction ships its button, distinct outcomes and correct save wiring", () => {
   const apiSource = readFileSync(join(root, "src/api.js"), "utf8");
   assert.ok(clientSource.includes('apiFetch("/api/dsh-mneme/profile/extract"'),
@@ -2564,20 +3240,25 @@ test("profile extraction ships its button, distinct outcomes and correct save wi
     const occurrences = clientSource.split(`"${key}"`).length - 1;
     assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
   }
-  assert.ok(/group\.enhance[\s\S]{0,700}"profileExtractEnabled"/.test(clientSource),
-    "FEATURE_GROUPS group.enhance must carry profileExtractEnabled");
-
-  // 位置锁（2026-11-04）：提取按钮属于「Agent 眼中的你」卡，不属于「用户画像」卡。
-  // 此前没有任何用例锁位置——整块 UI 搬走测试也不会红，这正是它被放错地方却一直绿的原因。
-  // 锁法：三处锚点的先后顺序 + 两张卡标题之间不许出现 profileExtract。
-  const profileCardIdx = clientSource.indexOf('h("div", { className: "mneme-set-title" }, t("memory.settings.profile"))');
-  const personaViewIdx = clientSource.indexOf('h("div", { className: "mneme-set-title" }, t("memory.settings.personaView"))');
-  const extractButtonIdx = clientSource.indexOf('t("memory.settings.profileExtract")');
-  assert.ok(profileCardIdx > 0 && personaViewIdx > profileCardIdx && extractButtonIdx > personaViewIdx,
-    "the extract button must render inside the persona-view card, which comes after the user-profile card");
-  assert.ok(!clientSource.slice(profileCardIdx, personaViewIdx).includes("profileExtract"),
-    "the user-profile card must not carry any extract UI");
-
+  assert.ok(/group\.persona[\s\S]{0,700}"profileExtractEnabled"/.test(clientSource),
+    "FEATURE_GROUPS group.persona must carry profileExtractEnabled");
+
+  // 位置锁（2026-11-09 再改口径）：提取按钮属于「用户画像」卡，而画像卡本身
+  // 已经从设置页搬进记忆面板的「人格」页（桉桉：mneme 设置里面的个性化还没移走）。
+  // 两处都在同一份客户端里，光比先后会被设置页的规则卡骗过——必须先切出
+  // 人格页那一段再比，并额外断言设置页里不再有画像卡（搬回去就红）。
+  const personaStart = clientSource.indexOf("function PersonaMainPanel(");
+  const settingsStart = clientSource.indexOf("function SettingsContent(");
+  assert.ok(settingsStart > 0 && personaStart > settingsStart, "both panels must exist");
+  const settingsSlice = clientSource.slice(settingsStart, personaStart);
+  const personaSlice = clientSource.slice(personaStart);
+  const profileTitle = 'h("div", { className: "mneme-set-title" }, t("memory.settings.profile"))';
+  assert.ok(!settingsSlice.includes(profileTitle),
+    "the profile card must be gone from the settings page (it moved into the persona page)");
+  const profileCardIdx = personaSlice.indexOf(profileTitle);
+  const extractButtonIdx = personaSlice.indexOf('t("memory.settings.profileExtract")');
+  assert.ok(profileCardIdx > 0 && extractButtonIdx > profileCardIdx,
+    "the extract button must render inside the user-profile card on the persona page");
   // 只出副本（2026-11-04 桉桉定的口径）：草稿不许再走落库路径。此前 applyProfileDraft 会
   // 直接 PUT /profile —— 把用户手写的那份覆盖掉，且没有撤销。
   assert.ok(clientSource.includes("function copyProfileDraft()"), "the draft action must be a copy, not a save");
@@ -2648,32 +3329,44 @@ test("profile facts card ships management UI, run outcomes and never touches the
     const occurrences = clientSource.split(`"${key}"`).length - 1;
     assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
   }
-  assert.ok(/group\.enhance[\s\S]{0,1200}"profileFactsEnabled"/.test(clientSource),
-    "FEATURE_GROUPS group.enhance must carry profileFactsEnabled");
-
-  // 位置锁：事实卡是 personaView 之后、规则卡之前的独立一张——塞回 personaView 卡
-  // 内部或搬到规则卡后面都不会红，所以先钉住先后顺序（同 profile-extract 的位置锁）。
-  const personaViewIdx = clientSource.indexOf('t("memory.settings.personaView"))');
-  const rulesCardIdx = clientSource.indexOf('t("memory.settings.rules"))');
-  const factsCardIdx = clientSource.indexOf('t("memory.settings.factsTitle")');
-  assert.ok(personaViewIdx > 0 && factsCardIdx > personaViewIdx && rulesCardIdx > factsCardIdx,
-    "the facts card must sit between the persona-view card and the rules card");
-
+  assert.ok(/group\.persona[\s\S]{0,1200}"profileFactsEnabled"/.test(clientSource),
+    "FEATURE_GROUPS group.persona must carry profileFactsEnabled");
+
+  // 位置锁（2026-11-09 改口径）：画像卡与事实卡一起搬进了人格页，事实卡仍是画像卡
+  // 之后的一张。切段比较，防止设置页的规则卡把顺序骗过去；设置页里两张卡都不许再有。
+  const personaStart = clientSource.indexOf("function PersonaMainPanel(");
+  const settingsStart = clientSource.indexOf("function SettingsContent(");
+  assert.ok(settingsStart > 0 && personaStart > settingsStart, "both panels must exist");
+  const settingsSlice = clientSource.slice(settingsStart, personaStart);
+  const personaSlice = clientSource.slice(personaStart);
+  assert.ok(!settingsSlice.includes('t("memory.settings.factsTitle")'),
+    "the facts card must be gone from the settings page (it moved into the persona page)");
+  assert.ok(!settingsSlice.includes('h("div", { className: "mneme-set-title" }, t("memory.settings.profile"))'),
+    "the profile card must be gone from the settings page (it moved into the persona page)");
+  const profileCardIdx = personaSlice.indexOf('h("div", { className: "mneme-set-title" }, t("memory.settings.profile"))');
+  const factsCardIdx = personaSlice.indexOf('t("memory.settings.factsTitle")');
+  assert.ok(profileCardIdx > 0 && factsCardIdx > profileCardIdx,
+    "the facts card must sit after the user-profile card on the persona page");
   // 手填画像神圣：事实域的全部面板代码（loadFacts 起到事实卡渲染止）里不许出现
   // PUT /profile 的路径字面量。断言的是**带闭引号**的精确串——/profile-facts/* 的
   // 路径都以 /profile 开头，不带闭引号的话这个断言会自己误伤自己。
-  const handlersStart = clientSource.indexOf("const loadFacts");
-  const factsSlice = clientSource.slice(handlersStart, factsCardIdx);
+  // 两个下标必须在同一个坐标系里比：factsCardIdx 是相对 personaSlice 的，
+  // 而 handlersStart 相对整份源码——混用会切出空片，让下面每条断言都空跑。
+  const handlersStart = personaSlice.indexOf("const loadFacts");
+  const factsSlice = personaSlice.slice(handlersStart, factsCardIdx);
   assert.ok(handlersStart > 0 && factsSlice.length > 0, "the facts handlers must exist");
   assert.ok(!factsSlice.includes('"/api/dsh-mneme/profile"'),
     "the facts domain must never write the hand-filled profile (PUT /profile is off-limits here)");
   for (const fragment of ["/api/dsh-mneme/profile-facts?agent=", "/api/dsh-mneme/profile-facts/apply", "/api/dsh-mneme/profile-facts/run"]) {
     assert.ok(factsSlice.includes(fragment), `the facts handlers must call ${fragment}`);
   }
-  // 人工 apply 成功后注入预览必须跟着刷新：事实段是注入文本的一部分，
-  // 只在 run 后刷新会让「改完一条、预览还是旧的」。
-  assert.ok(factsSlice.includes("loadPreview(personaEditing)"),
-    "both apply and run success paths must refresh the injected preview");
+  // 人工 apply 成功后注入预览必须跟着刷新。2026-11-09 起画像卡与事实卡同在人格页，
+  // 不再跨视图写别人的状态——事实卡仍然不直接调 loadPreview，刷新走人格页自己的
+  // tick 哨兵；所以锁两条：①事实处理段不直接碰 loadPreview；②页面有 tick 刷新。
+  assert.ok(!factsSlice.includes("loadPreview("),
+    "the facts card must not write the persona view's preview state from another view");
+  assert.ok(clientSource.includes("setPreviewTick((n) => n + 1)"),
+    "the persona page must refetch its own preview after a save");
   // 总闸快照要跟着功能开关走：FeaturesCard 即改即存并广播 mneme:features-changed，
   // 事实卡监听重读——不然按提示开了「自动事实」，按钮还得关面板重开才解禁
   // （评审 P2：快照 effect 是 [] 依赖，监听缺失等于回到「重开才生效」的老病）。
@@ -2905,6 +3598,52 @@ test("minimal preset notice reaches the settings page, not just the status tab (
   assert.ok(!/minimalWarn\s*=\s*true/.test(clientSource), "the notice must never be hard-wired on");
 });
 
+// 上面那条只证明"声明字符串存在"，证明不了"每个消费点的作用域里有它"。
+// 人格页搬进 SettingsContent 之后，运行模式卡这一处读的是自由变量：渲染即 ReferenceError，
+// 而宿主只记一句 "import failed: client-modules: could not load @modusensus/dsh-mneme"，
+// 看起来像整个插件加载不了，实际是一个 JSX 分支炸了（本机 crash-*-web-boot.log 实录）。
+// 不变量是"每个消费点的作用域里有声明"，不是"声明数量等于消费点数量"：
+// 同一个组件消费两次（SettingsContent 里两张卡各一处）只需要一份声明，按数量判会把正确代码钉红。
+test("each minimalWarn consumer resolves the declaration inside its own component", () => {
+  const lines = clientSource.split("\n");
+  const components = [];
+  lines.forEach((line, i) => {
+    const m = /^(?:    |      )(?:function |const )([A-Z]\w*)/.exec(line);
+    if (m) components.push({ line: i + 1, name: m[1] });
+  });
+  const owner = function (at) {
+    let found = null;
+    for (const c of components) {
+      if (c.line <= at) found = c;
+      else break;
+    }
+    return found;
+  };
+  assert.ok(components.length > 0, "component scan matched nothing — bundle layout changed; fix this lock, don't delete it");
+
+  const decls = [];
+  const uses = [];
+  lines.forEach((line, i) => {
+    if (!line.includes("minimalWarn") || line.trim().startsWith("//")) return;
+    (/const minimalWarn\s*=/.test(line) ? decls : uses).push(i + 1);
+  });
+  assert.ok(uses.length >= 2, `expected the notice in both surfaces (got ${uses.length} use sites)`);
+
+  const byComponent = new Map();
+  for (const d of decls) {
+    const name = owner(d).name;
+    if (!byComponent.has(name)) byComponent.set(name, []);
+    byComponent.get(name).push(d);
+  }
+  for (const u of uses) {
+    const c = owner(u);
+    const inScope = (byComponent.get(c.name) || []).filter((d) => d < u);
+    assert.ok(inScope.length > 0,
+      `line ${u} reads minimalWarn inside ${c.name} (opens at ${c.line}) which has no declaration before it — ` +
+      "renders as ReferenceError and the host reports only \"import failed\"");
+  }
+});
+
 // --- 移动端适配（mobile-adapt 车道）---
 // 面板在 320–430px 容器里原本是「骨架级失衡」而不是「略挤」：记忆页左栏固定
 // 216px、卡片最小轨道 252+48=300px，要 ≥517px 才排得下；实体页 rail 224px +
@@ -3204,27 +3943,21 @@ test("panel exposes the bootstrap entry and the config-key coverage card (issue
   );
   // 菜单按钮的 onClick 里必须也关掉它，否则点「⋯」会留下上一个弹层。但它现在带一个
   // 条件：引导请求在飞时不关（否则等于绕过弹层里那两道 busy 禁用的锁，评审
-  // #4452245292）。所以这里锁的是「有条件地关」，不是无条件关。
-  assert.ok(
-    /setImportOpen\(false\);\s*\n\s*\/\/[\s\S]{0,200}?if \(!bootstrapBusy\) setBootstrapOpen\(false\);/.test(clientSource),
-    "the overflow toggle must close the bootstrap dialog when it is not busy"
-  );
-  // 父组件必须真的把这个标志接下来，否则上面那句恒为真（undefined → !undefined）。
+  // #4452245292）。#558 起关闭同时把任务态回 idle——用户看得见这次关闭，terminal
+  // 状态不留在 store 里（重开弹层要干净，#558 只保留没人看过的那份）。
   assert.ok(
-    /const \[bootstrapBusy, setBootstrapBusy\] = useState\(false\)/.test(clientSource),
-    "the parent needs a bootstrapBusy flag for the guard above to mean anything"
+    /setImportOpen\(false\);\s*\n\s*\/\/[\s\S]{0,300}?if \(!bootstrapBusy\) \{ resetBootstrapJob\(\); setBootstrapOpen\(false\); \}/.test(clientSource),
+    "the overflow toggle must close the bootstrap dialog (and reset the job) when it is not busy"
   );
+  // 父组件的 busy 守卫必须真的有来源：#558 起它订阅模块级 bootstrapJob 派生
+  // （prop 钻孔链拆了——tab 注册的 explorer 没有 onBusyChange，原本就报不上来）。
   assert.ok(
-    /onBusyChange: reportBootstrapBusy/.test(clientSource),
-    "the dialog must report its busy state up, or the guard reads a stale false"
+    /const bootstrapBusy = bootstrapJob\.phase === "running"/.test(clientSource),
+    "the parent derives bootstrapBusy from the module-level job, or the guard above means nothing"
   );
-  // 这个转发函数必须同步调外层、且身份稳定：走 useEffect 转报的话要等渲染提交后
-  // 才跑，中间那一拍外层读到 false（#4452539705 的老毛病）；而若每渲染新建一个，
-  // BootstrapDialog 的卸载 effect（依赖 [onBusyChange]）会在父组件每次重渲染时
-  // 先跑 cleanup 调一次 onBusyChange(false)——而父组件正是在置 busy 之后重渲染的。
   assert.ok(
-    /const reportBootstrapBusy = useCallback\(\(v\) => \{[\s\S]{0,200}?setBootstrapBusy\(v\);[\s\S]{0,200}?onBusyChange\(v\);/.test(clientSource),
-    "the forwarder must set both levels synchronously and keep a stable identity"
+    /function BootstrapDialog\(\{ t, onClose, onImported \}\)/.test(clientSource),
+    "the dialog no longer takes onBusyChange: busy lives in the store, not in prop drilling"
   );
   // 会挂弹层的菜单项在忙碌时必须禁用（评审 #4452539738）：新建 / 导入 / 引导 / 分享 /
   // 接收共五处，加上「⋯」按钮自己（见下），再加上四个视图标签（评审 #4453639221，
@@ -3267,12 +4000,13 @@ test("panel exposes the bootstrap entry and the config-key coverage card (issue
   const bsEnd = clientSource.indexOf("// --- 分享包弹层 ---", bsIdx);
   const bsBody = clientSource.slice(bsIdx, bsEnd > bsIdx ? bsEnd : bsIdx + 4200);
   assert.ok(bsIdx > 0, "BootstrapDialog must exist");
-  // 忙碌状态必须**同步**报上去（评审 #4452539705）：只靠上面那个 useEffect 的话，
-  // 它要等这次渲染提交后才跑，中间那一拍父组件的 bootstrapBusy 还是 false，此时点
-  // 「⋯」仍会把弹层卸掉，请求的成功或失败就再没有地方显示。
+  // 任务态必须**同步**进 store（评审 #4452539705 的结构化解法）：#558 起三处守卫
+  // （explorer 的「⋯」、overlay 的 Esc/背板/✕）都订阅同一份 bootstrapJob，submit
+  // 里 setBootstrapJob(running) 一落，监听者同步被唤醒——不再有「等渲染提交后才
+  // 追上」的那一拍。
   assert.ok(
-    /setBusy\(true\);[\s\S]{0,400}?onBusyChange\(true\);/.test(bsBody),
-    "busy must be reported up synchronously, not only through the effect"
+    /setBootstrapJob\(\{ phase: "running"[\s\S]{0,200}?apiFetch\("\/api\/dsh-mneme\/bootstrap"/.test(bsBody),
+    "running must hit the store synchronously before the fetch leaves"
   );
   assert.ok(
     /apiFetch\("\/api\/dsh-mneme\/bootstrap"/.test(bsBody),
@@ -3289,14 +4023,16 @@ test("panel exposes the bootstrap entry and the config-key coverage card (issue
     /type: "text",[\s\S]{0,400}?disabled: busy,[\s\S]{0,400}?onChange: \(e\) => \{ setDir/.test(bsBody),
     "the dir input must be disabled while the request is in flight"
   );
-  // 成功路径不再复位 busy（900ms 提示期间按钮不该重新变得可点），且定时器句柄要能清：
-  // 否则第二次提交的结果会写进已经卸载的组件（评审 #4452245256）。断言窗口只取
-  // 「setMsg…到 setTimeout」之间——再往后就是 catch 里的网络错误兜底，那一处复位是对的。
+  // 成功路径把 done 写进 store 并保持 900ms 阅读窗（fresh done 期间提交钮锁住），
+  // 且定时器句柄要能清：否则第二次提交的结果会写进已经卸载的组件（评审
+  // #4452245256）。断言窗口取「onImported…到 setTimeout」之间——再往后就是 catch
+  // 的网络错误兜底，那一处写 failed 是对的。
   const doneIdx = bsBody.indexOf("memory.explorer.bootstrapDone");
   const timerIdx = bsBody.indexOf("timerRef.current = setTimeout(");
   assert.ok(timerIdx > doneIdx, "the success branch must schedule its close through the stored ref");
   const successTail = bsBody.slice(doneIdx, timerIdx);
-  assert.ok(!/setBusy\(false\)/.test(successTail), "the success path must not re-enable the button");
+  assert.ok(/phase: "done"/.test(successTail), "the success path must land done in the store (survives tab close)");
+  assert.ok(!/resetBootstrapJob\(\)/.test(successTail), "the success path must not reset the job during the reading window");
   assert.ok(/clearTimeout\(timerRef\.current\)/.test(bsBody), "the stored timer must actually be cleared on unmount");
   // 刷新必须同步调、不能排进定时器（评审 #4452539711）：切视图会卸载本组件并把
   // timerRef 清掉，若刷新也挂在那 900ms 后面，它就静默丢了——库已经写进去了，
@@ -3314,8 +4050,8 @@ test("panel exposes the bootstrap entry and the config-key coverage card (issue
   // 错误按服务端的码分开说（missing-dir / dir-not-found / not-a-directory /
   // bootstrap-unavailable），不能一律「引导失败」——三种情况下用户该做的事不同。
   assert.ok(
-    /"memory\.explorer\.bootstrapErr\." \+ String\(code/.test(bsBody),
-    "error codes must be mapped to distinct messages"
+    /"memory\.explorer\.bootstrapErr\." \+ String\(job\.error/.test(bsBody),
+    "error codes must be mapped to distinct messages (code lives in the store, derived at render)"
   );
   for (const key of [
     "memory.explorer.bootstrap",
@@ -3335,6 +4071,7 @@ test("panel exposes the bootstrap entry and the config-key coverage card (issue
       `i18n key ${key} must exist in both dictionaries`
     );
   }
+  // #558 的存活规则锁（在原测试内追加）：见文件尾的 issue #558 专项测试。
 
   // 第 7 条：配置键覆盖面只读卡。
   const ckIdx = clientSource.indexOf("function ConfigKeysCard");
@@ -3395,14 +4132,16 @@ test("the memory overlay refuses to close while a library request is in flight (
   const ovEnd = clientSource.indexOf("const EXPLORER_TYPES", ovIdx);
   const ovBody = clientSource.slice(ovIdx, ovEnd > ovIdx ? ovEnd : ovIdx + 2600);
 
-  // 忙碌标志必须从 Explorer 上得来：MemoryOverlay 自己不知道有没有请求在飞。
+  // 忙碌标志必须与 Explorer 同源：#558 起两处各自订阅模块级 bootstrapJob——
+  // overlay 不再依赖子组件回报（tab 注册的 explorer 没有 onBusyChange，原本就
+  // 报不上来，守卫对那条路径是空的）。
   assert.ok(
-    /useState\(false\)/.test(ovBody) && /explorerBusy/.test(ovBody),
-    "the overlay needs its own busy flag"
+    /useBootstrapJob\(\)/.test(ovBody) && /explorerBusy = bootstrapJob\.phase === "running"/.test(ovBody),
+    "the overlay derives its busy flag from the module-level job store"
   );
   assert.ok(
-    /h\(MemoryExplorer, \{ t, onBusyChange: setExplorerBusy \}\)/.test(ovBody),
-    "the explorer must report its busy state up to the overlay"
+    /h\(MemoryExplorer, \{ t \}\)/.test(ovBody),
+    "the explorer no longer reports busy up: both sides subscribe to the same store"
   );
   // 用 ref 读、不把 busy 列进那个 effect 的依赖：effect 每次重跑都会
   // closeBtnRef.current.focus()，请求一起一落就把正在输目录的用户踢出输入框。
@@ -3557,3 +4296,130 @@ test("the entity rail counts the whole library, not the newest slice", () => {
     "the notice needs its own dim style on the semantic colour layer"
   );
 });
+
+// --- issue #622 可观测性：错峰时段串解析失败的面板提示 ---
+// parsePeakSpec 的失败语义是「整串视为未配置」（排程是省钱手段，不救错——这个契约
+// 不动）。但静默意味着用户写错格式的唯一症状是「功能悄悄没生效」。本批的可见性分
+// 工：校验在服务端（/features 的 invalidPeakHours，parsePeakSpec 只此一份实现），
+// 面板只渲染提示行——独立 bundle 复制一份解析器必然漂移，这里锁死这个分工不被
+// 「优化」成面板自己解析。
+test("peak hours observability: invalid-spec hint renders from server field, never parses locally", () => {
+  // 两个键的提示行都接上了（蒸馏侧与巩固侧各一处）
+  const uses = clientSource.split("peakInvalidHint(").length - 1; // 两处调用（定义处是 "= (key)"，不匹配）
+  assert.ok(uses >= 2, `peakInvalidHint must be wired for both peak rows (got ${uses})`);
+  assert.ok(clientSource.includes('peakInvalidHint("summarizePeakHours")'), "distill-side row must carry the hint");
+  assert.ok(clientSource.includes('peakInvalidHint("dreamPeakHours")'), "dream-side row must carry the hint");
+  // 数据源是服务端字段，不是面板本地解析
+  assert.ok(clientSource.includes("state?.invalidPeakHours"), "hint must read the server-computed field");
+  // 反拷贝锁匹配**调用形态**而非名字——注释里提到解析器名字是允许的，调用不许有
+  assert.ok(!/parsePeakSpec\(|invalidPeakSpecs\(/.test(clientSource), "panel must not copy the parser (single implementation stays in src/peak-hours.js)");
+  // i18n 双语键成对出现
+  for (const key of [
+    "memory.features.summarizePeakHours.invalid",
+    "memory.features.dreamPeakHours.invalid"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+});
+
+// --- issue #558：引导任务在飞态活得比标签页体长 ---
+// better-sidebar 关 tab 会把 MemoryExplorer 与引导弹层整个卸载（keepMounted 覆盖
+// 隐藏与切视图、不含关闭）。POST 照样跑完、行照样落库，但旧实现的成功/失败提示
+// 写进已卸载组件的 setState（无处显示）、忙碌态也丢——重开还能再提交一次。锁四
+// 件事：状态住模块级 store；弹层是 store 的视图（busy/msg/err 派生而非本地 state）；
+// 只有「人看得见的关闭」才把 terminal 态回 idle；卸载发生在 running 时的那一份
+// 留给重开回放（本 issue 修的就是它）。
+test("bootstrap job outlives the tab body: store in module scope, replay on remount (issue #558)", () => {
+  // store 是模块级的（apply 作用域、所有面板组件共享），带订阅者集合与读写口
+  assert.ok(/const bootstrapJob = \{ phase: "idle"/.test(clientSource), "the job store must be module-level, not component state");
+  assert.ok(/function setBootstrapJob\(/.test(clientSource) && /function useBootstrapJob\(/.test(clientSource), "store needs its setter and subscription hook");
+  // 弹层从 store 派生三态；重放挂载时输入框播种上次的目录（重试同目录是最常见的下一步）
+  const bs558Idx = clientSource.indexOf("function BootstrapDialog");
+  const bs558End = clientSource.indexOf("// --- 分享包弹层 ---", bs558Idx);
+  const bs558Body = clientSource.slice(bs558Idx, bs558End > bs558Idx ? bs558End : bs558Idx + 5000);
+  assert.ok(/const job = useBootstrapJob\(\)/.test(bs558Body), "the dialog must be a view over the job store");
+  assert.ok(/const busy = job\.phase === "running"/.test(bs558Body), "busy derives from the store");
+  assert.ok(/useState\(job\.dir \|\| ""\)/.test(bs558Body), "the dir input seeds from the last job's dir on replay");
+  // 存活规则：卸载发生在 running 时 → 结果留给重开；非 running 卸载 → 回 idle
+  // （保持「重开是干净弹层」的既有行为）。
+  assert.ok(
+    /useEffect\(\(\) => \(\) => \{\s*\n\s*if \(bootstrapJob\.phase !== "running"\) resetBootstrapJob\(\);/.test(clientSource),
+    "unmount keeps a running job for replay and resets a seen terminal one"
+  );
+  // fresh done 的 900ms 阅读窗锁提交钮，但不锁取消（done 是 store 态、可能被重开
+  // 回放——取消若也锁死，旧结果会把弹层永久焊住）。
+  assert.ok(/const freshDone = job\.phase === "done" && timerRef\.current !== null/.test(bs558Body), "the reading window must be distinguished from a replayed result");
+  assert.ok(/disabled: submitBlocked, onClick: submit/.test(bs558Body), "submit is locked during the fresh-done window");
+  assert.ok(/disabled: busy, onClick: onClose/.test(bs558Body), "cancel stays available for a replayed result");
+  // terminal 化只写 store（组件可能已被 tab 关闭卸载——那正是要修的路径）
+  assert.ok(/setBootstrapJob\(\{ phase: "failed", error:/.test(bs558Body), "failure must land in the store, not in unmounted component state");
+  assert.ok(/setBootstrapJob\(\{ phase: "done", result:/.test(bs558Body), "success must land in the store too");
+});
+
+// #619 可见化 C：情绪一栏的「三种状态不许互相冒充」。
+// 界面在这里最容易犯的错是把「请求失败」渲染成「没有数据」——两者对用户的
+// 含义完全相反（前者是系统坏了，后者是功能没用），而空列表长得一模一样。
+test("affective panel keeps loading, error and empty apart (#619)", () => {
+  const start = clientSource.indexOf("function AffectivePanel({ t })");
+  assert.ok(start > 0, "AffectivePanel must exist");
+  const end = clientSource.indexOf("function StatusPanel({ t, onBrowse })", start);
+  assert.ok(end > start, "panel body must be bounded");
+  const body = clientSource.slice(start, end);
+
+  // 失败分支必须 role=alert 且用 error 文案，不能掉进空态文案。
+  assert.ok(/state\.error\)\s*\{[\s\S]*?memory\.affective\.error/.test(body),
+    "失败时要显式说「这是取失败」，不能用空态文案顶替");
+  assert.ok(/memory\.affective\.empty/.test(body), "真的一条都没有时才有空态文案");
+
+  // catch 里不许把 items 落在 []，否则「上游挂了」与「还没记过情绪」同形。
+  const catchBlock = body.slice(body.indexOf(".catch("));
+  assert.ok(/error:\s*true/.test(catchBlock), "catch 必须立 error 标记");
+  assert.ok(!/items:\s*\[\]/.test(catchBlock.split("\n").slice(0, 3).join("\n")) ||
+            /error:\s*true/.test(catchBlock),
+    "catch 分支不能只留空列表而丢掉失败");
+
+  // 截断与跳过都要显式说出来，不能静默截断。
+  assert.ok(/memory\.affective\.truncated/.test(body), "截断要说出来");
+  assert.ok(/memory\.affective\.skipped/.test(body), "没情绪名的边要报出来");
+
+  // trait 与 occasion 必须用不同文案，否则「这次」被读成「一贯」。
+  assert.ok(/memory\.affective\.trait/.test(body) && /memory\.affective\.occasion/.test(body),
+    "trait 与 occasion 两档文案都要在");
+
+  // 页签要注册，不然这一栏根本没有入口。
+  assert.ok(clientSource.includes('{ key: "affective", label: t("memory.explorer.tabAffective") }'),
+    "情绪页签必须注册");
+  assert.ok(clientSource.includes('view === "affective"'), "视图分支必须存在");
+});
+
+// 回归锁：情绪行必须说出「谁」，页签图标必须各自认领（v0.13.0 复验轮）。
+// 这两处都是「数据在、界面没显示」的假绿形状：服务端一直带 person、ICON_PATHS
+// 之外的页签则静默落到 else 分支，闸门全绿而屏幕上少一块信息。
+test("affective rows name the person, and every tab owns its icon (#619)", () => {
+  const start = clientSource.indexOf("function AffectivePanel({ t })");
+  const end = clientSource.indexOf("function StatusPanel({ t, onBrowse })", start);
+  const body = clientSource.slice(start, end);
+
+  // 谁：person 必须进渲染，缺名给占位，不许把 undefined 打到界面上。
+  assert.ok(/it\.person/.test(body), "情绪行要渲染 person（服务端 from_name 一直都在）");
+  assert.ok(/it\.person\s*\?\?\s*"/.test(body), "person 缺失时要给占位符，不能渲染出 undefined");
+  // 顺序：谁 -> 情绪 -> 对什么。少了前半句「不安」就不知道是谁对谁。
+  const order = [body.indexOf('className: "mneme-affective-person"'), body.indexOf('className: "mneme-affective-emotion"'), body.indexOf('className: "mneme-affective-target"')];
+  assert.ok(order.every((i) => i > 0) && order[0] < order[1] && order[1] < order[2],
+    `情绪行的字段顺序必须是 谁 · 情绪 · 对什么（实际 ${order.join(",")}）`);
+
+  // 页签图标：affective 与 diary 各自有名字，且都在 ICON_PATHS 注册表里。
+  const tabTable = clientSource.match(/const TAB_ICONS = \{((?:[^}]|\n)*?)\}/);
+  assert.ok(tabTable, "TAB_ICONS must exist");
+  const map = Object.fromEntries([...tabTable[1].matchAll(/([a-zA-Z]+):\s*"([a-zA-Z]+)"/g)].map((m) => [m[1], m[2]]));
+  assert.equal(map.affective, "heart", "情绪页签要用 heart");
+  assert.equal(map.diary, "book", "日记页签要用 book");
+  for (const [key, icon] of Object.entries(map)) {
+    assert.ok(new RegExp(`^\\s{6}${icon}: \\[\\[`, "m").test(clientSource),
+      `页签 ${key} 指向的图标 ${icon} 没在 ICON_PATHS 注册（会静默渲染成空）`);
+  }
+  // 页签渲染只许走查表；再长出嵌套三元就又会把新页签塞到 else 分支。
+  assert.ok(/h\(Icon, \{ name: TAB_ICONS\[s\.key\]/.test(clientSource),
+    "页签图标必须走 TAB_ICONS 查表，不许回到嵌套三元");
+});