@modusensus/dsh-mneme 0.10.1 → 0.12.0

package/lib/client.js

@@ -289,6 +289,19 @@ window.__ModuleLoader__.load({
       return fetch(path, { ...opts, headers });
     }
 
+    // 通用失效广播：任何改库动作（裁决/删除/编辑/归档/导入/接收/建条/回收…）
+    // 成功后派发一次。此前跨组件失效只有 mneme:conflicts-changed 一个事件、
+    // 三个状态侧监听者——记忆列表与冲突徽章、实体页、归档工作台全都不在名单里，
+    // 用户裁决完冲突要关掉面板重开才能看到败者归档。数据视图一律订阅本事件
+    // 立即重取；各动作自己的本地刷新（reloadKey / 列表过滤）保留，偶发的重复
+    // GET 换「永远不陈旧」，划算。与 mneme:conflicts-changed 并存不合并：后者
+    // 是裁决专属的精准信号，语义更窄，已有监听者不必搬家。
+    function broadcastStoreChanged(reason) {
+      try {
+        window.dispatchEvent(new CustomEvent("mneme:store-changed", { detail: { reason: reason || "" } }));
+      } catch { /* 非浏览器环境 */ }
+    }
+
     // ⚠️ 'betterSidebar' 绝不能进模块级 inject（issue #88 实锤）：loader 对
     // inject 声明的服务是硬等待——未安装 better-sidebar 的环境里整个 entry
     // 永远 pending（"1 entry did not activate" → Failed to load plugins）。
@@ -301,6 +314,24 @@ window.__ModuleLoader__.load({
       zh: {
         "memory.panel.empty": "暂无记忆条目",
         "memory.panel.open": "记忆",
+        "wiki.panel.open": "仓库地志",
+        "wiki.rebuild": "重建骨架",
+        "wiki.rebuilding": "重建中…",
+        "wiki.rebuild.done": "重建完成",
+        "wiki.rebuild.failed": "重建失败",
+        "wiki.rebuild.hint": "重跑 T0 确定性骨架（秒级；T1 语义富化请用 CLI --t1）。注意：富化页会退回骨架，语义段需重新生成",
+        "wiki.rebuild.modules": "个模块",
+        "wiki.rebuild.pages": "页",
+        "wiki.empty.noRepo": "还没有登记的仓库。先在仓库目录里跑 `dsh-mneme-choro <仓库路径> --apply` 生成骨架页并登记，然后回到这里。",
+        "wiki.empty.disabled": "chorography（仓库地志）未启用：在「设置」里打开「仓库地志」后重启 DSH 生效。",
+        "wiki.empty.pickRepo": "已登记多个仓库，选一个：",
+        "wiki.search.placeholder": "在页面里检索…",
+        "wiki.state.loading": "加载中…",
+        "wiki.state.pickPage": "从左侧选一个模块页。",
+        "wiki.state.pageMissing": "索引还在、磁盘页面缺失：在仓库目录重跑一次 `dsh-mneme-choro <仓库路径> --apply` 即可重建。",
+        "wiki.state.unavailable": "chorography 查询装配不可用（宿主环境缺件）。",
+        "wiki.state.error": "加载失败",
+        "wiki.tree.title": "模块",
         "memory.tab.all": "全部",
         "memory.tab.preference": "偏好",
         "memory.tab.project": "项目",
@@ -322,16 +353,21 @@ window.__ModuleLoader__.load({
         "memory.settings.profileSaved": "画像已保存",
         "memory.settings.profileExtract": "从记忆提取草稿",
         "memory.settings.profileExtracting": "正在提取…",
-        "memory.settings.profileExtractHint": "会花一次模型调用，只在你点这个按钮时发生；提取出来的是草稿，不采用就不进库，你手写的画像也不会被覆盖。",
+        "memory.settings.profileExtractHint": "会花一次模型调用，只在你点这个按钮时发生；提取出来的是草稿副本，只在这里展示——不会写进记忆库，也不会动你自己手写的「用户画像」。想留下它，点「复制草稿」。",
         "memory.settings.profileExtractDisabled": "没有提取：功能开关里的「画像提取草稿」还没打开。",
         "memory.settings.profileExtractEmpty": "库里没有可用的记忆条目，这次没有能提炼的内容（空输入下硬写一段画像只会是编的）。",
         "memory.settings.profileExtractNoRoute": "没有可用的模型：先在宿主里选一个默认模型（或在配置里填 dreamProvider / dreamModel），再点一次。",
         "memory.settings.profileSaveFailed": "画像没存进去",
         "memory.settings.profileExtractFailed": "提取没成：模型没按格式返回，或这次调用失败了。你现有的画像一个字都没被改动。",
-        "memory.settings.profileDraftTitle": "草稿（还没保存）",
+        "memory.settings.profileDraftTitle": "草稿副本（不会自动保存）",
         "memory.settings.profileDraftRows": "依据记忆条数",
+        "memory.status.entitiesSampled": "分类计数只统计最近 500 个实体；总数是全库",
+        "memory.status.entitiesUnknown": "总数读不到；下面是最近 500 个实体的分类计数",
         "memory.settings.profileDraftTruncated": "条目较多，这次只读了前面一部分",
-        "memory.settings.profileDraftApply": "采用为画像",
+        "memory.settings.profileDraftCopy": "复制草稿",
+        "memory.settings.profileDraftCopied": "已复制",
+        "memory.settings.profileDraftCopyHint": "「用户画像」那一栏只由你自己填写；要把它写进去，请粘贴后自己点保存。",
+        "memory.settings.profileDraftCopyFailed": "复制没成功：请选中上面的草稿手动复制。",
         "memory.settings.profileDraftDiscard": "丢弃草稿",
         "memory.settings.persona": "人格定义（beta）",
         "memory.settings.personaHint": "给这位 Agent 一张角色卡：名字、性格、回复要求。开关打开且下方「人格定义」总闸开启时，每轮对话都会注入。",
@@ -363,12 +399,55 @@ window.__ModuleLoader__.load({
         "memory.settings.personaViewSourceNone": "按当前寻址口径，这个身份不会注入任何人格——默认卡只兜「解析不到会话身份」的会话。",
         "memory.settings.personaViewGateOff": "总闸「人格定义（beta）」现在是关的：下面这段里不会出现人格，只有画像与规则。",
         "memory.settings.personaViewRefresh": "刷新预览",
+        "memory.settings.factsTitle": "自动事实（Agent 眼中的你）",
+        "memory.settings.factsHint": "Agent 在巩固（dream）后从新记忆里提炼的「对你的了解」，按会话身份分卡，与人格卡同域，注在预览里手填画像之后。这里可以逐条修正；删除只是归档，随时可恢复。你自己填的用户画像不受影响。",
+        "memory.settings.factsEmpty": "这张卡还没有事实。有新的对话记忆并跑过巩固后，Agent 对你的了解会出现在这里；也可以在下面手动添加。",
+        "memory.settings.factsUnavailable": "读不到事实（请求失败或后端版本过旧）。这里不显示猜测的内容。",
+        "memory.settings.factsAddPlaceholder": "例如：用户偏好简洁直给的回答",
+        "memory.settings.factsAdd": "添加事实",
+        "memory.settings.factsRowEdit": "编辑这条事实",
+        "memory.settings.factsRowSave": "保存",
+        "memory.settings.factsRowCancel": "取消",
+        "memory.settings.factsRowDelete": "删除这条事实（归档，可恢复）",
+        "memory.settings.factsApplyDone": "事实已更新",
+        "memory.settings.factsApplyError": "没存进去：请求失败了，请再试一次。",
+        "memory.settings.factsApplyFailures": "{n} 条没存进去",
+        "memory.settings.factsApplyDups": "跳过 {n} 条重复",
+        "memory.settings.factsGateOff": "功能开关里的「自动事实」没开：dream 轮不会自动维护这份清单，但这里的增改与下面的手动更新照常可用。",
+        "memory.settings.factsRun": "立即更新",
+        "memory.settings.factsRunning": "正在更新…",
+        "memory.settings.factsRunOk": "已更新 {n} 条事实",
+        "memory.settings.factsRunNoop": "没有新记忆，事实已是最新",
+        "memory.settings.factsRunDisabled": "功能开关里的「自动事实」还没打开，先到功能开关区打开它。",
+        "memory.settings.factsRunNoRoute": "没有可用的模型：先在宿主里选一个默认模型（或在配置里填 dreamProvider / dreamModel），再点一次。",
+        "memory.settings.factsRunFailed": "更新没成：模型没按格式返回，或这次调用失败了。稍后可重试。",
+        "memory.settings.factsJournalTitle": "最近变更",
+        "memory.settings.factsJournalEmpty": "还没有变更记录",
+        "memory.settings.factsOpAdd": "新增",
+        "memory.settings.factsOpUpdate": "修改",
+        "memory.settings.factsOpArchive": "归档",
+        "memory.settings.factsActorAuto": "自动",
+        "memory.settings.factsActorManual": "手动",
+        "memory.settings.factsRunLast": "最近一轮：",
+        "memory.settings.factsRunCounts": "输入 {input} 条 · 应用 {ops} 项操作",
+        "memory.settings.factsRunStatusOk": "成功",
+        "memory.settings.factsRunStatusNoop": "无变更",
+        "memory.settings.factsRunStatusFailed": "失败",
         "memory.features.personaEnabled": "人格定义（beta）",
         "memory.features.personaEnabled.hint": "把「设置 → 个性化」里的人格卡注入到每轮对话。默认关（beta）；总闸与人格卡内的开关同时打开才生效。",
         "memory.features.personaStrictAddressing": "严格人格寻址",
         "memory.features.personaStrictAddressing.hint": "开：会话身份没有对应人格卡、或那张卡被关掉时，就不注入人格——默认卡只兜「解析不到会话身份」的会话。宿主里跑着自带身份的 bot（DS Bot 那类）时关掉这种兜底，免得两句「你是谁」撞在同一轮。默认关 = 未命中就落默认卡（历史行为）。",
         "memory.features.profileExtractEnabled": "画像提取草稿",
-        "memory.features.profileExtractEnabled.hint": "打开「设置 → 个性化 → 用户画像」里的「从记忆提取草稿」按钮：读一批活跃记忆、花一次模型调用，产一段「助手眼中的用户」草稿。草稿要你点「采用」才会写进画像，绝不自动覆盖你手写的原文。轻量档预设关（用户显式勾选仍然赢）。",
+        "memory.features.profileExtractEnabled.hint": "打开「设置 → 个性化 → Agent 眼中的你」卡上的「从记忆提取草稿」按钮：读一批活跃记忆、花一次模型调用，产一段「助手眼中的用户」草稿。草稿只在那张卡上展示副本，可一键复制，不会写进记忆库、也不会覆盖你自己填的「用户画像」。轻量档预设关（用户显式勾选仍然赢）。",
+        "memory.features.profileFactsEnabled": "自动事实",
+        "memory.features.profileFactsEnabled.hint": "每次 dream（巩固）轮后，把这一窗口里沉淀的新记忆再读一遍，按会话身份卡维护一份「Agent 眼中的你」事实清单（设置 → 个性化 → 自动事实），注入在手填画像之后。事实住独立的表，不会覆盖你自己填的「用户画像」；面板上可逐条修正或删除（删除=归档，可恢复）。轻量档预设关（用户显式勾选仍然赢）。",
+        "memory.features.chorographyEnabled": "仓库地志（chorography）",
+        "memory.features.chorographyEnabled.hint": "读一遍仓库写成一份带页码的志书：确定性骨架零模型、可以随时重建；语义段由 CLI 的 headless 会话逐模块补。打开后有四个入口——模型侧三个只读工具、面板「仓库地志」浏览页、每轮的开局提纲注入、/choro 命令。关着时它们全部不存在（模型工具列表里根本没有，注入块不渲染，/choro 不注册）。默认关。",
+        "memory.features.chorographyInject": "开局注入档位",
+        "memory.features.chorographyInject.hint": "每轮往上下文里塞地志提纲的份量：light 只列文件数最多的 6 个模块（约 8 行）、full 列全部模块、off 不注入（工具与面板页仍可用）。只注模块名 / 文件数 / 页状态 / 页相对路径，不含正文；正文要模型自己用 choro_read_page 取。轻量档预设压成 off。",
+        "memory.features.chorographyInject.off": "off（不注入）",
+        "memory.features.chorographyInject.light": "light（前 6 个模块）",
+        "memory.features.chorographyInject.full": "full（全部模块）",
         "memory.settings.rules": "规则",
         "memory.settings.rulesHint": "给 Agent 立下必须遵守的规矩，随时增删，下一轮即生效。",
         "memory.settings.ruleAdd": "添加规则",
@@ -390,6 +469,7 @@ window.__ModuleLoader__.load({
         "memory.explorer.tabSettings": "设置",
         "memory.explorer.tabStatus": "状态",
         "memory.entities.count": "{n} 个实体",
+      "memory.entities.countSampled": "列表只列最近 {shown} 个；上方总数是全库",
         "memory.entities.pick": "从左侧选择一个实体，查看它的属性与关系",
         // 搜索框有字但一条没筛出来时用它；与 entities.none（库里真没实体）分开，
         // 否则「暂无实体」会把打错一个字误导成「你还没开抽取」。
@@ -535,6 +615,15 @@ window.__ModuleLoader__.load({
         "memory.settings.mcp.snippet": "{ \"mcpServers\": { \"dsh-mneme\": { \"command\": \"dsh-mneme-mcp\", \"env\": { \"DSH_MNEME_TOKEN\": \"<外部访问 API 的 token>\" } } } }",
         "memory.settings.mcp.copy": "复制",
         "memory.settings.mcp.copied": "已复制",
+        "memory.settings.configKeys.title": "配置键覆盖面",
+        "memory.settings.configKeys.desc": "配置文件里的键，面板能改多少、哪些只能手改。只列键名，不显示任何值。",
+        "memory.settings.configKeys.summary": "schema 里共 {schema} 个键：面板能改 {panel} 个，{file} 个只能改配置文件，另有 {undefaulted} 个登记了却没有默认值。",
+        "memory.settings.configKeys.fileOnlyHead": "只能改配置文件（{n} 个）",
+        "memory.settings.configKeys.undefaultedHead": "面板登记了、但运行时没有默认值（{n} 个）",
+        "memory.settings.configKeys.undefaultedHint": "这些键在白名单里，所以面板上有输入框；但 schema 没给默认值，留空时「当前生效值」里就没有它。填一个值才会生效。",
+        "memory.settings.configKeys.show": "展开清单",
+        "memory.settings.configKeys.hide": "收起清单",
+        "memory.settings.configKeys.loadFailed": "没能取到这份清单（接口暂时不可用）——这不等于「没有只能改文件的键」。",
         "memory.settings.mcp.hint": "数据面走「外部访问 API」（默认 127.0.0.1:8790，Bearer），token 就是上面那张；可用 DSH_MNEME_URL / DSH_MNEME_TOKEN 环境变量或 ~/.dsh-mneme/cli.json 覆盖。command 需在 PATH 上（随 @modusensus/dsh-mneme 安装自带）。",
         "memory.settings.extapi.savedHint": "已保存，重启 DSH 后生效",
         "memory.settings.extapi.invalidPort": "端口需为 1-65535 的数字",
@@ -814,6 +903,19 @@ window.__ModuleLoader__.load({
         "memory.explorer.imported": "已合并 {n} 条编辑",
         "memory.explorer.importFailed": "导入失败",
         "memory.explorer.importNoFile": "请先选择文件",
+        "memory.explorer.bootstrap": "从目录引导…",
+        "memory.explorer.bootstrapTitle": "从目录引导",
+        "memory.explorer.bootstrapHint": "读这个目录里的确定性产物（脚本命令、README、贡献规范、CI 工作流、顶层结构、最近提交），一条规则一条记忆。不调用模型，重复执行只会合并更新、不会重复入库。",
+        "memory.explorer.bootstrapDir": "目录路径",
+        "memory.explorer.bootstrapConfirm": "开始引导",
+        "memory.explorer.bootstraping": "引导中…",
+        "memory.explorer.bootstrapDone": "新建 {n} 条、并入 {m} 条",
+        "memory.explorer.bootstrapNoDir": "请先填写目录路径",
+        "memory.explorer.bootstrapFailed": "引导失败",
+        "memory.explorer.bootstrapErr.missing-dir": "没给目录路径",
+        "memory.explorer.bootstrapErr.dir-not-found": "这个路径不存在",
+        "memory.explorer.bootstrapErr.not-a-directory": "这个路径不是目录",
+        "memory.explorer.bootstrapErr.bootstrap-unavailable": "当前装配下这条能力没接线",
         "memory.explorer.sharePack": "分享记忆包…",
         "memory.explorer.shareTitle": "分享记忆包",
         "memory.explorer.shareHint": "把本机活跃记忆打成一个可外发的包：密钥/PII 整条不发，本机路径抹成 ~，归档与遗忘的不进。",
@@ -1096,6 +1198,13 @@ window.__ModuleLoader__.load({
         "memory.status.token.heat": "8 周热力 · 每天花了多少",
         "memory.status.token.heatLess": "少",
         "memory.status.token.heatMore": "多",
+        "memory.status.token.sink": "8 周沉淀 · 进来的 vs 稳住的",
+        "memory.status.token.sinkAdded": "新增",
+        "memory.status.token.sinkMerged": "巩固",
+        "memory.status.token.sinkArchived": "归档",
+        "memory.status.token.sinkGap": "巩固/新增",
+        "memory.status.token.sinkEmpty": "最近还没有记录",
+        "memory.status.token.sinkFoot": "巩固按去重记录数计，同一条被多轮合并只算一次",
         "memory.status.token.last7": "近 7 天",
         "memory.status.token.meterOnly": "（只计量）",
         "memory.status.token.detail": "详细状态卡（原「库内一览 / 后台运转」9 张，点击展开）",
@@ -1110,6 +1219,24 @@ window.__ModuleLoader__.load({
       en: {
         "memory.panel.empty": "No memories yet",
         "memory.panel.open": "Memory",
+        "wiki.panel.open": "Repo Atlas",
+        "wiki.rebuild": "Rebuild skeleton",
+        "wiki.rebuilding": "Rebuilding…",
+        "wiki.rebuild.done": "Rebuilt",
+        "wiki.rebuild.failed": "Rebuild failed",
+        "wiki.rebuild.hint": "Re-runs the deterministic T0 skeleton (seconds; T1 semantic enrichment stays on the CLI --t1). Note: enriched pages fall back to skeleton — regenerate semantics afterwards",
+        "wiki.rebuild.modules": "modules",
+        "wiki.rebuild.pages": "pages",
+        "wiki.empty.noRepo": "No repository registered yet. Run `dsh-mneme-choro <repo-path> --apply` inside the repository to generate skeleton pages and register it, then come back here.",
+        "wiki.empty.disabled": "chorography (Repo Atlas) is disabled: turn it on under Settings and restart DSH to apply.",
+        "wiki.empty.pickRepo": "Multiple repositories registered — pick one:",
+        "wiki.search.placeholder": "Search pages…",
+        "wiki.state.loading": "Loading…",
+        "wiki.state.pickPage": "Pick a module page from the tree.",
+        "wiki.state.pageMissing": "Index exists but the page file is missing: re-run `dsh-mneme-choro <repo-path> --apply` to rebuild.",
+        "wiki.state.unavailable": "chorography queries are unavailable (host wiring missing).",
+        "wiki.state.error": "Failed to load",
+        "wiki.tree.title": "Modules",
         "memory.tab.all": "All",
         "memory.tab.preference": "Preferences",
         "memory.tab.project": "Projects",
@@ -1131,16 +1258,21 @@ window.__ModuleLoader__.load({
         "memory.settings.profileSaved": "Profile saved",
         "memory.settings.profileExtract": "Draft from memory",
         "memory.settings.profileExtracting": "Extracting…",
-        "memory.settings.profileExtractHint": "Costs one model call, and only when you press this button. The result is a draft: nothing is stored until you apply it, and your hand-written profile is never overwritten.",
+        "memory.settings.profileExtractHint": "Costs one model call, and only when you press this button. The result is a draft copy shown here only — it is never written to the memory store and never touches the User Profile you wrote yourself. Press “Copy draft” to keep it.",
         "memory.settings.profileExtractDisabled": "Nothing extracted: the “Profile draft from memory” feature switch is still off.",
         "memory.settings.profileExtractEmpty": "No usable memory entries in the store, so there was nothing to draft from (writing a profile out of an empty input would only be invention).",
         "memory.settings.profileExtractNoRoute": "No model available: pick a default model in the host (or set dreamProvider / dreamModel), then try again.",
         "memory.settings.profileSaveFailed": "Profile was not saved",
         "memory.settings.profileExtractFailed": "Extraction failed: the model did not return the required shape, or the call errored. Your existing profile is untouched.",
-        "memory.settings.profileDraftTitle": "Draft (not saved)",
+        "memory.settings.profileDraftTitle": "Draft copy (never saved automatically)",
         "memory.settings.profileDraftRows": "Based on entries",
+        "memory.status.entitiesSampled": "Per-type counts cover the newest 500 entities only; the total is the whole library",
+        "memory.status.entitiesUnknown": "Total unavailable; the counts below cover the newest 500 entities",
         "memory.settings.profileDraftTruncated": "many entries — only the first batch was read",
-        "memory.settings.profileDraftApply": "Apply as profile",
+        "memory.settings.profileDraftCopy": "Copy draft",
+        "memory.settings.profileDraftCopied": "Copied",
+        "memory.settings.profileDraftCopyHint": "The User Profile field is yours to write; to keep this text, paste it there and save it yourself.",
+        "memory.settings.profileDraftCopyFailed": "Copy failed: select the draft above and copy it manually.",
         "memory.settings.profileDraftDiscard": "Discard draft",
         "memory.settings.persona": "Persona (beta)",
         "memory.settings.personaHint": "Give this agent a character card: name, personality, reply style. Injected every turn when the toggle below and the \"Persona\" master switch are both on.",
@@ -1172,12 +1304,55 @@ window.__ModuleLoader__.load({
         "memory.settings.personaViewSourceNone": "Under the current addressing mode this identity injects no persona at all — the default card only covers sessions with no resolvable identity.",
         "memory.settings.personaViewGateOff": "The master switch “Persona (beta)” is off: the block below contains profile and rules only.",
         "memory.settings.personaViewRefresh": "Refresh preview",
+        "memory.settings.factsTitle": "Auto facts (you, as the agent sees you)",
+        "memory.settings.factsHint": "What the agent learned about you, distilled from new memories after each dream run — split into cards by session identity (same domain as persona cards) and injected after your handwritten profile in the preview. Fix entries here one by one; deleting only archives a fact and can be undone. The User Profile you wrote yourself is never touched.",
+        "memory.settings.factsEmpty": "No facts on this card yet. After new conversation memories go through a dream run, what the agent picked up about you shows up here; you can also add one below.",
+        "memory.settings.factsUnavailable": "Could not read the facts (request failed or backend too old). Nothing is guessed here.",
+        "memory.settings.factsAddPlaceholder": "e.g. The user prefers short, direct answers",
+        "memory.settings.factsAdd": "Add fact",
+        "memory.settings.factsRowEdit": "Edit this fact",
+        "memory.settings.factsRowSave": "Save",
+        "memory.settings.factsRowCancel": "Cancel",
+        "memory.settings.factsRowDelete": "Delete this fact (archived, restorable)",
+        "memory.settings.factsApplyDone": "Facts updated",
+        "memory.settings.factsApplyError": "Not saved: the request failed. Please try again.",
+        "memory.settings.factsApplyFailures": "{n} not saved",
+        "memory.settings.factsApplyDups": "skipped {n} duplicates",
+        "memory.settings.factsGateOff": "The “Auto facts” feature switch is off: dream runs will not maintain this list, but editing here and the manual update below keep working.",
+        "memory.settings.factsRun": "Update now",
+        "memory.settings.factsRunning": "Updating…",
+        "memory.settings.factsRunOk": "Updated {n} facts",
+        "memory.settings.factsRunNoop": "No new memories — facts are already up to date",
+        "memory.settings.factsRunDisabled": "The “Auto facts” feature switch is off; turn it on in the feature switches section first.",
+        "memory.settings.factsRunNoRoute": "No model available: pick a default model in the host (or set dreamProvider / dreamModel), then try again.",
+        "memory.settings.factsRunFailed": "Update failed: the model did not return the required shape, or the call errored. You can retry later.",
+        "memory.settings.factsJournalTitle": "Recent changes",
+        "memory.settings.factsJournalEmpty": "No changes recorded yet",
+        "memory.settings.factsOpAdd": "Add",
+        "memory.settings.factsOpUpdate": "Edit",
+        "memory.settings.factsOpArchive": "Archive",
+        "memory.settings.factsActorAuto": "auto",
+        "memory.settings.factsActorManual": "manual",
+        "memory.settings.factsRunLast": "Last run: ",
+        "memory.settings.factsRunCounts": "input {input} · applied {ops} ops",
+        "memory.settings.factsRunStatusOk": "ok",
+        "memory.settings.factsRunStatusNoop": "no change",
+        "memory.settings.factsRunStatusFailed": "failed",
         "memory.features.personaEnabled": "Persona (beta)",
         "memory.features.personaEnabled.hint": "Inject the persona card (Settings → Personalization) into every turn. Off by default (beta); both this switch and the card's own toggle must be on.",
         "memory.features.personaStrictAddressing": "Strict persona addressing",
         "memory.features.personaStrictAddressing.hint": "On: when a session's identity has no persona card — or that card is switched off — no persona is injected, so the default card only covers sessions with no resolvable identity. Turn this on when the host runs a bot that brings its own identity (DS Bot and friends), otherwise two \"you are ...\" claims land in the same turn. Off (default): unresolved identities fall back to the default card, as before.",
         "memory.features.profileExtractEnabled": "Profile draft from memory",
-        "memory.features.profileExtractEnabled.hint": "Adds the \"Draft from memory\" button to Settings → Personalization → profile: reads a batch of active memories, spends one model call, and returns an \"as the assistant sees them\" draft. Nothing is written until you press Apply, so your hand-written profile is never overwritten automatically. Off in the lightweight preset (an explicit choice still wins).",
+        "memory.features.profileExtractEnabled.hint": "Adds the \"Draft from memory\" button to the \"You in the agent's eyes\" card under Settings → Personalization: reads a batch of active memories, spends one model call, and returns an \"as the assistant sees them\" draft. The draft is only shown there as a copy you can copy out — it is never written to the memory store and never overwrites the User Profile you wrote yourself. Off in the lightweight preset (an explicit choice still wins).",
+        "memory.features.profileFactsEnabled": "Auto facts",
+        "memory.features.profileFactsEnabled.hint": "After each dream (consolidation) run, the memories settled in that window are read once more to maintain a per-identity-card list of facts the agent holds about you (Settings → Personalization → Auto facts), injected after the handwritten profile. Facts live in their own tables and never overwrite the User Profile you wrote yourself; any fact can be fixed or removed in the panel (removing = archiving, restorable). Off in the lightweight preset (an explicit choice still wins).",
+        "memory.features.chorographyEnabled": "Repo atlas (chorography)",
+        "memory.features.chorographyEnabled.hint": "Reads a repository once and writes it up as a paginated atlas: the deterministic skeleton costs no model and can be rebuilt any time; the semantic sections are added per module by a headless session in the CLI. Turning it on enables four entry points — three read-only tools for the model, the atlas panel page, the per-turn outline injection, and the /choro command. With it off none of them exist (the tools are absent from the model's tool list, the injection block is not rendered, /choro is not registered). Off by default.",
+        "memory.features.chorographyInject": "Opening injection tier",
+        "memory.features.chorographyInject.hint": "How much of the atlas outline goes into context every turn: light lists the six modules with the most files (about 8 lines), full lists every module, off injects nothing (tools and the panel page still work). Only module name / file count / page status / page path are injected, never page bodies — the model fetches those with choro_read_page. The lightweight preset forces off.",
+        "memory.features.chorographyInject.off": "off (no injection)",
+        "memory.features.chorographyInject.light": "light (top 6 modules)",
+        "memory.features.chorographyInject.full": "full (all modules)",
         "memory.settings.rules": "Rules",
         "memory.settings.rulesHint": "Rules the agent must follow — add or remove anytime, effective next turn.",
         "memory.settings.ruleAdd": "Add Rule",
@@ -1199,6 +1374,7 @@ window.__ModuleLoader__.load({
         "memory.explorer.tabSettings": "Settings",
         "memory.explorer.tabStatus": "Status",
         "memory.entities.count": "{n} entities",
+      "memory.entities.countSampled": "The list shows the newest {shown} only; the total above is the whole library",
         "memory.entities.pick": "Select an entity to see its attributes and relations",
         "memory.entities.noMatch": "No entities match that search — try another word",
         "memory.entities.none": "No entities yet — turn on entity extraction and people / projects / concepts will accumulate here",
@@ -1338,6 +1514,15 @@ window.__ModuleLoader__.load({
         "memory.settings.mcp.snippet": "{ \"mcpServers\": { \"dsh-mneme\": { \"command\": \"dsh-mneme-mcp\", \"env\": { \"DSH_MNEME_TOKEN\": \"<token from External API above>\" } } } }",
         "memory.settings.mcp.copy": "Copy",
         "memory.settings.mcp.copied": "Copied",
+        "memory.settings.configKeys.title": "Config key coverage",
+        "memory.settings.configKeys.desc": "How many config-file keys the panel can change, and which ones are file-only. Key names only — no values are shown.",
+        "memory.settings.configKeys.summary": "The schema has {schema} keys: the panel can change {panel}, {file} are file-only, and {undefaulted} are registered without a runtime default.",
+        "memory.settings.configKeys.fileOnlyHead": "File-only ({n})",
+        "memory.settings.configKeys.undefaultedHead": "Registered for the panel but has no runtime default ({n})",
+        "memory.settings.configKeys.undefaultedHint": "These keys are on the whitelist, so the panel shows an input for them, but the schema gives no default — while unset they are absent from the effective snapshot. Set a value for them to take effect.",
+        "memory.settings.configKeys.show": "Show the list",
+        "memory.settings.configKeys.hide": "Hide the list",
+        "memory.settings.configKeys.loadFailed": "Couldn't load this list (endpoint unavailable) — that is not the same as \"no file-only keys\".",
         "memory.settings.mcp.hint": "Data plane is the external API (default 127.0.0.1:8790, Bearer) — the token is the one above; override with DSH_MNEME_URL / DSH_MNEME_TOKEN env vars or ~/.dsh-mneme/cli.json. The command must be on PATH (installed with @modusensus/dsh-mneme).",
         "memory.settings.extapi.savedHint": "Saved. Takes effect after restarting DSH",
         "memory.settings.extapi.invalidPort": "Port must be a number between 1 and 65535",
@@ -1600,6 +1785,19 @@ window.__ModuleLoader__.load({
         "memory.explorer.imported": "Merged {n} edits",
         "memory.explorer.importFailed": "Import failed",
         "memory.explorer.importNoFile": "Choose a file first",
+        "memory.explorer.bootstrap": "Bootstrap from a directory…",
+        "memory.explorer.bootstrapTitle": "Bootstrap from a directory",
+        "memory.explorer.bootstrapHint": "Reads the deterministic artifacts there (script commands, README, contributing rules, CI workflows, top-level layout, recent commits) — one rule, one memory. No model call; running it again merges instead of duplicating.",
+        "memory.explorer.bootstrapDir": "Directory path",
+        "memory.explorer.bootstrapConfirm": "Bootstrap",
+        "memory.explorer.bootstraping": "Bootstrapping…",
+        "memory.explorer.bootstrapDone": "Created {n}, merged {m}",
+        "memory.explorer.bootstrapNoDir": "Enter a directory path first",
+        "memory.explorer.bootstrapFailed": "Bootstrap failed",
+        "memory.explorer.bootstrapErr.missing-dir": "No directory path was given",
+        "memory.explorer.bootstrapErr.dir-not-found": "That path does not exist",
+        "memory.explorer.bootstrapErr.not-a-directory": "That path is not a directory",
+        "memory.explorer.bootstrapErr.bootstrap-unavailable": "This capability is not wired in the current assembly",
         "memory.explorer.sharePack": "Share memories…",
         "memory.explorer.shareTitle": "Memory share pack",
         "memory.explorer.shareHint": "Pack your active memories for someone else: rows holding secrets are dropped whole, home paths become ~, archived and forgotten rows stay out.",
@@ -1882,6 +2080,13 @@ window.__ModuleLoader__.load({
         "memory.status.token.heat": "8-week heat · daily spend",
         "memory.status.token.heatLess": "less",
         "memory.status.token.heatMore": "more",
+        "memory.status.token.sink": "8-week consolidation · in vs kept",
+        "memory.status.token.sinkAdded": "added",
+        "memory.status.token.sinkMerged": "consolidated",
+        "memory.status.token.sinkArchived": "archived",
+        "memory.status.token.sinkGap": "consolidated/added",
+        "memory.status.token.sinkEmpty": "nothing recorded yet",
+        "memory.status.token.sinkFoot": "consolidated counts distinct records; re-merging the same record counts once",
         "memory.status.token.last7": "last 7 days",
         "memory.status.token.meterOnly": "(metered only)",
         "memory.status.token.detail": "Detailed status cards (the original 9 under Library / Background activity, click to expand)",
@@ -1968,10 +2173,12 @@ window.__ModuleLoader__.load({
       // / -warning / -success / -warn / --dsw-alias-border），
       // 于是长年吃的是写在 fallback 里的硬编码色。这里按宿主真实 token 现算一组
       // 面板自有语义色：混色基准全是宿主 token，宿主换肤时跟着走，不引入新字面量。
-      // 必须挂四个根——面板不只长在 .mneme-x 下：记忆库 sheet portal 到 body
+      // 必须挂满五个根——面板不只长在 .mneme-x 下：记忆库 sheet portal 到 body
       // （.mneme-overlay）、侧边栏入口在宿主插槽（.mneme-triggerwrap）、顶部入口
-      // portal 到宿主侧边栏（.mneme-topentry）。
-      ".mneme-x,.mneme-overlay,.mneme-triggerwrap,.mneme-topentry{" +
+      // portal 到宿主侧边栏（.mneme-topentry）。第五个根是宿主内整页面板
+      // （.mneme-panel）配套的侧栏图标容器：那颗图标长在宿主的 panelGlyph 里，
+      // 不在 .mneme-x 的子树里，而它右上角的未处理冲突 badge 要吃 --mneme-danger。
+      ".mneme-x,.mneme-overlay,.mneme-triggerwrap,.mneme-topentry,.mneme-paneliglyph{" +
         "--mneme-fg-dim:color-mix(in srgb,var(--dsw-alias-label-primary) 60%,transparent);" +
         "--mneme-graphic-dim:color-mix(in srgb,var(--dsw-alias-label-primary) 50%,transparent);" +
         "--mneme-accent:color-mix(in srgb,var(--dsw-alias-state-business-primary) 85%,var(--dsw-alias-label-primary));" +
@@ -2011,6 +2218,9 @@ window.__ModuleLoader__.load({
       // 低于详情抽屉(6)，下拉菜单/导入对话框随容器整体上浮。
       ".mneme-xtools{position:absolute;right:14px;top:50%;transform:translateY(-50%);display:flex;align-items:center;gap:8px;padding:0;z-index:3}",
       ".mneme-xcount{flex:none;font-size:12px;line-height:16px;color:var(--mneme-fg-dim);white-space:nowrap}",
+    // 目录计数下面那行小字：说清「总数是全库、列表只列最近 N 个」，两个口径
+    // 不一样不能只靠一个数字冒充（实体页此前就吃到这个亏）。
+    ".mneme-xcountnote{font-size:11px;line-height:15px;color:var(--mneme-fg-dim);white-space:nowrap}",
       // --- three-column browse layout: hairline separators, no outer box ---
       ".mneme-xmain{flex:1;min-height:0;display:flex;flex-direction:row;overflow:hidden}",
       ".mneme-xside{flex:none;width:264px;min-width:0;min-height:0;overflow-y:auto;overflow-x:hidden;padding:16px 14px;border-right:1px solid var(--dsw-alias-border-l2);box-sizing:border-box;display:flex;flex-direction:column;gap:8px}",
@@ -2164,6 +2374,62 @@ window.__ModuleLoader__.load({
       ".mneme-set-cmddesc{font-size:12px;line-height:17px;color:var(--mneme-fg-dim);margin-top:1px;word-break:break-word}",
       // --- settings sub-view ---
       ".mneme-set{flex:1;min-height:0;overflow-y:auto;padding:8px 24px 48px;box-sizing:border-box}",
+      // --- 宿主中列整页面板（sidebar.panellist + main 成对座位）---
+      // 宿主把 main 槽渲染在三列 grid 的中列里，那一层只给了 min-width:0 与
+      // overflow:hidden，没有任何尺寸约束——注册者必须自己铺满并自管滚动，
+      // 否则内容会撑破中列（右栏打开时中列更窄，宽度还会变）。
+      ".mneme-panel{box-sizing:border-box;flex:1;min-width:0;min-height:0;width:100%;height:100%;display:flex;flex-direction:column;overflow:hidden;background:var(--dsw-alias-bg-layer-1)}",
+      // 侧栏图标容器：badge 用绝对定位挂在它上面。宿主 panelRow 没有
+      // overflow:hidden，所以 -3px 的偏移不会被裁；这里的 position:relative
+      // 只提供定位上下文，不接管尺寸（由宿主的 panelGlyph 决定）。
+      ".mneme-paneliglyph{position:relative;display:inline-flex;align-items:center;justify-content:center}",
+      // --- chorography 面板（仓库地志）：顶栏检索 + 左树右文。颜色全部引用
+      // 既有语义层（--dsw-alias-* 正文/边框、--mneme-fg-dim 弱化），不引入新
+      // 字面量色——contrast.test.js 会重算每一条 color 声明。内容渲染挂在
+      // .mneme-panel 根内（#562 的中列整页容器），不新增渲染根。
+      ".mneme-wikibar{flex:none;display:flex;align-items:center;gap:10px;padding:10px 16px;border-bottom:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1)}",
+      ".mneme-wikirepo{flex:none;max-width:40%;font-size:13.5px;font-weight:600;color:var(--dsw-alias-label-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}",
+      // 重建骨架按钮（收尾档 P34）与回执行：语义色层，无新字面量色。
+      ".mneme-wikibtn{flex:none;height:28px;padding:0 10px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-base,transparent);color:var(--dsw-alias-label-primary);cursor:pointer;font-family:inherit;font-size:12px;line-height:26px;transition:border-color .12s}",
+      ".mneme-wikibtn:hover{border-color:var(--dsw-alias-state-business-primary)}",
+      ".mneme-wikibtn:disabled{opacity:.5;cursor:default}",
+      ".mneme-wikirebuildnote{flex:1;min-width:0;font-size:11.5px;line-height:16px;color:var(--mneme-fg-dim);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}",
+      ".mneme-wikisearch{flex:1;min-width:0;height:28px;padding:0 10px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-base,transparent);color:var(--dsw-alias-label-primary);font-family:inherit;font-size:12.5px;outline:none;transition:border-color .12s}",
+      ".mneme-wikisearch:focus{border-color:var(--dsw-alias-state-business-primary);box-shadow:0 0 0 3px color-mix(in srgb,var(--dsw-alias-state-business-primary) 15%,transparent)}",
+      ".mneme-wikibody{flex:1;min-height:0;display:flex;overflow:hidden}",
+      ".mneme-wikitree{flex:none;width:232px;overflow-y:auto;border-right:1px solid var(--dsw-alias-border-l1);padding:10px 6px}",
+      ".mneme-wikitreeitem{display:block;width:100%;text-align:left;border:none;background:none;cursor:pointer;font-family:inherit;font-size:12.5px;line-height:18px;color:var(--dsw-alias-label-secondary);padding:5px 8px;border-radius:7px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:background .12s}",
+      ".mneme-wikitreeitem:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
+      ".mneme-wikitreeitem.mneme-active{background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary);font-weight:500}",
+      ".mneme-wikipage{flex:1;min-width:0;overflow-y:auto;padding:18px 22px 44px;color:var(--dsw-alias-label-primary)}",
+      ".mneme-wikipage h2,.mneme-wikipage h3,.mneme-wikipage h4,.mneme-wikipage h5{margin:18px 0 8px;color:var(--dsw-alias-label-primary);line-height:1.35}",
+      ".mneme-wikipage h2{font-size:17px;border-bottom:1px solid var(--dsw-alias-border-l1);padding-bottom:6px}",
+      ".mneme-wikipage h3{font-size:15px}",
+      ".mneme-wikipage h4,.mneme-wikipage h5{font-size:13.5px}",
+      ".mneme-wikipage p{margin:6px 0;font-size:13px;line-height:21px;color:var(--dsw-alias-label-secondary)}",
+      ".mneme-wikipage ul,.mneme-wikipage ol{margin:6px 0;padding-left:22px}",
+      ".mneme-wikipage li{font-size:13px;line-height:20px;color:var(--dsw-alias-label-secondary);margin:3px 0}",
+      ".mneme-wikipre{margin:10px 0;padding:10px 12px;border:1px solid var(--dsw-alias-border-l1);border-radius:8px;background:var(--dsw-alias-bg-layer-2,var(--dsw-alias-bg-layer-1));overflow-x:auto;font-size:12px;line-height:18px;color:var(--dsw-alias-label-primary);white-space:pre}",
+      ".mneme-wikicode{font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:12px;color:var(--dsw-alias-label-primary);background:var(--dsw-alias-interactive-bg-active);border-radius:4px;padding:1px 5px}",
+      // 表格（v0.11.1 美化）：真 table 替代竖线等宽行；文件清单第一列路径走
+      // code 底色，行数列右对齐等宽数字；斑马纹用 3% 前景混色，不引新字面量色。
+      ".mneme-wikitable{width:100%;border-collapse:collapse;margin:10px 0 14px;font-size:12.5px}",
+      ".mneme-wikitable th{padding:6px 10px;border-bottom:1px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-secondary);font-weight:500;text-align:left;white-space:nowrap}",
+      ".mneme-wikitable td{padding:5px 10px;border-top:1px solid var(--dsw-alias-border-l1);color:var(--dsw-alias-label-secondary);vertical-align:top}",
+      ".mneme-wikitable tbody tr:nth-child(even){background:color-mix(in srgb,var(--dsw-alias-label-primary) 3%,transparent)}",
+      ".mneme-wikitable tbody tr:hover{background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 7%,transparent)}",
+      ".mneme-wikitable td .mneme-wikicode{background:none;padding:0}",
+      ".mneme-wikinum{text-align:right;font-variant-numeric:tabular-nums}",
+      ".mneme-wikiquote{margin:8px 0 14px;padding:8px 12px;border-left:3px solid var(--dsw-alias-border-l2);color:var(--mneme-fg-dim);font-size:12px;line-height:18px}",
+      ".mneme-wikiempty{padding:26px 22px;font-size:13px;line-height:21px;color:var(--dsw-alias-label-secondary);display:flex;flex-direction:column;gap:8px;overflow-y:auto}",
+      ".mneme-wikiemptytitle{font-size:15px;font-weight:600;color:var(--dsw-alias-label-primary)}",
+      ".mneme-wikihits{position:absolute;inset-inline:22px;top:8px;z-index:3;display:flex;flex-direction:column;gap:4px;max-height:46%;overflow-y:auto;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-1);padding:8px;box-shadow:0 10px 28px color-mix(in srgb,var(--dsw-alias-label-primary) 14%,transparent)}",
+      ".mneme-wikihit{text-align:left;border:none;background:none;cursor:pointer;font-family:inherit;font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary);padding:5px 7px;border-radius:6px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
+      ".mneme-wikihit:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
+      ".mneme-wikihitsclose{flex:none;align-self:flex-end;border:none;background:none;cursor:pointer;color:var(--mneme-fg-dim);font-size:15px;line-height:16px;padding:0 4px}",
+      // 相对定位由 .mneme-panel 提供？它没有——检索浮层需要定位上下文，给页面列加
+      // position:relative（不能动 .mneme-panel 本身：记忆面板还挂在同一根上）。
+      ".mneme-wikipage{position:relative}",
       // --- 记忆库页面：居中 sheet，非全屏 ---
       // 从对话直接打开一页记忆库：背板压暗 + 居中圆角卡片（上限 1180×880），
       // 对话仍留在背板之后，任何状态下（含新会话 hero、无 tab 环）都可用。
@@ -2463,6 +2729,25 @@ window.__ModuleLoader__.load({
       ".mneme-heatcell.l4{background:var(--mneme-heat-1)}",
       ".mneme-heatlegend{display:flex;align-items:center;gap:3px;margin-top:8px;font-size:10.5px;color:var(--mneme-fg-dim)}",
       ".mneme-heatlegend .mneme-heatcell{width:10px;height:10px}",
+      // 热力右侧的空白：热力只有 56 格 × 11px ≈ 745px 宽，而容器可用宽 968px，
+      // 右边常年空着约 220px。原先三块图各自独占整行，空白是「每块只占半行」造成的，
+      // 不是某个空 div——所以这里把热力与沉淀图并成两列（左侧热力按内容宽 auto，
+      // 右侧吃剩余），容器窄到放不下两列时回落单列竖排。
+      ".mneme-flowrow{display:grid;grid-template-columns:auto minmax(0,1fr);gap:20px;align-items:start}",
+      "@container (max-width:960px){.mneme-flowrow{grid-template-columns:minmax(0,1fr)}}",
+      ".mneme-flowheat{min-width:0}",
+      ".mneme-flowsink{min-width:0;display:flex;flex-direction:column}",
+      // 8 周沉淀只画两条（进来的 / 稳住的）：220px 宽里三序列会细到看不清，
+      // 归档数改在下方图例里给总量。
+      ".mneme-sinkchart{display:flex;align-items:flex-end;gap:4px;height:96px;margin-top:12px}",
+      ".mneme-sinkcol{flex:1;min-width:0;display:flex;align-items:flex-end;gap:2px;height:100%}",
+      ".mneme-sinkbar{flex:1;min-width:0;border-radius:2px 2px 0 0;min-height:1px}",
+      ".mneme-sinkbar--added{background:var(--mneme-chart-3)}",
+      ".mneme-sinkbar--merged{background:var(--mneme-chart-2)}",
+      ".mneme-sinklabels{display:flex;gap:4px;margin-top:4px;font-size:9.5px;color:var(--mneme-fg-dim);font-variant-numeric:tabular-nums}",
+      ".mneme-sinklabels span{flex:1;min-width:0;text-align:center;white-space:nowrap}",
+      ".mneme-sinklegend{display:flex;flex-wrap:wrap;align-items:center;gap:4px 10px;margin-top:8px;font-size:10.5px;color:var(--mneme-fg-dim)}",
+      ".mneme-sinklegend b{font-weight:600;color:var(--dsw-alias-label-secondary);font-variant-numeric:tabular-nums}",
       // 原 9 卡降级折叠区：默认收起，展开才挂载子卡（见 TokenFlowSection 注释）。
       ".mneme-legacy{max-width:1000px;margin:0 auto 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;padding:12px 16px}",
       ".mneme-legacy summary{cursor:pointer;font-size:13px;font-weight:600;color:var(--dsw-alias-label-secondary)}",
@@ -2506,6 +2791,11 @@ window.__ModuleLoader__.load({
       ".mneme-set-tocchip:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}",
       ".mneme-set-token{font-family:monospace;font-size:12px;padding:7px 10px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-base,transparent);color:var(--dsw-alias-label-primary);word-break:break-all;user-select:all}",
       ".mneme-set-hint{font-size:12px;color:var(--mneme-fg-dim)}",
+      // 配置键覆盖清单（#386 第 7 条）：一行一排 chip，长键名换行不截断——
+      // 这张表的用处就是让「memoryQualityFilter.archiveThreshold」这样的名字能被
+      // 完整抄进配置文件，省略号会直接毁掉它的用途。
+      ".mneme-keylist{display:flex;flex-wrap:wrap;gap:5px;margin-top:6px}",
+      ".mneme-keychip{font-family:monospace;font-size:11px;padding:2px 6px;border-radius:6px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-base,transparent);color:var(--mneme-fg-dim);word-break:break-all;user-select:all}",
       // --- 重要性编辑行：与查看态同一份 Lucide 星形（此前是文本星号下拉，角更尖锐且与其他星不统一） ---
       ".mneme-staredit{display:inline-flex;align-items:center;gap:1px;justify-self:start}",
       ".mneme-starbtn{border:none;background:none;cursor:pointer;padding:2px 1px;display:inline-flex;color:var(--dsw-alias-label-secondary);transition:transform .12s}",
@@ -2831,6 +3121,12 @@ window.__ModuleLoader__.load({
     //   ④ 关系图谱  the same ego graph the old graph-only tab drew
     function EntityPanel({ t, focusEntity, onJumpMemory }) {
       const [entities, setEntities] = useState(null);
+      // 目录只取最近 500 个（limit=500），可「一共抽出多少实体」问的是全库。
+      // 后端回 total + totalExact（见 src/api.js 的 /entities），这里必须用全库数，
+      // 否则左侧栏永远显示「500 个实体」——那正是「实体太少」这个观感的另一半来源：
+      // 状态页已经在 #559 修正，实体页这一处当时漏了。null = 全库数读不到（老宿主
+      // 或计数失败），此时退回切片长度并如实标成切片口径，不冒充全库。
+      const [entityTotal, setEntityTotal] = useState(null);
       const [railQuery, setRailQuery] = useState("");
       const [entityName, setEntityName] = useState(focusEntity || "");
       const [depth, setDepth] = useState(1);
@@ -2848,14 +3144,29 @@ window.__ModuleLoader__.load({
       const dragRef = useRef(null); // { id, moved }
       const viewRef = useRef({ x: 0, y: 0, k: 1 }); // pan/zoom viewport, viewBox units
       const [frame, setFrame] = useState(0); // re-render tick driven by the simulation
+      // 通用失效广播的重取游标：记忆行的增删改会连带实体属性/关联记忆/关系边，
+      // 目录与各层数据的 effect 依赖都带上它（见下方订阅 effect）。
+      const [dataTick, setDataTick] = useState(0);
 
       useEffect(() => {
         let cancelled = false;
         apiFetch("/api/dsh-mneme/entities?limit=500")
           .then((r) => (r.ok ? r.json() : { entities: [] }))
-          .then((j) => { if (!cancelled) setEntities(Array.isArray(j.entities) ? j.entities : []); })
-          .catch(() => { if (!cancelled) setEntities([]); });
+          .then((j) => {
+            if (cancelled) return;
+            setEntities(Array.isArray(j.entities) ? j.entities : []);
+            setEntityTotal(j.totalExact === true && typeof j.total === "number" ? j.total : null);
+          })
+          .catch(() => { if (!cancelled) { setEntities([]); setEntityTotal(null); } });
         return () => { cancelled = true; };
+      }, [dataTick]);
+
+      // 通用失效广播订阅：实体抽取随写入发生，本页签对别处的改库（删除记忆、
+      // 裁决冲突、导入）无从感知——不订阅的话，切回来之前图谱一直是旧的。
+      useEffect(() => {
+        const onChanged = () => setDataTick((k) => k + 1);
+        window.addEventListener("mneme:store-changed", onChanged);
+        return () => window.removeEventListener("mneme:store-changed", onChanged);
       }, []);
 
       useEffect(() => {
@@ -2889,7 +3200,7 @@ window.__ModuleLoader__.load({
         }
       }, []);
 
-      useEffect(() => { load(entityName, depth); }, [load, entityName, depth]);
+      useEffect(() => { load(entityName, depth); }, [load, entityName, depth, dataTick]);
 
       // Layer data for the selected entity: current attrs + related memories.
       useEffect(() => {
@@ -2906,7 +3217,7 @@ window.__ModuleLoader__.load({
           .then((j) => { if (!cancelled) setRelated(Array.isArray(j.items) ? j.items : []); })
           .catch(() => {});
         return () => { cancelled = true; };
-      }, [entityName]);
+      }, [entityName, dataTick]);
 
       // issue #24 块4 复核面：只在展开时取，收起时不发请求。
       const loadBoosted = useCallback(async () => {
@@ -3106,8 +3417,13 @@ window.__ModuleLoader__.load({
             value: railQuery,
             onChange: (e) => setRailQuery(e.target.value)
           }),
+          // 大数字用全库数；全库数读不到（老宿主 / 计数失败）时退回切片长度，
+          // 但那只是「这次取回多少」，所以要多一行脚注说清列表本身只列最近 500 个。
           entities !== null && entities.length > 0 && h("div", { className: "mneme-xcount" },
-            t("memory.entities.count").replace("{n}", String(entities.length)))
+            t("memory.entities.count").replace("{n}", String(entityTotal !== null ? entityTotal : entities.length))),
+          entities !== null && entityTotal !== null && entityTotal > entities.length
+            && h("div", { className: "mneme-xcountnote" },
+              t("memory.entities.countSampled").replace("{shown}", String(entities.length)))
         ),
         h("div", { className: "mneme-entrailbody" },
           entities === null && h("div", { className: "mneme-xempty" }, "…"),
@@ -3393,7 +3709,16 @@ window.__ModuleLoader__.load({
         // 人格定义页（beta）：注入总闸。分组随 enhance（行为开关，非座位闸门）；
         // 人格内容在设置页「个性化」区的人格卡。
         // 严格寻址是同一条链上的第二个口径开关（只在总闸打开时起作用）。
-        "personaEnabled", "personaStrictAddressing", "profileExtractEnabled"] },
+        "personaEnabled", "personaStrictAddressing", "profileExtractEnabled",
+        // 自动事实（profile_facts）：dream 后的自动维护闸。展示与人工修正不受它管
+        // （GET/apply 在 flag 关时照常放行，存量事实要能看能改），它只决定「自动做梦
+        // 维护」与面板「立即更新」这两条 LLM 路径开不开。
+        "profileFactsEnabled",
+        // chorography（仓库地志）的暴露闸（M1 就有的键，M3 才上 UI）：它是「是否
+        // 启用这个子系统」而不是「每轮付多少」，所以和上面这些行为开关同组；
+        // 每轮付出多少由紧随组尾的 choroSub 档位管。放组末是因为子块按组尾渲染
+        // ——档位下拉要贴着它的总闸。
+        "chorographyEnabled"] },
       { key: "group.dream", items: ["sleepModeEnabled"] },
       // v0.8.0 A4（issue #17）：作用域隔离组——标注总开关 + 严格硬过滤。
       { key: "group.scope", items: ["scopeEnabled", "strictScope"] }
@@ -3417,6 +3742,9 @@ window.__ModuleLoader__.load({
     // 蒸馏思考强度（issue #315）：比 entity 多一个 off（显式关思考，思考型模型
     // 蒸馏防推理烧预算）。后端枚举含 off，面板必须能选到，否则操作者用不上。
     const SUMMARIZE_REASONING = ["off", "none", "low", "medium", "high"];
+    // 地志注入档位（M3）：与后端 settings.js 的 FEATURE_FLAG_ENUMS.chorographyInject
+    // 同一份取值。light 是默认档，off 才是不注入。
+    const CHORO_TIERS = ["off", "light", "full"];
 
     function FeatureRow({ name, hint, on, disabled, onToggle, sub, tag }) {
       return h("div", { className: "mneme-featrow", style: sub ? { paddingLeft: 18, opacity: 0.86 } : undefined },
@@ -3514,6 +3842,10 @@ window.__ModuleLoader__.load({
           }
           setState(await res.json());
           setSaveError("");
+          // 功能开关即改即存：别的卡在读同一份 effective 快照（画像事实卡的
+          // 「立即更新」按钮禁用态）——广播让它们重读，不然按提示开了开关还得
+          // 关面板重开才解禁，正是本车道广播工作项要消灭的那类体验。
+          try { window.dispatchEvent(new CustomEvent("mneme:features-changed")); } catch { /* 非浏览器环境 */ }
           announce(t("memory.features.restartHint"));
           setSavedTick(true);
           setTimeout(() => setSavedTick(false), 1800);
@@ -3834,6 +4166,24 @@ window.__ModuleLoader__.load({
         h("div", { className: "mneme-featsubhint" }, t("memory.features.distillRecords.retentionDays.hint"))
       );
 
+      // chorography M3：开局注入的档位。挂在 chorographyEnabled 下（总闸关着时
+      // 不展开——没启用子系统就没有「注入多少」可谈）。枚举键没有通用渲染器，
+      // 与上面几个子块同款手写下拉。轻量档（lightMode）在消费侧压成 off，
+      // 面板不因此灰掉：那是运行时预设，不是用户选择。
+      const choroSub = eff.chorographyEnabled && h("div", { className: "mneme-featsub" },
+        h("div", { className: "mneme-featnum" },
+          h("span", { className: "mneme-featnumlabel" }, t("memory.features.chorographyInject")),
+          h("select", {
+            className: "mneme-select",
+            value: eff.chorographyInject || "light",
+            disabled: busy,
+            onChange: (e) => put({ chorographyInject: e.target.value })
+          },
+            CHORO_TIERS.map((r) => h("option", { key: r, value: r }, t(`memory.features.chorographyInject.${r}`))))
+        ),
+        h("div", { className: "mneme-featsubhint" }, t("memory.features.chorographyInject.hint"))
+      );
+
       if (error && !state) return h("section", { className: "mneme-set-card" },
         h("div", { className: "mneme-set-title" }, t("memory.features.title")),
         h("div", { className: "mneme-set-hint" }, error));
@@ -3868,7 +4218,7 @@ window.__ModuleLoader__.load({
                 // 子块按组尾追加。distillSub 紧跟在 core 组最后一行
                 // （distillRecords.enabled）之后，天数行才贴着它的总闸。
                 g.key === "group.core" && h(react.Fragment, null, distillSub, summarizeSub),
-                g.key === "group.enhance" && h(react.Fragment, null, embedSub, entitySub),
+                g.key === "group.enhance" && h(react.Fragment, null, embedSub, entitySub, choroSub),
                 g.key === "group.dream" && h(react.Fragment, null, dreamSub, sleepSub)
               );
               const firstScreen = FEATURE_GROUPS.filter((g) => FEATURE_FIRST_SCREEN.includes(g.key));
@@ -3963,6 +4313,15 @@ window.__ModuleLoader__.load({
       // 话——把「没启用」「库里没东西」「模型没配合」压成同一句「没有草稿」，用户就只能瞎猜。
       const [profileDraft, setProfileDraft] = react.useState(null);
       const [profileExtracting, setProfileExtracting] = react.useState(false);
+      const [profileDraftCopied, setProfileDraftCopied] = react.useState(false);
+      // 复制失败必须**看得见**：announce() 那个 live region 是 1px 裁剪元素，只有屏幕
+      // 阅读器读得到。视力正常的用户看到按钮文字没变、页面也没变化，就会以为复制成功，
+      // 粘贴时拿到旧的剪贴板内容——比不提示更糟。
+      const [profileDraftCopyFailed, setProfileDraftCopyFailed] = react.useState(false);
+      // 复制的每一趟都要能认出「这条回调还属于当前这份草稿吗」。剪贴板是异步的，复制 A 的
+      // promise 还没落地时又提取出草稿 B，A 的回调就会在 B 上打勾或报错——B 一个字都没被
+      // 复制过。用递增序号做票据：换草稿或重新复制都换票，旧票的回调直接丢弃。
+      const profileCopyTicket = react.useRef(0);
       // 保存失败要可见（persona 那条一直有，画像这条以前是静默 catch）。
       const [profileError, setProfileError] = react.useState("");
       const [cmdError, setCmdError] = react.useState("");
@@ -4186,6 +4545,10 @@ window.__ModuleLoader__.load({
       async function extractProfileDraft() {
         setProfileExtracting(true);
         setProfileDraft(null);
+        // 新草稿一出现，上一趟复制的回调立刻作废，连它留下的两种提示也一并清掉。
+        profileCopyTicket.current += 1;
+        setProfileDraftCopied(false);
+        setProfileDraftCopyFailed(false);
         try {
           const res = await apiFetch("/api/dsh-mneme/profile/extract", {
             method: "POST",
@@ -4217,16 +4580,59 @@ window.__ModuleLoader__.load({
         }
       }
 
-      // 采用草稿 = 显式写画像。两件事都要对：把草稿文本直接交给保存（不能 setProfile
-      // 之后再调无参保存——那读的是这次渲染里的旧闭包值，会存回旧文本），以及**只有
-      // 真的存下了才提交界面状态**（否则一次 403 就留下「框里是草稿、库里是旧文、
-      // 草稿已被清掉」的三不像，关掉面板后彻底找不回来）。
-      async function applyProfileDraft() {
+      // 草稿只展示副本（桉桉 2026-11-04 定的口径）。这一段以前叫「采用为画像」，
+      // 点一下就直接 PUT /profile —— 把用户手写的那份覆盖掉，且没有撤销。现在改成
+      // 复制：要落进「用户画像」必须由用户自己粘贴再点保存，手写原文一个字都不会被
+      // 后台改掉。剪贴板不可用（无权限 / 非安全上下文）时不许假装成功——退回
+      // execCommand 那条老路，仍然失败就明确让她手动选中复制。
+      function copyProfileDraft() {
         if (profileDraft?.kind !== "draft") return;
-        const text = profileDraft.text;
-        if (await saveProfile(text)) {
-          setProfile(text);
-          setProfileDraft(null);
+        const text = profileDraft.text || "";
+        // 每次尝试先清掉上次的失败提示：失败过以后再成功，红字不能留在屏上。
+        setProfileDraftCopyFailed(false);
+        // 这一趟的票。回调落地时票已经不是当前那张，就说明界面早已换了一份草稿。
+        const ticket = ++profileCopyTicket.current;
+        const current = () => ticket === profileCopyTicket.current;
+        const ok = () => {
+          if (!current()) return;
+          setProfileDraftCopied(true);
+          announce(t("memory.settings.profileDraftCopied"));
+          setTimeout(() => { if (current()) setProfileDraftCopied(false); }, 1500);
+        };
+        // 剪贴板失败要说话：这个方法唯一的产出就是"文本进了剪贴板"，静默失败
+        // 会让用户以为复制成功、粘贴时却拿到旧内容（草稿是只读 <pre>，选中再
+        // 复制是她能自己走的退路，得明确告诉她走这条）。
+        // 失败还要顺手撤掉「已复制」：成功态能挂 1.5 秒，这期间重试失败会同时出现
+        // 「已复制」和「复制没成功」两句相反的话。
+        const failed = () => {
+          if (!current()) return;
+          setProfileDraftCopied(false);
+          setProfileDraftCopyFailed(true);
+          announce(t("memory.settings.profileDraftCopyFailed"));
+        };
+        if (navigator.clipboard?.writeText) {
+          navigator.clipboard.writeText(text).then(ok, () => copyProfileDraftFallback(text) ? ok() : failed());
+        } else {
+          copyProfileDraftFallback(text) ? ok() : failed();
+        }
+      }
+
+      // 没有 Clipboard API（非安全上下文 / 内嵌 webview 未授权）时的退路：
+      // 临时 textarea + execCommand("copy")。失败返回 false，由调用方说话。
+      function copyProfileDraftFallback(text) {
+        try {
+          const ta = document.createElement("textarea");
+          ta.value = text;
+          ta.setAttribute("readonly", "");
+          ta.style.position = "fixed";
+          ta.style.opacity = "0";
+          document.body.appendChild(ta);
+          ta.select();
+          const done = document.execCommand("copy");
+          document.body.removeChild(ta);
+          return done === true;
+        } catch {
+          return false;
         }
       }
 
@@ -4289,6 +4695,203 @@ window.__ModuleLoader__.load({
         savePersonaCards(personaDefault, next);
       };
 
+      // 「Agent 眼中的你」自动事实（profile_facts 三表）：展示与人工修正独立于手填
+      // 画像（#497 口径：user_settings 神圣，这里一个字都不写它）。增改删全走
+      // POST /apply（删除=归档，可恢复），与 dream 自动轮共用后端同一份 applyOps
+      // 与同一本账——前端不复述任何判据，也不自己维护第二份事实列表。
+      const [factsCards, setFactsCards] = react.useState([]); // 卡清单是全局的，不随选中卡变化
+      const [factsRows, setFactsRows] = react.useState(null); // null = 还没读到/读失败（fail-closed，不拿旧卡的行冒充这张卡）
+      const [factsJournal, setFactsJournal] = react.useState([]);
+      const [factsRuns, setFactsRuns] = react.useState([]);
+      const [factsAgent, setFactsAgent] = react.useState(""); // "" = default 卡
+      const [factsEditId, setFactsEditId] = react.useState(null);
+      const [factsEditDraft, setFactsEditDraft] = react.useState("");
+      const [factsNew, setFactsNew] = react.useState("");
+      const [factsBusy, setFactsBusy] = react.useState(false); // apply 提交中
+      const [factsRunning, setFactsRunning] = react.useState(false); // 手动维护轮进行中
+      // apply 的一次性回执：{kind, text}。failures / dupsSkipped 必须如实摆出来——
+      // 把失败装成成功，人会以为删掉的事实在下一轮不会再来。
+      const [factsNotice, setFactsNotice] = react.useState(null);
+      // 手动维护轮的结局文案（profileDraft 的 kind 分支同款）：把「没启用」「没配模型」
+      // 「模型不配合」压成一句「失败」，用户就只能瞎猜该去修什么。
+      const [factsRunEnd, setFactsRunEnd] = react.useState(null);
+      // 总闸快照只管「立即更新」按钮的可用性：null = 还没读到（读失败不猜，按钮保持
+      // 可用，点下去由后端 409 disabled 兜底）；事实的展示与人工修正不受这个闸管。
+      const [factsFlag, setFactsFlag] = react.useState(null);
+      // 与 loadPreview 同一套序号守卫：先切 A 再切 B，A 的响应后到不能盖掉 B 的。
+      const factsSeq = react.useRef(0);
+      const loadFacts = react.useCallback(async (agentKey) => {
+        const seq = ++factsSeq.current;
+        try {
+          const res = await apiFetch(`/api/dsh-mneme/profile-facts?agent=${encodeURIComponent(agentKey)}`);
+          const body = await res.json().catch(() => null);
+          if (seq !== factsSeq.current) return;
+          if (res.ok && body && Array.isArray(body.facts)) {
+            setFactsCards(Array.isArray(body.cards) ? body.cards.filter((k) => typeof k === "string") : []);
+            setFactsRows(body.facts);
+            setFactsJournal(Array.isArray(body.journal) ? body.journal : []);
+            setFactsRuns(Array.isArray(body.runs) ? body.runs : []);
+          } else {
+            // 503 unavailable / 后端过旧：行清空走「读不到」文案；卡清单是全局的，
+            // 保留上次读到的，选择器不至于闪空。
+            setFactsRows(null);
+            setFactsJournal([]);
+            setFactsRuns([]);
+          }
+        } catch {
+          if (seq === factsSeq.current) {
+            setFactsRows(null);
+            setFactsJournal([]);
+            setFactsRuns([]);
+          }
+        }
+      }, []);
+      // 切卡先清行再取：上一张卡的事实留在屏上会被当成这张的（同 loadPreview 的
+      // 单一所有者纪律——这里没有直接写数据，都交给 loadFacts）。维护轮结局一并
+      // 清：A 卡跑完的「已更新 N 条」不该显示在 B 卡下（评审 P3：跨卡残留）。
+      react.useEffect(() => {
+        setFactsRows(null);
+        setFactsEditId(null);
+        setFactsEditDraft("");
+        setFactsNotice(null);
+        setFactsRunEnd(null);
+        loadFacts(factsAgent);
+      }, [factsAgent, loadFacts]);
+      // 总闸快照：features 由功能开关卡管写，这里只读不写、失败不猜。功能开关卡
+      // 即改即存并广播 mneme:features-changed——不监听的话，按提示开了「自动事实」
+      // 还得关面板重开才解禁（正是广播工作项要消灭的那类体验）。
+      react.useEffect(() => {
+        let cancelled = false;
+        const loadFlag = () => {
+          apiFetch("/api/dsh-mneme/features")
+            .then((res) => (res.ok ? res.json() : null))
+            .then((j) => {
+              if (cancelled) return;
+              const eff = (j && j.effective) || {};
+              setFactsFlag(eff.profileFactsEnabled === true);
+            })
+            .catch(() => {}); // 读失败保持 null：按钮不锁死，409 兜底
+        };
+        loadFlag();
+        window.addEventListener("mneme:features-changed", loadFlag);
+        return () => { cancelled = true; window.removeEventListener("mneme:features-changed", loadFlag); };
+      }, []);
+      // 人工修正统一入口：一张卡上的小批量 ops 一次 POST，回来重取 GET 让账本跟上，
+      // 并刷新注入预览（事实段是注入文本的一部分，预览别停在编辑前）。
+      async function applyFactsOps(ops) {
+        if (factsBusy) return null;
+        setFactsBusy(true);
+        try {
+          const res = await apiFetch("/api/dsh-mneme/profile-facts/apply", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ agent: factsAgent, ops })
+          });
+          const body = await res.json().catch(() => null);
+          if (!res.ok || !body || !Array.isArray(body.facts)) {
+            setFactsNotice({ kind: "fail", text: t("memory.settings.factsApplyError") });
+            announce(t("memory.settings.factsApplyError"));
+            return null;
+          }
+          const fails = Array.isArray(body.failures) ? body.failures : [];
+          const dups = Number(body.dupsSkipped) || 0;
+          let text = t("memory.settings.factsApplyDone");
+          let kind = "ok";
+          if (fails.length || dups > 0) {
+            const parts = [];
+            if (fails.length) parts.push(t("memory.settings.factsApplyFailures").replace("{n}", String(fails.length)));
+            if (dups > 0) parts.push(t("memory.settings.factsApplyDups").replace("{n}", String(dups)));
+            text = parts.join(" · ");
+            kind = fails.length ? "fail" : "dup";
+          }
+          setFactsNotice({ kind, text });
+          announce(text);
+          await loadFacts(factsAgent);
+          loadPreview(personaEditing);
+          return body;
+        } catch {
+          setFactsNotice({ kind: "fail", text: t("memory.settings.factsApplyError") });
+          announce(t("memory.settings.factsApplyError"));
+          return null;
+        } finally {
+          setFactsBusy(false);
+        }
+      }
+      async function addFact() {
+        const content = factsNew.trim();
+        if (!content) return;
+        const body = await applyFactsOps([{ op: "add", content }]);
+        // 与既有活跃事实重复的 add 会被后端跳过并计数：输入框照常清空，跳了几条
+        // 由提示条说明，别让人以为没点上。
+        if (body) setFactsNew("");
+      }
+      function startFactEdit(f) {
+        setFactsEditId(f.id);
+        setFactsEditDraft(typeof f.content === "string" ? f.content : "");
+      }
+      function cancelFactEdit() {
+        setFactsEditId(null);
+        setFactsEditDraft("");
+      }
+      async function saveFactEdit() {
+        if (factsEditId === null) return;
+        const content = factsEditDraft.trim();
+        if (!content) return;
+        const editId = factsEditId;
+        const body = await applyFactsOps([{ op: "update", id: editId, content }]);
+        // 只有这条真的写进去了才收起编辑框；它自己的 op 失败时留着草稿，别让人重打。
+        if (body && !(Array.isArray(body.failures) && body.failures.some((x) => x && x.id === editId))) {
+          cancelFactEdit();
+        }
+      }
+      async function archiveFact(id) {
+        await applyFactsOps([{ op: "archive", id }]);
+      }
+      // 手动维护轮：结局按后端 error 码分派——no-route 重跑也一样、unparseable 等
+      // 可重试、disabled 是闸没开，三种话不能混。跑完重取 GET 并刷新预览。
+      async function runFacts() {
+        if (factsRunning || factsBusy) return;
+        setFactsRunning(true);
+        setFactsRunEnd(null);
+        try {
+          const res = await apiFetch("/api/dsh-mneme/profile-facts/run", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ agent: factsAgent })
+          });
+          const body = await res.json().catch(() => null);
+          if (res.ok && body && typeof body.status === "string") {
+            const n = Number(body.opsApplied) || 0;
+            setFactsRunEnd(body.status === "noop" ? { kind: "noop" } : { kind: "ok", n });
+            announce(t(body.status === "noop" ? "memory.settings.factsRunNoop" : "memory.settings.factsRunOk").replace("{n}", String(n)));
+          } else {
+            const error = body && typeof body.error === "string" ? body.error : "";
+            const kind = error === "disabled" ? "disabled" : error === "no-route" ? "noroute" : "failed";
+            setFactsRunEnd({ kind });
+            announce(t(kind === "disabled" ? "memory.settings.factsRunDisabled"
+              : kind === "noroute" ? "memory.settings.factsRunNoRoute"
+              : "memory.settings.factsRunFailed"));
+          }
+          await loadFacts(factsAgent);
+          loadPreview(personaEditing);
+        } catch {
+          setFactsRunEnd({ kind: "failed" });
+          announce(t("memory.settings.factsRunFailed"));
+        } finally {
+          setFactsRunning(false);
+        }
+      }
+      // 账本行的摘要截断：before/after 各 ~40 字符，长了加省略号——账本给「扫一眼」
+      // 用，整句塞进来会把最近变更撑成一堵墙。
+      const clipFactText = (s) => {
+        const v = String(s ?? "");
+        return v.length > 40 ? v.slice(0, 40) + "…" : v;
+      };
+      const factOpLabel = (op) => (op === "add" ? t("memory.settings.factsOpAdd")
+        : op === "update" ? t("memory.settings.factsOpUpdate")
+        : op === "archive" ? t("memory.settings.factsOpArchive")
+        : String(op ?? ""));
+
       async function putRules(next) {
         await apiFetch("/api/dsh-mneme/rules", {
           method: "PUT",
@@ -4521,35 +5124,7 @@ window.__ModuleLoader__.load({
             saved && h("span", { className: "mneme-saved" }, t("memory.settings.profileSaved")),
             profileError ? h("span", { className: "mneme-saved", style: { color: "var(--dsw-danger, #d33)" } },
               t("memory.settings.profileSaveFailed") + " (" + profileError + ")") : null
-          ),
-          // 从记忆提取草稿（#497）。两种结局都要显眼：草稿（要用户点「采用」才落库）
-          // 与失败原因（开关没开 / 没内容可提 / 模型没配合）。手写的原文在这之上一直
-          // 可见——采用前它不会被任何东西覆盖。
-          h("div", { style: { display: "flex", alignItems: "center", gap: 8, marginTop: 8 } },
-            h("button", {
-              type: "button",
-              className: "mneme-btn",
-              disabled: profileExtracting,
-              onClick: extractProfileDraft
-            }, t("memory.settings.profileExtract")),
-            profileExtracting ? h("span", { className: "mneme-saved" }, t("memory.settings.profileExtracting")) : null
-          ),
-          h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractHint")),
-          profileDraft?.kind === "disabled" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractDisabled")) : null,
-          profileDraft?.kind === "empty" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractEmpty")) : null,
-          profileDraft?.kind === "noroute" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractNoRoute")) : null,
-          profileDraft?.kind === "failed" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractFailed")) : null,
-          profileDraft?.kind === "draft" ? h("div", null,
-            h("div", { className: "mneme-featnumlabel" }, t("memory.settings.profileDraftTitle")),
-            h("div", { className: "mneme-set-desc" },
-              t("memory.settings.profileDraftRows") + ": " + profileDraft.rowsUsed
-              + (profileDraft.truncated ? " · " + t("memory.settings.profileDraftTruncated") : "")),
-            h("pre", { className: "mneme-set-input mneme-set-input--area", style: { whiteSpace: "pre-wrap", minHeight: 0 } }, profileDraft.text),
-            h("div", { style: { display: "flex", alignItems: "center", gap: 8, marginTop: 6 } },
-              h("button", { type: "button", className: "mneme-btn", onClick: applyProfileDraft }, t("memory.settings.profileDraftApply")),
-              h("button", { type: "button", className: "mneme-btn", onClick: () => setProfileDraft(null) }, t("memory.settings.profileDraftDiscard"))
-            )
-          ) : null
+          )
         ),
         // 人格卡（beta，v1.2 多卡）— who the agent is：多张角色卡按会话身份注入。
         // 卡内开关只是该卡 enabled 半边；总闸 personaEnabled 在功能开关组，双闸同真。
@@ -4681,7 +5256,186 @@ window.__ModuleLoader__.load({
               className: "mneme-btn",
               onClick: () => loadPreview(personaEditing)
             }, t("memory.settings.personaViewRefresh"))
-          )
+          ),
+          // 从记忆提取草稿（#497）。**放在这张卡上而不是「用户画像」卡**：画像那一栏是
+          // 用户自己手填的地方；这一段是从记忆里反推出来的「Agent 眼中的你」，属于可
+          // 沉淀的那一侧。它只出**副本**——不写 user_settings，也不碰手写画像（桉桉
+          // 2026-11-04 定的口径：只展示副本）。要改成手写画像只能自己复制再粘过去。
+          h("div", { style: { display: "flex", alignItems: "center", gap: 8, marginTop: 12 } },
+            h("button", {
+              type: "button",
+              className: "mneme-btn",
+              disabled: profileExtracting,
+              onClick: extractProfileDraft
+            }, t("memory.settings.profileExtract")),
+            profileExtracting ? h("span", { className: "mneme-saved" }, t("memory.settings.profileExtracting")) : null
+          ),
+          h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractHint")),
+          profileDraft?.kind === "disabled" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractDisabled")) : null,
+          profileDraft?.kind === "empty" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractEmpty")) : null,
+          profileDraft?.kind === "noroute" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractNoRoute")) : null,
+          profileDraft?.kind === "failed" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.profileExtractFailed")) : null,
+          profileDraft?.kind === "draft" ? h("div", null,
+            h("div", { className: "mneme-featnumlabel" }, t("memory.settings.profileDraftTitle")),
+            h("div", { className: "mneme-set-desc" },
+              t("memory.settings.profileDraftRows") + ": " + profileDraft.rowsUsed
+              + (profileDraft.truncated ? " · " + t("memory.settings.profileDraftTruncated") : "")),
+            h("pre", { className: "mneme-set-input mneme-set-input--area", style: { whiteSpace: "pre-wrap", minHeight: 0 } }, profileDraft.text),
+            h("div", { style: { display: "flex", alignItems: "center", gap: 8, marginTop: 6 } },
+              h("button", { type: "button", className: "mneme-btn", onClick: copyProfileDraft },
+                profileDraftCopied ? t("memory.settings.profileDraftCopied") : t("memory.settings.profileDraftCopy")),
+              h("button", { type: "button", className: "mneme-btn", onClick: () => {
+                profileCopyTicket.current += 1;
+                setProfileDraft(null);
+                setProfileDraftCopied(false);
+                setProfileDraftCopyFailed(false);
+              } }, t("memory.settings.profileDraftDiscard")),
+              h("span", { className: "mneme-set-desc" }, t("memory.settings.profileDraftCopyHint")),
+              profileDraftCopyFailed ? h("span", { className: "mneme-set-desc", role: "alert", style: { color: "var(--mneme-danger)" } },
+                t("memory.settings.profileDraftCopyFailed")) : null
+            )
+          ) : null
+        ),
+        // 自动事实（profile_facts）：dream 后自动维护的「Agent 眼中的你」，按会话身份
+        // 分卡。放在注入预览卡之后——预览里事实段的来源就在这里，看预览的人顺势就能
+        // 找到改它的地方；规则是用户立的另一域（另一张卡），不混。
+        h("section", { className: "mneme-set-card" },
+          h("div", { className: "mneme-set-title" }, t("memory.settings.factsTitle")),
+          h("div", { className: "mneme-set-desc" }, t("memory.settings.factsHint")),
+          // 卡选择器：default + 各身份卡，人格卡同款 chip 形态；切换即重取（effect 里清行）。
+          h("div", { style: { display: "flex", flexWrap: "wrap", gap: 6 } },
+            h("button", {
+              type: "button",
+              className: "mneme-btn" + (factsAgent === "" ? " mneme-btn--active" : ""),
+              onClick: () => setFactsAgent("")
+            }, t("memory.settings.personaDefaultCard")),
+            // 选中卡即使这轮从清单里消失（事实全归档且无同 scope 记忆）也不让它从
+            // 选择器上失踪——正在编辑的人不能失去落点。
+            [...new Set([factsAgent, ...factsCards])].filter((k) => k && k.trim()).map((k) =>
+              h("button", {
+                key: k,
+                type: "button",
+                className: "mneme-btn" + (factsAgent === k ? " mneme-btn--active" : ""),
+                onClick: () => setFactsAgent(k)
+              }, k))
+          ),
+          factsRows === null
+            ? h("div", { className: "mneme-xempty" }, t("memory.settings.factsUnavailable"))
+            : h("div", null,
+                // 只列活跃行：归档的行留在账本里可追溯，不再回到清单上（恢复=重新添加）。
+                factsRows.filter((f) => f && f.status === "active").length === 0
+                  ? h("div", { className: "mneme-xempty" }, t("memory.settings.factsEmpty"))
+                  : null,
+                factsRows.filter((f) => f && f.status === "active").map((f) =>
+                  factsEditId === f.id
+                    ? h("div", { key: f.id, className: "mneme-set-row" },
+                        h("input", {
+                          className: "mneme-set-input",
+                          style: { marginBottom: 0, flex: "1 1 auto" },
+                          value: factsEditDraft,
+                          autoFocus: true,
+                          onChange: (e) => setFactsEditDraft(e.target.value),
+                          onKeyDown: (e) => {
+                            if (e.key === "Enter") saveFactEdit();
+                            if (e.key === "Escape") cancelFactEdit();
+                          }
+                        }),
+                        h("button", { type: "button", className: "mneme-btn", disabled: factsBusy, onClick: saveFactEdit },
+                          t("memory.settings.factsRowSave")),
+                        h("button", { type: "button", className: "mneme-btn", disabled: factsBusy, onClick: cancelFactEdit },
+                          t("memory.settings.factsRowCancel"))
+                      )
+                    : h("div", { key: f.id, className: "mneme-set-row" },
+                        h("span", { className: "mneme-set-ruletext", style: { flex: "1 1 auto" } }, f.content),
+                        // ✎ 与 × 都走 mneme-set-del（悬停显形）：低频动作不常驻，
+                        // 与规则卡同一套视觉语言。
+                        h("button", {
+                          type: "button",
+                          className: "mneme-set-del",
+                          title: t("memory.settings.factsRowEdit"),
+                          "aria-label": t("memory.settings.factsRowEdit"),
+                          onClick: () => startFactEdit(f)
+                        }, "✎"),
+                        // 删除不二次确认：archive 可恢复（账本里留 before），打断比误删贵。
+                        h("button", {
+                          type: "button",
+                          className: "mneme-set-del",
+                          title: t("memory.settings.factsRowDelete"),
+                          "aria-label": t("memory.settings.factsRowDelete"),
+                          onClick: () => archiveFact(f.id)
+                        }, "×")
+                      )
+                ),
+                h("div", { style: { display: "flex", gap: 8, marginTop: 6 } },
+                  h("input", {
+                    className: "mneme-set-input",
+                    style: { marginBottom: 0 },
+                    value: factsNew,
+                    placeholder: t("memory.settings.factsAddPlaceholder"),
+                    onChange: (e) => setFactsNew(e.target.value),
+                    onKeyDown: (e) => { if (e.key === "Enter") addFact(); }
+                  }),
+                  h("button", { type: "button", className: "mneme-btn", disabled: factsBusy, onClick: addFact },
+                    t("memory.settings.factsAdd"))
+                ),
+                // apply 回执：失败（role=alert）与跳重如实摆出来，全成才说成功。
+                factsNotice
+                  ? h("div", {
+                      className: "mneme-set-desc",
+                      role: factsNotice.kind === "fail" ? "alert" : undefined,
+                      style: { color: factsNotice.kind === "fail" ? "var(--mneme-danger)" : undefined }
+                    }, factsNotice.text)
+                  : null,
+                // 手动维护轮：总闸快照关着就禁用（features 只读不写）；快照没读到时
+                // 不锁——点下去由后端 409 disabled 给出同款解释。
+                h("div", { style: { display: "flex", alignItems: "center", gap: 8, marginTop: 12 } },
+                  h("button", {
+                    type: "button",
+                    className: "mneme-btn",
+                    disabled: factsRunning || factsFlag === false,
+                    onClick: runFacts
+                  }, factsRunning ? t("memory.settings.factsRunning") : t("memory.settings.factsRun")),
+                  factsRunning ? h("span", { className: "mneme-saved" }, t("memory.settings.factsRunning")) : null
+                ),
+                factsFlag === false ? h("div", { className: "mneme-set-desc" }, t("memory.settings.factsGateOff")) : null,
+                // 五种结局各一句话（profileDraft 的 kind 分支同款）。
+                factsRunEnd?.kind === "ok" ? h("div", { className: "mneme-set-desc" },
+                  t("memory.settings.factsRunOk").replace("{n}", String(factsRunEnd.n))) : null,
+                factsRunEnd?.kind === "noop" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.factsRunNoop")) : null,
+                factsRunEnd?.kind === "disabled" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.factsRunDisabled")) : null,
+                factsRunEnd?.kind === "noroute" ? h("div", { className: "mneme-set-desc" }, t("memory.settings.factsRunNoRoute")) : null,
+                factsRunEnd?.kind === "failed" ? h("div", { className: "mneme-set-desc", role: "alert", style: { color: "var(--mneme-danger)" } },
+                  t("memory.settings.factsRunFailed")) : null,
+                // 最近变更（账本尾 8 条，后端按新→旧给）：时间 + op + 内容变化 + actor 徽章。
+                h("div", { className: "mneme-featnumlabel", style: { marginTop: 12 } }, t("memory.settings.factsJournalTitle")),
+                factsJournal.length === 0 ? h("div", { className: "mneme-xempty" }, t("memory.settings.factsJournalEmpty")) : null,
+                factsJournal.slice(0, 8).map((j) =>
+                  h("div", { key: j.id, className: "mneme-set-row", style: { flexWrap: "wrap", gap: 6 } },
+                    h("span", { className: "mneme-set-desc", title: j.at }, formatRelativeTime(j.at, t)),
+                    h("span", { className: "mneme-set-ruletext" }, factOpLabel(j.op)),
+                    h("span", { className: "mneme-set-desc", style: { flex: "1 1 160px" } },
+                      // add 只展示新值；archive 只展示旧值（op 标签已经说了归档）；
+                      // update 才有真正的 before→after。
+                      j.op === "add" ? "+ " + clipFactText(j.after)
+                        : j.op === "archive" ? clipFactText(j.before)
+                        : clipFactText(j.before) + " → " + clipFactText(j.after)),
+                    h("span", { className: "mneme-badge " + (j.actor === "manual" ? "mneme-badge--scope" : "mneme-badge--default") },
+                      t(j.actor === "manual" ? "memory.settings.factsActorManual" : "memory.settings.factsActorAuto"))
+                  )
+                ),
+                // 最近一轮维护（回执尾 1 条，后端按新→旧给）：状态 + 输入/应用计数。
+                factsRuns[0]
+                  ? h("div", { className: "mneme-set-desc" },
+                      t("memory.settings.factsRunLast")
+                      + (factsRuns[0].status === "ok" ? t("memory.settings.factsRunStatusOk")
+                        : factsRuns[0].status === "noop" ? t("memory.settings.factsRunStatusNoop")
+                        : factsRuns[0].status === "failed" ? t("memory.settings.factsRunStatusFailed")
+                        : String(factsRuns[0].status ?? ""))
+                      + " · " + t("memory.settings.factsRunCounts")
+                        .replace("{input}", String(Number(factsRuns[0].input_count) || 0))
+                        .replace("{ops}", String(Number(factsRuns[0].ops_applied) || 0)))
+                  : null
+              )
         ),
         // 规则 — numbered rows, hover reveals the delete affordance
         h("section", { className: "mneme-set-card" },
@@ -4922,6 +5676,10 @@ window.__ModuleLoader__.load({
           ),
           apiTokenSaved && h("div", { style: { marginTop: 8 } }, h("span", { className: "mneme-saved" }, t("memory.settings.apiTokenSaved")))
         ),
+        // 配置键覆盖面（issue #386 第 7 条）：只读核对表，放在 connect 组尾——
+        // 它与上面的 API Token / 独立服务同属「我在这台机器上能调什么」那一类，
+        // 而不是功能开关（那些在 personal/core/enhance 各组里改）。
+        h(ConfigKeysCard, { t }),
         // —— 帮助：支持与鼓励（图标行 + 检测更新 + star，兼当「关于」收尾） ——
         groupHead("help"),
         // 反馈三入口：新建 issue 预填（版本+平台）/ 邮件 / 浏览已知问题。
@@ -4997,6 +5755,16 @@ window.__ModuleLoader__.load({
     // 上下文裁不住它；运行时拒绝 react-dom 时就地渲染（position:fixed 仍然成立）。
     function MemoryOverlay({ t }) {
       const [open, setOpen] = useOverlayOpen();
+      // 库内是否有请求在飞（目前只有「从目录引导」会置位）。Esc / 背板 / ✕ 三条
+      // 关闭路径都要看它：关掉弹层会把 MemoryExplorer 连同引导弹层一起卸载，
+      // 而 POST 还在飞，回来那句「新建几条、并入几条」就再没有地方显示——
+      // 库写进去了，用户却以为没成功（评审 #4453225573）。
+      const [explorerBusy, setExplorerBusy] = useState(false);
+      // 用 ref 读而不是进 effect 依赖：那个 effect 在 [open] 变化时会
+      // closeBtnRef.current.focus()，若把 explorerBusy 也列进依赖，每次请求
+      // 起落都会重跑一次并抢焦点——用户正打字输目录时会被踢出输入框。
+      const explorerBusyRef = useRef(false);
+      useEffect(() => { explorerBusyRef.current = explorerBusy; }, [explorerBusy]);
       // #178：弹层焦点管理——打开时把焦点移入面板（关闭按钮为入口），
       // Tab 循环圈在面板内（Tab 从最后一个元素出去回到关闭按钮），
       // Esc/关闭时把焦点还给触发元素（侧边栏入口）。
@@ -5005,7 +5773,8 @@ window.__ModuleLoader__.load({
       useEffect(() => {
         if (!open) return undefined;
         const onKey = (e) => {
-          if (e.key === "Escape") { setOpen(false); return; }
+          // 库内请求在飞时不响应 Esc：见上面 explorerBusy 的注释。
+          if (e.key === "Escape") { if (!explorerBusyRef.current) setOpen(false); return; }
           if (e.key !== "Tab" || !panelRef.current) return;
           const focusables = panelRef.current.querySelectorAll('button, input, select, textarea, a[href], [tabindex]:not([tabindex="-1"])');
           if (focusables.length === 0) return;
@@ -5033,7 +5802,7 @@ window.__ModuleLoader__.load({
       const tree = h(react.Fragment, null,
         h("div", {
           className: "mneme-backdrop",
-          onClick: () => setOpen(false),
+          onClick: () => { if (!explorerBusyRef.current) setOpen(false); },
           "aria-hidden": "true"
         }),
         h("div", { className: "mneme-overlay", role: "region", "aria-label": t("memory.view.label"), ref: panelRef },
@@ -5046,12 +5815,15 @@ window.__ModuleLoader__.load({
               type: "button",
               className: "mneme-footbtn",
               ref: closeBtnRef,
+              // 忙碌时不禁用、只标 aria-disabled：真的 disabled 会把焦点从按钮上
+              // 拿走，而 #178 的 Tab 环靠 closeBtnRef 当入口，焦点落空就出不去。
+              "aria-disabled": String(explorerBusy),
               "aria-label": t("memory.overlay.close"),
               title: t("memory.overlay.close"),
-              onClick: () => setOpen(false)
+              onClick: () => { if (!explorerBusyRef.current) setOpen(false); }
             }, "✕")
           ),
-          h("div", { className: "mneme-overlaybody" }, h(MemoryExplorer, { t }))
+          h("div", { className: "mneme-overlaybody" }, h(MemoryExplorer, { t, onBusyChange: setExplorerBusy }))
         )
       );
       if (reactDom && typeof document !== "undefined") return reactDom.createPortal(tree, document.body);
@@ -5123,7 +5895,7 @@ window.__ModuleLoader__.load({
 
     // 实体 — directory snapshot grouped by entity type.
     function EntitiesStatusCard({ t }) {
-      const [state, setState] = useState({ loading: true, error: false, total: 0, byType: [] });
+      const [state, setState] = useState({ loading: true, error: false, total: 0, totalKnown: true, byType: [] });
       useEffect(() => {
         let cancelled = false;
         const order = ["organization", "person", "project", "technology", "concept"];
@@ -5140,9 +5912,16 @@ window.__ModuleLoader__.load({
             const byType = order.concat("other")
               .filter((k) => counts.has(k))
               .map((k) => [k, counts.get(k)]);
-            setState({ loading: false, error: false, total: list.length, byType });
+            // 大数字用后端回的全库 total；分类型小行仍来自本次切片（最近 500 个），
+            // 两个口径不一样，切片写进 foot 里说清楚——以前 total 取 list.length，
+            // 一万六千个实体永远显示成 500，看着像"实体太少"。
+            // totalExact 为假（计数失败 / 老宿主）时 total 只是切片长度，不能当全库数
+            // 显示：那正是原来「永远 500」的错法。这时大数字显示“—”，脚注说明总数读不到。
+            const totalKnown = j.totalExact === true && typeof j.total === "number";
+            const realTotal = totalKnown ? j.total : list.length;
+            setState({ loading: false, error: false, total: realTotal, totalKnown, sampled: list.length < realTotal, byType });
           })
-          .catch(() => { if (!cancelled) setState({ loading: false, error: true, total: 0, byType: [] }); });
+          .catch(() => { if (!cancelled) setState({ loading: false, error: true, total: 0, totalKnown: true, byType: [] }); });
         return () => { cancelled = true; };
       }, []);
       const rows = state.byType.map(([ty, n]) => ({ label: entityTypeLabel(t, ty), value: String(n) }));
@@ -5151,8 +5930,11 @@ window.__ModuleLoader__.load({
         title: t("memory.status.entities"),
         loading: state.loading,
         error: state.error,
-        num: state.total.toLocaleString(),
-        rows
+        num: state.totalKnown === false ? "—" : state.total.toLocaleString(),
+        rows,
+        foot: state.totalKnown === false
+          ? t("memory.status.entitiesUnknown")
+          : state.sampled === true ? t("memory.status.entitiesSampled") : null
       });
     }
 
@@ -5433,6 +6215,8 @@ window.__ModuleLoader__.load({
             setResult(r.body);
             setArmed(false);
             setRunning(false);
+            // 回收确认模式真的删了行：主列表/实体页/工作台的计数都变了，广播重取。
+            broadcastStoreChanged("reclaim");
           })
           .catch(() => { setResultError(t("memory.status.maint.failed")); setRunning(false); });
       };
@@ -5613,6 +6397,76 @@ window.__ModuleLoader__.load({
       });
     }
 
+    // --- 配置键覆盖面（issue #386 第 7 条）---
+    // 面板能改的键（settings.js 白名单）与 schema 里真有的键是两张表，从没被摆在一起
+    // 对过。这条卡把它们交/差出来，回答一个具体问题：**「我在配置文件里看到的这个键，
+    // 为什么在面板上找不到」**——答案要么是「它只能改文件」（fileOnly），要么是「它
+    // 登记了却没默认值」（undefaulted，见 config-keys.js 对 dreamProvider 的说明）。
+    //
+    // 只显示键名，一个值都不显示：apiToken 的名字出现在「仅配置文件」里正是这条 issue
+    // 想让人看见的（否则用户不知道它存在），值则一律不出服务端。
+    //
+    // 默认收起：这是一张核对表，不是日常要看的东西。做只读清单而不是补一批输入框，
+    // 也是维护者在 issue 里给的接手口径（「做成只读清单就能先关掉大部分价值」）。
+    function ConfigKeysCard({ t }) {
+      const [state, setState] = useState({ loading: true, data: null, failed: false });
+      const [open, setOpen] = useState(false);
+      useEffect(() => {
+        let cancelled = false;
+        apiFetch("/api/dsh-mneme/config-keys")
+          .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+          .then((j) => { if (!cancelled) setState({ loading: false, data: j, failed: false }); })
+          .catch(() => { if (!cancelled) setState({ loading: false, data: null, failed: true }); });
+        return () => { cancelled = true; };
+      }, []);
+      const d = state.data;
+      const counts = (d && d.counts) || null;
+      const fileOnly = (d && d.fileOnly) || [];
+      const undefaulted = (d && d.undefaulted) || [];
+      const title = t("memory.settings.configKeys.title");
+      const body = state.loading
+        ? h("div", { className: "mneme-set-hint" }, "…")
+        // 取数失败与「真的没有只读键」必须分开说：把失败画成 0 条，人会以为清单就是空的。
+        : state.failed || !counts
+          ? h("div", { className: "mneme-set-hint", style: { color: "var(--mneme-danger)" } },
+            t("memory.settings.configKeys.loadFailed"))
+          : h(react.Fragment, null,
+            h("div", { className: "mneme-set-hint", style: { marginTop: 4 } },
+              t("memory.settings.configKeys.summary")
+                .replace("{schema}", String(counts.schemaLeaf))
+                .replace("{panel}", String(counts.panelEditable))
+                .replace("{file}", String(counts.fileOnly))
+                // 三类的数字必须都来自服务端算出来的桶：写成 schema − panel 会与展开后
+                // 「只能改文件」那段对不上（评审 #4452245244），因为 schema 之外还多出
+                // 白名单里登记了却没默认值的那几个键。
+                .replace("{undefaulted}", String(counts.undefaulted))),
+            open && h("div", { style: { marginTop: 10 } },
+              // 两段各自的标题也带上条数，收起时只看 summary 就够判断要不要展开。
+              h("div", { className: "mneme-featsubhint", style: { marginTop: 2 } },
+                t("memory.settings.configKeys.fileOnlyHead")
+                  .replace("{n}", String(fileOnly.length))),
+              h("div", { className: "mneme-keylist" },
+                fileOnly.map((k) => h("code", { key: k, className: "mneme-keychip" }, k))),
+              undefaulted.length > 0 && h(react.Fragment, null,
+                h("div", { className: "mneme-featsubhint", style: { marginTop: 10 } },
+                  t("memory.settings.configKeys.undefaultedHead")
+                    .replace("{n}", String(undefaulted.length))),
+                h("div", { className: "mneme-keylist" },
+                  undefaulted.map((k) => h("code", { key: k, className: "mneme-keychip" }, k))),
+                h("div", { className: "mneme-featsubhint", style: { marginTop: 4 } },
+                  t("memory.settings.configKeys.undefaultedHint"))
+              )
+            ),
+            h("button", { type: "button", className: "mneme-btn", style: { marginTop: 10 }, onClick: () => setOpen(!open) },
+              open ? t("memory.settings.configKeys.hide") : t("memory.settings.configKeys.show"))
+          );
+      return h("section", { className: "mneme-set-card" },
+        h("div", { className: "mneme-set-title" }, title),
+        h("div", { className: "mneme-set-desc" }, t("memory.settings.configKeys.desc")),
+        body
+      );
+    }
+
     // --- Token 去向三屏（2026-10 可观测性改造）---
     // 原 LlmStatusCard 只有一个「LLM 消耗」总数，且 by_source 把两个最大成本项
     // dream_consolidate / dream_summarize 合并成 autoDream（2026-10 审计里巩固
@@ -5654,6 +6508,11 @@ window.__ModuleLoader__.load({
     function TokenFlowSection({ t }) {
       const [stats, setStats] = useState(null);
       const [heatStats, setHeatStats] = useState(null);
+      // 沉淀曲线（/semantic/consolidation-stats）与 token 审计不同源：前者读
+      // memories.created_at / receipt_chain / archived_at，与「花了多少 token」
+      // 无关，所以是独立请求、独立 error 位——一个失败不该把另一个图也拖成错误态。
+      const [sinkStats, setSinkStats] = useState(null);
+      const [sinkError, setSinkError] = useState(false);
       const [statsError, setStatsError] = useState(false);
       // #521 评审：待确认冲突与「上一轮跳过明细」同源（/dream-status），一次请求两用。
       // 跳过明细必须出现在首屏——它原先只挂在折叠区里的 DreamStatusCards 上，而那个
@@ -5680,6 +6539,14 @@ window.__ModuleLoader__.load({
             setHeatStats(j && typeof j === "object" ? (j.stats || j) : {});
           })
           .catch(() => { if (!cancelled) setHeatStats({}); });
+        // 沉淀曲线同样要 56 天窗口，理由与热力一致（7 天的 by_day 撑不满 8 周）。
+        apiFetch("/api/dsh-mneme/semantic/consolidation-stats?days=56")
+          .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+          .then((j) => {
+            if (cancelled) return;
+            setSinkStats(j && typeof j === "object" ? j : {});
+          })
+          .catch(() => { if (!cancelled) setSinkError(true); });
         // KPI 第 4 格的待确认冲突与 DreamStatusCards 同源（/dream-status），
         // 同样监听 mneme:conflicts-changed 重取（#295），两处计数永不漂移。
         const loadConflicts = () => {
@@ -5703,7 +6570,14 @@ window.__ModuleLoader__.load({
         };
         loadConflicts();
         window.addEventListener("mneme:conflicts-changed", loadConflicts);
-        return () => { cancelled = true; window.removeEventListener("mneme:conflicts-changed", loadConflicts); };
+        // 通用失效广播：KPI 第 4 格的待确认计数不只随裁决变——涉及冲突的
+        // 记忆被删除/恢复也一样，两个事件都听，取数只有一次 GET。
+        window.addEventListener("mneme:store-changed", loadConflicts);
+        return () => {
+          cancelled = true;
+          window.removeEventListener("mneme:conflicts-changed", loadConflicts);
+          window.removeEventListener("mneme:store-changed", loadConflicts);
+        };
       }, []);
 
       const loading = !stats && !statsError;
@@ -5799,6 +6673,42 @@ window.__ModuleLoader__.load({
         for (const d of [1, 3, 5]) rows[(d - startDow + 7) % 7] = ["一", "三", "五"][[1, 3, 5].indexOf(d)];
         return rows;
       })();
+      // 8 周沉淀：56 天原始序列在热力右侧那条约 220px 的竖列里会细到看不出，
+      // 所以按周聚成 8 桶（右端对齐今天 UTC，与 7 天柱状同一套「补连续区间」
+      // 口径，缺周填 0）。三条线只画两条——新增与巩固是这张图要表达的剪刀差，
+      // 归档数改在图例里给总量（它从 10-12 才开始非零，混进同一坐标会误导）。
+      // sinkStats 为 null（未到）与 {}（已知为空）必须分开：前者不画图，后者
+      // 画空态，否则加载态会先画 8 根零高柱子。
+      const sinkDays = (() => {
+        if (!sinkStats) return null;
+        const rows = Array.isArray(sinkStats.by_day) ? sinkStats.by_day : [];
+        const byDay = new Map(rows.map((d) => [String((d && d.day) ?? ""), d]));
+        const out = [];
+        for (let w = 7; w >= 0; w--) {
+          let added = 0;
+          let merged = 0;
+          let archived = 0;
+          let first = "";
+          for (let i = 6; i >= 0; i--) {
+            const key = new Date(endDay.getTime() - (w * 7 + i) * 86400000).toISOString().slice(0, 10);
+            if (!first) first = key;
+            const row = byDay.get(key);
+            added += Number((row && row.added) ?? 0);
+            merged += Number((row && row.merged) ?? 0);
+            archived += Number((row && row.archived) ?? 0);
+          }
+          out.push({ key: first, added, merged, archived });
+        }
+        return out;
+      })();
+      const sinkMax = Math.max(1, ...((sinkDays ?? []).map((d) => d.added)));
+      const sinkSum = (field) => (sinkDays ?? []).reduce((a, d) => a + d[field], 0);
+      const sinkAddedTotal = sinkSum("added");
+      const sinkMergedTotal = sinkSum("merged");
+      const sinkArchivedTotal = sinkSum("archived");
+      // 巩固/新增的比值取自总量而非逐周：单周可能新增为 0（无分母），总量口径
+      // 才是「这个库到底在膨胀还是在巩固」的答案。
+      const sinkGap = sinkAddedTotal > 0 ? `${((sinkMergedTotal / sinkAddedTotal) * 100).toFixed(0)}%` : "—";
       const kpi = (title, num, cap) =>
         h(StatusCard, { t, title, loading, error: statsError, num, cap });
       const segClass = (s) =>
@@ -5892,29 +6802,76 @@ window.__ModuleLoader__.load({
           h("div", { className: "mneme-barlabels" },
             days.map((d) => h("span", { key: d.day }, d.day.slice(5)))
           ),
-          h("h3", { className: "mneme-xcolhead" }, t("memory.status.token.heat")),
-          // 月份行与格子列同用列主序网格对齐：每月占的列数 = 该月在这个
-          // 56 天窗口里的列数（按列的起始日期算），标签只在该列起点画一次。
-          h("div", { className: "mneme-heatmonths" },
-            monthLabels.map((m) => h("span", { key: m.key, style: { gridColumn: `${m.from} / span ${m.span}` } }, m.label))
-          ),
-          h("div", { className: "mneme-heatwrap" },
-            h("div", { className: "mneme-heatrows", "aria-hidden": "true" },
-              heatRowLabels.map((d, i) => h("span", { key: i }, d))
+          // 热力与沉淀并排两列：热力只有约 745px，右侧原本整块空着。两列
+          // 在窄容器里回落单列（见 .mneme-flowrow 的 @container）。
+          h("div", { className: "mneme-flowrow" },
+            h("div", { className: "mneme-flowheat" },
+              h("h3", { className: "mneme-xcolhead" }, t("memory.status.token.heat")),
+              // 月份行与格子列同用列主序网格对齐：每月占的列数 = 该月在这个
+              // 56 天窗口里的列数（按列的起始日期算），标签只在该列起点画一次。
+              h("div", { className: "mneme-heatmonths" },
+                monthLabels.map((m) => h("span", { key: m.key, style: { gridColumn: `${m.from} / span ${m.span}` } }, m.label))
+              ),
+              h("div", { className: "mneme-heatwrap" },
+                h("div", { className: "mneme-heatrows", "aria-hidden": "true" },
+                  heatRowLabels.map((d, i) => h("span", { key: i }, d))
+                ),
+                h("div", { className: "mneme-heatgrid" },
+                  heatCells.map((c) => h("div", {
+                    key: c.key,
+                    className: heatLevel(c.total, heatQ) ? `mneme-heatcell l${heatLevel(c.total, heatQ)}` : "mneme-heatcell",
+                    title: `${c.key} · ${c.total.toLocaleString()}`
+                  }))
+                )
+              ),
+              h("div", { className: "mneme-heatlegend" },
+                h("span", null, t("memory.status.token.heatLess")),
+                h("span", { className: "mneme-heatcell" }),
+                [1, 2, 3, 4].map((lv) => h("span", { key: lv, className: `mneme-heatcell l${lv}` })),
+                h("span", null, t("memory.status.token.heatMore"))
+              )
             ),
-            h("div", { className: "mneme-heatgrid" },
-              heatCells.map((c) => h("div", {
-                key: c.key,
-                className: heatLevel(c.total, heatQ) ? `mneme-heatcell l${heatLevel(c.total, heatQ)}` : "mneme-heatcell",
-                title: `${c.key} · ${c.total.toLocaleString()}`
-              }))
+            h("div", { className: "mneme-flowsink" },
+              h("h3", { className: "mneme-xcolhead" }, t("memory.status.token.sink")),
+              sinkError
+                ? h("div", { className: "mneme-statuscap", style: { color: "var(--mneme-danger)" } }, t("memory.status.error"))
+                : !sinkDays
+                  // 未到：什么都不画。画空态会把「还没加载完」说成「最近没有记录」。
+                  ? null
+                  : sinkAddedTotal + sinkMergedTotal + sinkArchivedTotal === 0
+                  ? h("div", { className: "mneme-statuscap", style: { marginTop: "12px" } }, t("memory.status.token.sinkEmpty"))
+                  : h("div", { className: "mneme-sinkchart" },
+                      (sinkDays ?? []).map((d) => h("div", { className: "mneme-sinkcol", key: d.key },
+                        // 两根柱同一基准（本期最大新增），高度差就是剪刀差本身；
+                        // 巩固可能远小于新增，故给 1px 下限免得整根消失。
+                        h("div", {
+                          className: "mneme-sinkbar mneme-sinkbar--added",
+                          style: { height: `${Math.max((d.added / sinkMax) * 100, d.added > 0 ? 1 : 0)}%` },
+                          title: `${d.key} · ${t("memory.status.token.sinkAdded")} ${d.added}`
+                        }),
+                        h("div", {
+                          className: "mneme-sinkbar mneme-sinkbar--merged",
+                          style: { height: `${Math.max((d.merged / sinkMax) * 100, d.merged > 0 ? 1 : 0)}%` },
+                          title: `${d.key} · ${t("memory.status.token.sinkMerged")} ${d.merged}`
+                        })
+                      ))
+                    ),
+              sinkDays && !sinkError
+                ? h("div", { className: "mneme-sinklabels" },
+                    sinkDays.map((d) => h("span", { key: d.key }, d.key.slice(5)))
+                  )
+                : null,
+              // 图例只在有数据时给：加载中把三个 0 画出来等于谎报「最近没东西进库」。
+              sinkDays && !sinkError
+                ? h("div", { className: "mneme-sinklegend" },
+                    h("span", null, `${t("memory.status.token.sinkAdded")} `, h("b", null, sinkAddedTotal.toLocaleString())),
+                    h("span", null, `${t("memory.status.token.sinkMerged")} `, h("b", null, sinkMergedTotal.toLocaleString())),
+                    h("span", null, `${t("memory.status.token.sinkArchived")} `, h("b", null, sinkArchivedTotal.toLocaleString())),
+                    h("span", null, `${t("memory.status.token.sinkGap")} `, h("b", null, sinkGap))
+                  )
+                : null,
+              h("div", { className: "mneme-statuscap", style: { marginTop: "6px", fontSize: "11px" } }, t("memory.status.token.sinkFoot"))
             )
-          ),
-          h("div", { className: "mneme-heatlegend" },
-            h("span", null, t("memory.status.token.heatLess")),
-            h("span", { className: "mneme-heatcell" }),
-            [1, 2, 3, 4].map((lv) => h("span", { key: lv, className: `mneme-heatcell l${lv}` })),
-            h("span", null, t("memory.status.token.heatMore"))
           )
         )
       );
@@ -5967,9 +6924,15 @@ window.__ModuleLoader__.load({
         };
         loadOnce();
         // #295 评审：裁决完成后队列会广播 mneme:conflicts-changed，这里重取
-        // 计数，状态卡的「待确认冲突」不再停留旧值。
+        // 计数，状态卡的「待确认冲突」不再停留旧值。涉及冲突的记忆被删除/
+        // 恢复同样改变计数，通用失效广播一并听。
         window.addEventListener("mneme:conflicts-changed", loadOnce);
-        return () => { cancelled = true; window.removeEventListener("mneme:conflicts-changed", loadOnce); };
+        window.addEventListener("mneme:store-changed", loadOnce);
+        return () => {
+          cancelled = true;
+          window.removeEventListener("mneme:conflicts-changed", loadOnce);
+          window.removeEventListener("mneme:store-changed", loadOnce);
+        };
       }, []);
       // #495：这张卡的标题是「最近巩固」，取数就该是巩固轮，而不是 runs[0]。
       // organize 与巩固共用 dream_runs，一次 agent 主动整理会写两行（dryRun 报告 +
@@ -6123,6 +7086,14 @@ window.__ModuleLoader__.load({
           .catch(() => { setItems([]); setLoadError(true); });
       };
       useEffect(() => { load(); }, []);
+      // 参与记忆在别处被删除/编辑时（通用失效广播），队列联表出的那一侧会失真
+      // ——重取，宁可多一次 GET 也不把「已失联」装成「还在」。
+      useEffect(() => {
+        const onChanged = () => load(true);
+        window.addEventListener("mneme:store-changed", onChanged);
+        return () => window.removeEventListener("mneme:store-changed", onChanged);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+      }, []);
       // #177：空队列不再整块消失——空态教育卡要渲染（原 return null 已移除）。
       if (!items) return null;
       const resolve = (id, winner) => {
@@ -6143,6 +7114,10 @@ window.__ModuleLoader__.load({
             // 读一次 dream-status，不广播的话状态卡停留在旧计数。同页两个组件
             // 用一个 window 事件对齐（比提升状态到 StatusPanel 少动三处）。
             try { window.dispatchEvent(new CustomEvent("mneme:conflicts-changed")); } catch { /* 非浏览器环境 */ }
+            // 裁决会归档败者、给胜者追加已否决注记——记忆列表、实体页、归档
+            // 工作台的数据全变了，走通用失效广播让它们立刻重取（用户反馈：
+            // 以前要关面板重开才能看到裁决落地）。
+            broadcastStoreChanged("conflict-resolve");
             load(true);
           })
           .catch(() => {})
@@ -6310,6 +7285,13 @@ window.__ModuleLoader__.load({
         return () => { cancelled = true; };
       }, [wbReload]);
       useEffect(() => { load(); }, [load]);
+      // 工作台三份列表（活动流/沉淀/归档）都读库：别处改库（裁决/删除/导入…）
+      // 广播过来就整组重取——此前只有本组件自己的恢复按钮会刷新它。
+      useEffect(() => {
+        const onChanged = () => setWbReload((k) => k + 1);
+        window.addEventListener("mneme:store-changed", onChanged);
+        return () => window.removeEventListener("mneme:store-changed", onChanged);
+      }, []);
 
       const restore = (id) => {
         setRestoring(id);
@@ -6322,6 +7304,8 @@ window.__ModuleLoader__.load({
           .then(() => {
             setArchived((cur) => (cur || []).filter((m) => m.id !== id));
             setArchivedTotal((n) => Math.max(0, n - 1));
+            // 恢复让行回到主列表：记忆页与实体页不知道这次 /update，广播让它们重取。
+            broadcastStoreChanged("memory-restore");
           })
           .catch(() => {})
           .finally(() => setRestoring(""));
@@ -7011,6 +7995,98 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // --- 从目录引导弹层（issue #386 第 6 条）---
+    // 后端能力早在 #220 就实现了（src/bootstrap.js：六类确定性产物，零 LLM，吃
+    // saveWithDedupe 的 (type,title,scope) 去重），但只有 Bearer 数据面一条入口，
+    // 面板够不着——用户照文档找过来，发现产品界面里没有这个东西。
+    //
+    // 与 ImportDialog 的两处刻意的不同：
+    // 1. 成功路径**不**重复 setBusy(false)。这里没有「同键再提交一次会追加正文」的
+    //    风险（bootstrap 是 _overwrite 刷新），但 900ms 的提示阅读时间同样成立；
+    //    更要紧的是这一段里组件仍挂着，按钮若重新可点，人会以为「没反应」再点一次。
+    //    定时器句柄存进 ref，卸载时清掉——否则第二次提交的结果会写进已卸载的组件
+    //    （#386 第 6 条评审）。
+    // 2. 错误按服务端的码分开说。「目录不存在」「不是目录」「能力没接线」三种情况下
+    //    用户该做的事完全不同，统一成一句「引导失败」等于让他自己猜。
+    function BootstrapDialog({ t, onClose, onImported, onBusyChange }) {
+      const [dir, setDir] = useState("");
+      const [busy, setBusy] = useState(false);
+      const [msg, setMsg] = useState("");
+      const [err, setErr] = useState("");
+      const timerRef = useRef(null);
+      useEffect(() => () => { if (timerRef.current) clearTimeout(timerRef.current); }, []);
+      // 忙碌状态要让外面也知道：菜单那个「⋯」在请求进行中若把弹层卸掉，等于绕过
+      // 了下面那两个 disabled 的按钮，请求还在飞、界面已经没了（评审 #4452245292）。
+      useEffect(() => { if (onBusyChange) onBusyChange(busy); }, [busy, onBusyChange]);
+      useEffect(() => () => { if (onBusyChange) onBusyChange(false); }, [onBusyChange]);
+      const submit = () => {
+        if (busy) return;
+        const target = String(dir || "").trim();
+        if (!target) { setErr(t("memory.explorer.bootstrapNoDir")); return; }
+        setBusy(true);
+        // 同步告诉父组件，别等下面那个 effect：effect 要等这次渲染提交后才跑，
+        // 中间那一拍父组件的 bootstrapBusy 还是 false，此时点「⋯」仍会把弹层卸掉，
+        // 请求的成功或失败就再没有地方显示（评审 #4452539705）。
+        if (onBusyChange) onBusyChange(true);
+        setErr("");
+        apiFetch("/api/dsh-mneme/bootstrap", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          // 传原串（不 trim）：前后空格在多数文件系统里是合法路径的一部分，
+          // 服务端也只是 trim 判空、回传原值。
+          body: JSON.stringify({ dir })
+        })
+          .then((res) => res.json().then((d) => ({ ok: res.ok, d })))
+          .then(({ ok, d }) => {
+            if (!ok) {
+              const code = d && d.error;
+              const key = "memory.explorer.bootstrapErr." + String(code || "");
+              const localized = t(key);
+              // t() 对未知键原样返回键名——那就退回通用文案，别把键名甩给用户。
+              setErr(localized === key ? t("memory.explorer.bootstrapFailed") : localized);
+              setBusy(false);
+              return;
+            }
+            setMsg(t("memory.explorer.bootstrapDone")
+              .replace("{n}", String((d && d.created) ?? 0))
+              .replace("{m}", String((d && d.merged) ?? 0)));
+            // onImported 同步调，只把 onClose 留在定时器里：切视图会卸载本组件并清掉
+            // timerRef，若刷新也排在那 900ms 之后，这一步就静默丢了——库已经写进去了，
+            // 列表却还是旧的（评审 #4452539711）。
+            onImported();
+            timerRef.current = setTimeout(() => onClose(), 900);
+          })
+          .catch(() => { setBusy(false); setErr(t("memory.explorer.bootstrapFailed")); });
+      };
+      return h("div", { className: "mneme-impdialog", role: "region", "aria-label": t("memory.explorer.bootstrapTitle") },
+        h("div", { className: "mneme-set-title" }, t("memory.explorer.bootstrapTitle")),
+        h("div", { className: "mneme-featsubhint", style: { marginTop: 4 } }, t("memory.explorer.bootstrapHint")),
+        h("div", { className: "mneme-improw" },
+          h("span", { className: "mneme-featnumlabel" }, t("memory.explorer.bootstrapDir")),
+          // 用文本框而不是 <input webkitdirectory>：后者给的是「选了哪个目录里的
+          // 一批文件」，拿不到目录本身，而 bootstrap 要的正是那个目录。
+          h("input", {
+            className: "mneme-set-input",
+            style: { marginBottom: 0, flex: 1, minWidth: 0 },
+            type: "text",
+            value: dir,
+            placeholder: "/path/to/project",
+            // 请求进行中锁住输入框：否则用户改成 B，回来的提示就贴在 B 旁边，
+            // 而它说的是 A 的结果（评审 #4452245279）。
+            disabled: busy,
+            onChange: (e) => { setDir(e.target.value); setErr(""); }
+          })
+        ),
+        err && h("div", { className: "mneme-featsubhint", style: { color: "var(--mneme-danger)", marginTop: 8 } }, err),
+        msg && h("div", { className: "mneme-saved", style: { marginTop: 8 } }, msg),
+        h("div", { className: "mneme-improw", style: { justifyContent: "flex-end" } },
+          h("button", { type: "button", className: "mneme-btn", disabled: busy, onClick: onClose }, t("memory.explorer.importCancel")),
+          h("button", { type: "button", className: "mneme-btn", disabled: busy, onClick: submit },
+            busy ? t("memory.explorer.bootstraping") : t("memory.explorer.bootstrapConfirm"))
+        )
+      );
+    }
+
     // --- 分享包弹层 ---
     // 这一面的支点只有一句：**看见 report 之前不给下载**。服务端一次 POST 就把包和报告
     // 一起交回，所以这一格拦不住靠协议、只能靠界面自己：CLI 那侧没人拦得住，面板至少要让
@@ -7454,7 +8530,7 @@ window.__ModuleLoader__.load({
       );
     }
 
-    function MemoryExplorer({ t }) {
+    function MemoryExplorer({ t, onBusyChange }) {
       const [view, setView] = useState("memory"); // memory | entity | status | settings
       const [items, setItems] = useState([]); // loaded browse pages, chrono desc
       const [total, setTotal] = useState(0); // server count for the current type filter
@@ -7490,6 +8566,21 @@ window.__ModuleLoader__.load({
       const [pendingIds, setPendingIds] = useState(() => new Set());
       const [menuOpen, setMenuOpen] = useState(false);
       const [importOpen, setImportOpen] = useState(false);
+      const [bootstrapOpen, setBootstrapOpen] = useState(false);
+      // 引导请求是否在飞：「⋯」按钮在忙碌时必须不关弹层（评审 #4452245292）。
+      const [bootstrapBusy, setBootstrapBusy] = useState(false);
+      // 一路直接抬到外层 MemoryOverlay：它要在 Esc / 背板 / ✕ 三条关闭路径上一起挡
+      // （评审 #4453225573）。刻意**不**用 useEffect 转报——那要等渲染提交后才跑，
+      // 中间那一拍外层守卫读到的是 false，正是 #4452539705 那条的老毛病。
+      // 走 BootstrapDialog 的回调，它的 submit 里是同步调的。
+      // better-sidebar 那个 tab 注册时不传 onBusyChange，所以这里必须容忍 undefined。
+      // 身份必须稳定：BootstrapDialog 的卸载 effect 依赖 [onBusyChange]，父组件每
+      // 重渲染一次就会先跑 cleanup 调 onBusyChange(false)——而父组件恰好是在
+      // setBootstrapBusy(true) 之后重渲染的，那一抹等于把刚置上的忙碌标记当场抹掉。
+      const reportBootstrapBusy = useCallback((v) => {
+        setBootstrapBusy(v);
+        if (onBusyChange) onBusyChange(v);
+      }, [onBusyChange]);
       const [createOpen, setCreateOpen] = useState(false);
       const [shareOpen, setShareOpen] = useState(false);
       const [receiveOpen, setReceiveOpen] = useState(false);
@@ -7519,6 +8610,16 @@ window.__ModuleLoader__.load({
         return () => { cancelled = true; };
       }, [reloadKey]);
 
+      // 通用失效广播订阅：任何改库动作（裁决/删除/编辑/导入/恢复…）都让首页
+      // 与冲突徽章立刻重取。此前列表只靠弹层成功回调、手动刷新与 30s 首页合并
+      // 续命——裁决冲突后徽章与败者归档要关面板重开才更新（用户反馈的病灶）。
+      // reloadKey 同时驱动浏览列表、搜索与上面这份 pendingIds，一个游标全带上。
+      useEffect(() => {
+        const onChanged = () => setReloadKey((k) => k + 1);
+        window.addEventListener("mneme:store-changed", onChanged);
+        return () => window.removeEventListener("mneme:store-changed", onChanged);
+      }, []);
+
       // One query string behind every browse-list fetch (initial page,
       // loadMore, auto-refresh): the type filter, importance floor and time
       // window always travel together, so counts and pagination stay
@@ -7593,7 +8694,10 @@ window.__ModuleLoader__.load({
             .catch(() => { if (!cancelled) setRemoteItems([]); });
         }, 250);
         return () => { cancelled = true; clearTimeout(timer); };
-      }, [query, semantic, searchTopK]);
+        // reloadKey 必须进依赖：导入/引导/接收成功时只递增它，而搜索态下 items 走
+        // remoteItems 那条路——少了这一格，搜索词不变就永远看不到刚进来的新行
+        // （评审 #4452245305）。
+      }, [query, semantic, searchTopK, reloadKey]);
 
       // Live view: while the memory tab is open, quietly re-fetch page 1
       // every 30s (and on every activation) so fresh memories surface
@@ -7712,6 +8816,8 @@ window.__ModuleLoader__.load({
             setRemoteItems((cur) => (cur ? cur.filter((m) => m.id !== id) : cur));
             setTotal((n) => Math.max(0, n - 1));
             setSelectedId(null);
+            // 删除同样广播：冲突队列的联表侧、实体页的关联记忆都引用这条 id。
+            broadcastStoreChanged("memory-delete");
             setToastMsg(t("memory.explorer.deleted"));
             setTimeout(() => setToastMsg(""), 2500);
           })
@@ -7724,7 +8830,10 @@ window.__ModuleLoader__.load({
 
       // 编辑保存 / 归档的本地落账：替换或移除对应行；镜像由后端重渲染。
       // 归档从所有视图移除（列表默认只看未归档），并清空选中。
+      // 调用点在服务端提交成功之后，所以这里同时是通用失效广播的发布点：
+      // 其它页签（实体/状态工作台/冲突队列）不知道这次 /update，不广播就陈旧。
       const applyMemoryUpdate = (updated, { archived = false, restored = false } = {}) => {
+        broadcastStoreChanged(archived ? "memory-archive" : restored ? "memory-restore" : "memory-edit");
         if (archived) {
           setItems((cur) => cur.filter((m) => m.id !== updated.id));
           setRemoteItems((cur) => (cur ? cur.filter((m) => m.id !== updated.id) : cur));
@@ -7785,7 +8894,18 @@ window.__ModuleLoader__.load({
         setSelectedId(target.id);
       };
 
+      // 引导请求在飞时不许离开记忆视图（评审 #4453639221）：`.mneme-xtools` 整块挂在
+      // `view === "memory"` 之下，BootstrapDialog 就在里面。任何离开这个视图的动作都会
+      // 连它一起卸载——请求还在飞、界面已经没了，那句「新建几条、并入几条」就再没有
+      // 地方显示。这里只拦「离开」的路径：jumpToMemory / browseWithFilter 是回到
+      // memory，不拦。
+      const leaveMemory = (key) => {
+        if (bootstrapBusy) return;
+        setView(key);
+      };
+
       const openGraphFor = (name) => {
+        if (bootstrapBusy) return;
         setGraphFocus(name || "");
         setView("entity");
       };
@@ -7814,9 +8934,14 @@ window.__ModuleLoader__.load({
               h("button", {
                 key: s.key,
                 type: "button",
+                // 引导请求在飞时四个视图标签一律禁用（评审 #4453639221）：离开 memory
+                // 会把整个 `.mneme-xtools` 连同里面的 BootstrapDialog 卸掉。onClick 仍
+                // 走 leaveMemory 而不是 setView——disabled 只是第一道，第二道在函数里，
+                // 免得将来有人给标签换一种可点的实现就绕过去了。
+                disabled: bootstrapBusy,
                 className: view === s.key ? "mneme-vtab mneme-active" : "mneme-vtab",
                 "aria-pressed": String(view === s.key),
-                onClick: () => setView(s.key)
+                onClick: () => leaveMemory(s.key)
               },
                 h(Icon, { name: s.key === "memory" ? "database" : s.key === "entity" ? "waypoints" : s.key === "status" ? "activity" : "settings", size: 14, className: "mneme-vtabico" }),
                 s.label
@@ -7843,39 +8968,66 @@ window.__ModuleLoader__.load({
                 "aria-label": t("memory.explorer.more"),
                 "aria-expanded": String(menuOpen),
                 title: t("memory.explorer.more"),
-                onClick: () => { setMenuOpen(!menuOpen); setImportOpen(false); setCreateOpen(false); setShareOpen(false); setReceiveOpen(false); }
+                // 引导请求在飞时整个「⋯」都不给开：菜单与引导弹层共用同一个
+                // 绝对定位锚点、同一层 z-index，弹层排在菜单之后渲染，会把
+                // 菜单顶上的两项导出盖住——它们没有 disabled，却点不到
+                // （评审 #4453225585）。不开菜单，就不存在「可点但被遮住」。
+                // 这也顺带把 #4452245292 那条锁得更死：菜单开不了，就没有
+                // 任何路径能在请求中途把引导弹层卸掉。
+                disabled: bootstrapBusy,
+                onClick: () => {
+                  setMenuOpen(!menuOpen);
+                  setImportOpen(false);
+                  // 引导弹层只在不忙的时候才关：它内部已经用 busy 禁用了取消与提交，
+                  // 这里若照旧卸载，等于给了一条绕过那两道锁的路（评审 #4452245292）。
+                  if (!bootstrapBusy) setBootstrapOpen(false);
+                  setCreateOpen(false);
+                  setShareOpen(false);
+                  setReceiveOpen(false);
+                }
               }, "⋯"),
               menuOpen && h("div", { className: "mneme-menu", role: "menu" },
-                h("button", { type: "button", role: "menuitem", onClick: () => { setCreateOpen(true); setMenuOpen(false); } },
+                // 引导请求在飞时，会挂弹层的那几项一律 disabled：这些弹层共用同一个
+                // 绝对定位锚点，后渲染的会盖住引导弹层，它那句「新建几条、并入几条」
+                // 就没地方看了（评审 #4452539738）。导出两项不挂弹层，照旧可点。
+                h("button", { type: "button", role: "menuitem", disabled: bootstrapBusy, onClick: () => { setCreateOpen(true); setMenuOpen(false); } },
                   t("memory.explorer.newMemory")),
                 h("button", { type: "button", role: "menuitem", onClick: () => { setMenuOpen(false); exportData("json"); } },
                   t("memory.explorer.exportJson")),
                 h("button", { type: "button", role: "menuitem", onClick: () => { setMenuOpen(false); exportData("markdown"); } },
                   t("memory.explorer.exportMarkdown")),
-                h("button", { type: "button", role: "menuitem", onClick: () => { setImportOpen(true); setMenuOpen(false); } },
+                h("button", { type: "button", role: "menuitem", disabled: bootstrapBusy, onClick: () => { setImportOpen(true); setMenuOpen(false); } },
                   t("memory.explorer.importMd")),
-                h("button", { type: "button", role: "menuitem", onClick: () => { setShareOpen(true); setMenuOpen(false); } },
+                h("button", { type: "button", role: "menuitem", disabled: bootstrapBusy, onClick: () => { setBootstrapOpen(true); setMenuOpen(false); } },
+                  t("memory.explorer.bootstrap")),
+                h("button", { type: "button", role: "menuitem", disabled: bootstrapBusy, onClick: () => { setShareOpen(true); setMenuOpen(false); } },
                   t("memory.explorer.sharePack")),
-                h("button", { type: "button", role: "menuitem", onClick: () => { setReceiveOpen(true); setMenuOpen(false); } },
+                h("button", { type: "button", role: "menuitem", disabled: bootstrapBusy, onClick: () => { setReceiveOpen(true); setMenuOpen(false); } },
                   t("memory.explorer.receivePack")),
               ),
               importOpen && h(ImportDialog, {
                 t,
                 onClose: () => setImportOpen(false),
-                onImported: () => setReloadKey((k) => k + 1)
+                onImported: () => { setReloadKey((k) => k + 1); broadcastStoreChanged("import"); }
+              }),
+              bootstrapOpen && h(BootstrapDialog, {
+                t,
+                onClose: () => setBootstrapOpen(false),
+                onBusyChange: reportBootstrapBusy,
+                onImported: () => { setReloadKey((k) => k + 1); broadcastStoreChanged("import"); }
               }),
               shareOpen && h(ShareDialog, { t, onClose: () => setShareOpen(false) }),
               receiveOpen && h(ReceiveDialog, {
                 t,
                 onClose: () => setReceiveOpen(false),
-                onImported: () => setReloadKey((k) => k + 1)
+                onImported: () => { setReloadKey((k) => k + 1); broadcastStoreChanged("import"); }
               }),
               createOpen && h(CreateDialog, {
                 t,
                 onClose: () => setCreateOpen(false),
                 // 新建后既刷新列表也选中新行：并入既有条目时 action 是 merged，
                 // 返回的 id 就是被并入那一行——两种情况都该把它滚进视野。
-                onCreated: (d) => { setReloadKey((k) => k + 1); if (d && d.id) setSelectedId(d.id); }
+                onCreated: (d) => { setReloadKey((k) => k + 1); broadcastStoreChanged("create"); if (d && d.id) setSelectedId(d.id); }
               })
             )
           ),
@@ -8121,6 +9273,7 @@ window.__ModuleLoader__.load({
           // （toast 形状照详情抽屉里 restored 那一条的先例，不带行号免得漂）。
           setSelectedId(null);
           setReloadKey((k) => k + 1);
+          broadcastStoreChanged("pack-undo");
           setToastMsg(t("memory.explorer.undoPackDone").replace("{n}", String(n)));
           setTimeout(() => setToastMsg(""), 2500);
         }
@@ -8141,8 +9294,10 @@ window.__ModuleLoader__.load({
     // 入口形状跟着宿主 v0.2 的侧边栏走，分两态：
     //  · 展开态：宿主把「插件 / 自动化任务」这类全局面板渲染成 nav.panelList
     //    里的 panelRow（36px 行高、透明底、图标 + 标题）。我们把按钮 portal 进
-    //    同一组并原样套用宿主 panelRow 的实时类名，于是它是该组的第三行——低调，
-    //    而不是 v0.8.10 那样长得像第二个高亮「新会话」按钮。
+    //    同一组并原样套用宿主 panelRow 的实时类名，于是它是该组的一行——低调，
+    //    而不是 v0.8.10 那样长得像第二个高亮「新会话」按钮。落点是「更多」行
+    //    之前而不是组尾：宿主 0.2.2 起把「更多」追加进同一个 nav，组尾已不再是
+    //    面板行，落在它下面会被展开的菜单盖住（#573）。
     //  · 收起态（Windows 标题栏）：panelList / regionArea / footArea 被宿主
     //    display:none，只有开关与「新会话」被改成固定在标题栏上。我们把按钮搬回
     //    标题栏、并排在「新会话」右侧（84px / 120px 的算法见上面 CSS 注释），
@@ -8205,9 +9360,13 @@ window.__ModuleLoader__.load({
         const unsubscribe = conflictBadgeCount.subscribe(setPending);
         const onChanged = () => { conflictBadgeCount.refresh(); };
         window.addEventListener("mneme:conflicts-changed", onChanged);
+        // 涉及冲突的记忆在别处被删除/恢复时 pending 集同样会变——裁决广播
+        // 之外的第二条失效路径（此前只能等 60s 兜底轮询）。
+        window.addEventListener("mneme:store-changed", onChanged);
         return () => {
           unsubscribe();
           window.removeEventListener("mneme:conflicts-changed", onChanged);
+          window.removeEventListener("mneme:store-changed", onChanged);
         };
       }, []);
       return pending;
@@ -8217,6 +9376,33 @@ window.__ModuleLoader__.load({
       return h("span", { className: "mneme-entrybadge", "aria-hidden": "true" },
         pending > 99 ? "99+" : String(pending));
     }
+    // --- 宿主内整页面板（新版宿主）：侧栏图标 + 中列整页 ---
+    // 首选承载方式：记忆库直接长在宿主中列里，与会话平级，不再叠一层背板
+    // 浮层。老宿主没声明 sidebar.panellist 时退回 footer.action + 浮层（见 apply）。
+    function SidebarPanelGlyph({ size }) {
+      // 红点复用模块级单例：图标与回落按钮共享同一个计数、同一条 60s 兜底轮询。
+      const pending = useConflictBadgeCount();
+      // 宿主 PanelRow 已经自带 button / aria-label / Tooltip / active 高亮，
+      // 这里只交一颗图形——再造一层按钮会套出两颗可聚焦元素，Tab 要停两次，
+      // 而且 host 的 selectPanel 也轮不到我们调。
+      return h("span", { className: "mneme-paneliglyph" },
+        renderMnemeMark({ size: size || 18 }),
+        h(ConflictBadge, { pending })
+      );
+    }
+
+    function MnemeMainPanel({ t }) {
+      // 进面板 = 用户准备处理冻结冲突：重取一次红点计数。理由与浮层时代
+      // openLibrary 里那次重取相同——裁决走别的路径或后台刚写过库时，计数
+      // 不该等 60s 兜底轮询才对齐。
+      useEffect(() => { conflictBadgeCount.refresh(); }, []);
+      // 不自带「回到会话」按钮：宿主的 openSession / 新建会话都会
+      // selectPanel(null)，用户点侧栏任何会话行就回得去（baleen 同样不做）。
+      return h("div", { className: "mneme-panel" },
+        h(MemoryExplorer, { t })
+      );
+    }
+
     function SidebarFallbackTrigger({ wide, t }) {
       const pending = useConflictBadgeCount();
       // #295 评审：.mneme-trigger 自身 overflow:hidden 且无定位上下文，badge
@@ -8260,6 +9446,12 @@ window.__ModuleLoader__.load({
           const list = findPanelList(region);
           return list ? list.querySelector('[class*="panelRow"]:not(.mneme-topentry-native)') : null;
         };
+        // 面板列表里的「更多」行（宿主 PanelMoreMenu 的锚点）。宿主 0.2.2 起先渲染
+        // 面板行、再把「更多」追加进同一个 nav，于是列表最后一项不再是面板行——
+        // 我们的入口若仍 appendChild 到末尾就会落在它下面，菜单一展开就盖住入口
+        // （#573）。按 [class*=] 前缀找，和其余几处一样不写死哈希类名；老宿主
+        // 没有这行时返回 null，退回追加到末尾的老行为。
+        const findMoreAnchor = (list) => list.querySelector('[class*="moreAnchor"]');
         // 占位锚点：新会话行（现役外壳里 newSession 按钮嵌在 logoRow 内，
         // 旧外壳是根的直接子按钮）。判定与生态插件的 sidebar-entry-core
         // 一致；锚点不可靠时回退到 regionArea 之前的旧位置。
@@ -8285,6 +9477,14 @@ window.__ModuleLoader__.load({
           // 列表时退回「新会话」行之后，由 .mneme-topentry-native 兜住低调行样式。
           const list = wide ? findPanelList(region) : null;
           if (list) {
+            // 落在面板组末尾、但在「更多」行之前（#573）；没有「更多」行时组尾
+            // 就是终点，退回老行为。
+            const more = findMoreAnchor(list);
+            if (more) {
+              if (created.parentElement === list && created.nextElementSibling === more) return;
+              list.insertBefore(created, more);
+              return;
+            }
             if (created.parentElement === list && created === list.lastElementChild) return;
             list.appendChild(created);
             return;
@@ -9477,13 +10677,290 @@ window.__ModuleLoader__.load({
       const t = ctx.locale.bind(NS);
       ctx.effect(() => ctx.locale.register(NS, dictionaries), "dsh-mneme: dictionaries");
 
-      // 记忆库唯一入口：sidebar.footer.action 注册作为锚点与回退；真实按钮
-      // 由 SidebarTopEntry portal 到侧边栏工作区上方。overlay 从这个常驻
-      // 插槽挂载（portal 到 body），会话切换不影响它的开关状态。
-      // v0.7.15 起不再注册 conversation.view tab——对话内嵌的面板被悬浮
-      // 输入框遮挡、挤压会话布局，sheet 页是更舒服的承载方式。
-      ctx.slots.inject("sidebar.footer.action", () => {
-        return ctx.slots.register({
+      // --- 入口座位 ---
+      // --- chorography（仓库地志）面板（M1，spec §7）---------------------
+      // 浏览页：左模块树 / 右正文 / 顶部检索。数据从 /choro/* 四条读路由来，
+      // 真源是仓库磁盘的 MD。座位无条件注册（P11）：inject 同名二次注册的
+      // cordis 语义没验证过，不赌；chorographyEnabled 关着时页面渲染「未启用」
+      // 空态（路由 409 disabled），开关生效走既有「重启生效」纪律——座位常挂
+      // 的收敛形态就是 D2 拆双 Cordis 条目时的样子。
+      function WikiGlyph({ size }) {
+        // 图形走 currentColor，粗细对比交给宿主的 active 态；不引入新色值。
+        return h("span", { className: "mneme-paneliglyph", "aria-hidden": "true" },
+          h("svg", {
+            width: size || 18, height: size || 18, viewBox: "0 0 24 24",
+            fill: "none", stroke: "currentColor", strokeWidth: 1.8,
+            strokeLinecap: "round", strokeLinejoin: "round"
+          },
+            h("path", { d: "M9 4 3 6v14l6-2 6 2 6-2V4l-6 2-6-2z" }),
+            h("path", { d: "M9 4v14" }),
+            h("path", { d: "M15 6v14" })
+          )
+        );
+      }
+
+      // 只读 MD 渲染（P13）：React 文本节点天然转义，不经过 innerHTML，无原始
+      // HTML 通道。frontmatter 折叠不显示；表格按等宽行渲染（知识库页的表都是
+      // 两三列的清单，保真优先于交互）；`code` 拆成等宽 span。
+      function renderWikiMarkdown(content) {
+        const lines = String(content ?? "").split("\n");
+        let i = 0;
+        // frontmatter：首行是 --- 时吃到下一行 ---
+        if (lines[0] && lines[0].trim() === "---") {
+          i = 1;
+          while (i < lines.length && lines[i].trim() !== "---") i++;
+          i++;
+        }
+        const out = [];
+        const inline = (text) => String(text).split(/`([^`]+)`/).map((part, idx) =>
+          idx % 2 === 1 ? h("code", { key: idx, className: "mneme-wikicode" }, part) : part
+        );
+        let list = null; // "ul" | "ol" | null
+        const flushList = () => {
+          if (list) { out.push(h(list, { key: out.length }, listItems)); listItems = []; list = null; }
+        };
+        let listItems = [];
+        let inCode = false;
+        let codeLines = [];
+        // --- 表格（v0.11.1 美化）：连续 `|` 行解析成真 table，不再按等宽行画竖线 ---
+        const splitRow = (line) => String(line).trim().replace(/^\|/, "").replace(/\|$/, "")
+          .split(/(?<!\\)\|/).map((c) => c.trim().replace(/\\\|/g, "|"));
+        const isSepRow = (cells) => cells.length > 0 && cells.every((c) => /^:?-{3,}:?$/.test(c));
+        // 路径形单元格（含 / 且以扩展名结尾）渲染成等宽 code——文件清单的第一列
+        // 是相对路径，等宽 + 深一点的底色让路径在表里一眼可辨。
+        const pathLike = (text) => /^(?!https?:)(?:[\w.-]+\/)*[\w.-]+\.[A-Za-z]{1,5}$/.test(String(text).trim());
+        const cellNodes = (text, key) => {
+          const trimmed = String(text).trim();
+          if (pathLike(trimmed)) return h("code", { key, className: "mneme-wikicode" }, trimmed);
+          return inline(trimmed);
+        };
+        let tableRows = null;
+        const flushTable = () => {
+          if (!tableRows) return;
+          const rows = tableRows;
+          tableRows = null;
+          if (rows.length === 0) return;
+          const headerCells = splitRow(rows[0]);
+          const sepIndex = rows.length > 1 && isSepRow(splitRow(rows[1])) ? 1 : -1;
+          const aligns = sepIndex >= 0
+            ? splitRow(rows[sepIndex]).map((c) => (c.endsWith(":") ? "right" : c.startsWith(":") ? "center" : null))
+            : headerCells.map(() => null);
+          const bodyStart = sepIndex >= 0 ? sepIndex + 1 : 0;
+          const head = h("thead", { key: "h" }, h("tr", null,
+            headerCells.map((c, idx) => h("th", {
+              key: idx, style: aligns[idx] ? { textAlign: aligns[idx] } : undefined,
+            }, cellNodes(c, idx)))));
+          const body = h("tbody", { key: "b" }, rows.slice(bodyStart).map((row, rIdx) => {
+            const cells = splitRow(row);
+            return h("tr", { key: rIdx }, headerCells.map((_, idx) => h("td", {
+              key: idx,
+              className: aligns[idx] === "right" ? "mneme-wikinum" : undefined,
+              style: aligns[idx] && aligns[idx] !== "right" ? { textAlign: aligns[idx] } : undefined,
+            }, cellNodes(cells[idx] ?? "", idx))));
+          }));
+          out.push(h("table", { key: out.length, className: "mneme-wikitable" }, head, body));
+        };
+        for (; i < lines.length; i++) {
+          const line = lines[i];
+          if (line.trim().startsWith("```")) {
+            if (inCode) {
+              out.push(h("pre", { key: out.length, className: "mneme-wikipre" }, codeLines.join("\n")));
+              codeLines = []; inCode = false;
+            } else { flushList(); flushTable(); inCode = true; }
+            continue;
+          }
+          if (inCode) { codeLines.push(line); continue; }
+          const heading = line.match(/^(#{1,6})\s+(.*)$/);
+          if (heading) {
+            flushList(); flushTable();
+            const level = Math.min(heading[1].length + 1, 5);
+            out.push(h(`h${level}`, { key: out.length }, inline(heading[2])));
+            continue;
+          }
+          const ul = line.match(/^\s*[-*]\s+(.*)$/);
+          const ol = line.match(/^\s*\d+[.)]\s+(.*)$/);
+          if (ul || ol) {
+            flushTable();
+            const want = ul ? "ul" : "ol";
+            if (list !== want) flushList();
+            list = want;
+            listItems.push(h("li", { key: listItems.length }, inline(ul ? ul[1] : ol[1])));
+            continue;
+          }
+          if (/^\s*\|/.test(line)) { flushList(); tableRows = tableRows ?? []; tableRows.push(line); continue; }
+          flushList(); flushTable();
+          if (/^>\s?/.test(line)) { out.push(h("blockquote", { key: out.length, className: "mneme-wikiquote" }, inline(line.replace(/^>\s?/, "")))); continue; }
+          if (line.trim() === "") continue;
+          out.push(h("p", { key: out.length }, inline(line)));
+        }
+        flushList(); flushTable();
+        if (inCode && codeLines.length > 0) out.push(h("pre", { key: out.length, className: "mneme-wikipre" }, codeLines.join("\n")));
+        return out;
+      }
+
+      function WikiMainPanel({ t }) {
+        const [state, setState] = useState({ phase: "loading", repos: [], repo: null, modules: [], edges: [], page: null, hits: [], q: "", selected: null, disabled: false, error: null, rebuilding: false, rebuildNote: null });
+        // apiFetch 是裸 fetch：非 2xx 不抛错，返回 Response。这里统一解 JSON 并把
+        // 状态码带回来——409 disabled（用户没开）/ 503 unavailable（装配缺件）
+        // 各有各的空态文案（#497 的语义分叉在这里接住）。
+        const readJson = async (res) => {
+          let data = {};
+          try { data = await res.json(); } catch { /* 空响应体 */ }
+          return { status: res.status, data };
+        };
+        const load = useCallback(async (repoRef) => {
+          try {
+            const { status, data } = await readJson(await apiFetch(`/api/dsh-mneme/choro/repos`));
+            if (status === 409) { setState((s) => ({ ...s, phase: "disabled" })); return; }
+            if (status === 503) { setState((s) => ({ ...s, phase: "unavailable" })); return; }
+            const repos = data.repos ?? [];
+            if (repos.length === 0) { setState((s) => ({ ...s, phase: "no-repo", repos: [] })); return; }
+            const ref = repoRef ?? (repos.length === 1 ? repos[0].id : null);
+            if (ref === null) { setState((s) => ({ ...s, phase: "pick-repo", repos })); return; }
+            const mod = await readJson(await apiFetch(`/api/dsh-mneme/choro/modules?repo=${encodeURIComponent(ref)}`));
+            if (mod.status !== 200) { setState((s) => ({ ...s, phase: "error", error: `modules ${mod.status}` })); return; }
+            setState((s) => ({ ...s, phase: "ready", repos, repo: mod.data.repo, modules: mod.data.modules ?? [], edges: mod.data.edges ?? [], page: null, selected: null }));
+          } catch (err) {
+            setState((s) => ({ ...s, phase: "error", error: String(err?.message ?? err) }));
+          }
+        }, []);
+        useEffect(() => { load(); }, [load]);
+        const openPage = useCallback(async (slug) => {
+          const repo = state.repo;
+          if (!repo) return;
+          setState((s) => ({ ...s, selected: slug, page: null }));
+          try {
+            const { status, data } = await readJson(await apiFetch(`/api/dsh-mneme/choro/page?repo=${encodeURIComponent(repo.id)}&slug=${encodeURIComponent(slug)}`));
+            if (status !== 200 || data.error) { setState((s) => ({ ...s, page: { error: data.error ?? `page ${status}` } })); return; }
+            setState((s) => ({ ...s, page: data.page }));
+          } catch (err) {
+            setState((s) => ({ ...s, page: { error: String(err?.message ?? err) } }));
+          }
+        }, [state.repo]);
+        const runSearch = useCallback(async (q) => {
+          setState((s) => ({ ...s, q }));
+          const repo = state.repo;
+          if (!repo || !q.trim()) { setState((s) => ({ ...s, hits: [] })); return; }
+          try {
+            const { data } = await readJson(await apiFetch(`/api/dsh-mneme/choro/search?repo=${encodeURIComponent(repo.id)}&q=${encodeURIComponent(q)}`));
+            setState((s) => ({ ...s, hits: data.hits ?? [] }));
+          } catch { setState((s) => ({ ...s, hits: [] })); }
+        }, [state.repo]);
+        // 重建骨架（收尾档 P34）：POST /choro/run（token-write），T0 apply 秒级
+        // 同步回执。T1 语义富化是长任务，不上 HTTP——按钮旁的空态/提示会引导去
+        // CLI（t1Loss 警告也从服务端原样透出）。
+        const rebuild = useCallback(async () => {
+          const repo = state.repo;
+          if (!repo || state.rebuilding) return;
+          setState((s) => ({ ...s, rebuilding: true, rebuildNote: null }));
+          try {
+            const { status, data } = await readJson(await apiFetch("/api/dsh-mneme/choro/run", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ repo: repo.id })
+            }));
+            if (status !== 200 || !data.ok) {
+              setState((s) => ({ ...s, rebuilding: false, rebuildNote: `${t("wiki.rebuild.failed")}: ${data.detail ?? data.error ?? status}` }));
+              return;
+            }
+            const r = data.receipt ?? {};
+            const loss = (r.warnings ?? []).find((w) => /T1|语义/.test(w));
+            setState((s) => ({
+              ...s,
+              rebuilding: false,
+              rebuildNote: `${t("wiki.rebuild.done")}: ${r.moduleCount ?? "?"} ${t("wiki.rebuild.modules")} / ${r.pageCount ?? "?"} ${t("wiki.rebuild.pages")}${loss ? ` — ${loss}` : ""}`
+            }));
+            await load(repo.id);
+          } catch (err) {
+            setState((s) => ({ ...s, rebuilding: false, rebuildNote: `${t("wiki.rebuild.failed")}: ${String(err?.message ?? err)}` }));
+          }
+        }, [state.repo, state.rebuilding, load, t]);
+
+        if (state.phase === "loading") return h("div", { className: "mneme-panel mneme-wikiempty" }, t("wiki.state.loading"));
+        if (state.phase === "disabled") return h("div", { className: "mneme-panel mneme-wikiempty" }, t("wiki.empty.disabled"));
+        if (state.phase === "unavailable") return h("div", { className: "mneme-panel mneme-wikiempty" }, t("wiki.state.unavailable"));
+        if (state.phase === "error") return h("div", { className: "mneme-panel mneme-wikiempty" }, `${t("wiki.state.error")}: ${state.error}`);
+        if (state.phase === "no-repo") {
+          return h("div", { className: "mneme-panel mneme-wikiempty" },
+            h("div", { className: "mneme-wikiemptytitle" }, t("wiki.panel.open")),
+            h("p", null, t("wiki.empty.noRepo")));
+        }
+        if (state.phase === "pick-repo") {
+          return h("div", { className: "mneme-panel mneme-wikiempty" },
+            h("div", { className: "mneme-wikiemptytitle" }, t("wiki.empty.pickRepo")),
+            state.repos.map((r) => h("button", {
+              key: r.id, type: "button", className: "mneme-wikitreeitem",
+              onClick: () => load(r.id)
+            }, `${r.name}`)));
+        }
+        const tree = [];
+        for (const mod of state.modules) {
+          const depth = (mod.slug.match(/-/g) || []).length;
+          tree.push(h("button", {
+            key: mod.slug,
+            type: "button",
+            className: `mneme-wikitreeitem${state.selected === mod.slug ? " mneme-active" : ""}`,
+            style: { paddingLeft: `${8 + Math.min(depth, 4) * 14}px` },
+            title: mod.title,
+            onClick: () => openPage(mod.slug)
+          }, mod.slug));
+        }
+        const pageBody = state.page
+          ? (state.page.error
+            ? h("div", { className: "mneme-wikiempty" }, state.page.error === "page-missing" ? t("wiki.state.pageMissing") : state.page.error)
+            : renderWikiMarkdown(state.page.content))
+          : h("div", { className: "mneme-wikiempty" }, t("wiki.state.pickPage"));
+        return h("div", { className: "mneme-panel" },
+          h("div", { className: "mneme-wikibar" },
+            h("span", { className: "mneme-wikirepo" }, state.repo ? `${state.repo.name}` : ""),
+            h("input", {
+              className: "mneme-wikisearch",
+              placeholder: t("wiki.search.placeholder"),
+              value: state.q,
+              onChange: (e) => runSearch(e.target.value),
+              "aria-label": t("wiki.search.placeholder")
+            }),
+            h("button", {
+              type: "button",
+              className: "mneme-wikibtn",
+              disabled: state.rebuilding,
+              title: t("wiki.rebuild.hint"),
+              onClick: rebuild
+            }, state.rebuilding ? t("wiki.rebuilding") : t("wiki.rebuild")),
+            state.rebuildNote && h("span", { className: "mneme-wikirebuildnote" }, state.rebuildNote)),
+          h("div", { className: "mneme-wikibody" },
+            h("nav", { className: "mneme-wikitree", "aria-label": t("wiki.tree.title") }, tree),
+            h("div", { className: "mneme-wikipage" },
+              state.hits.length > 0 && h("div", { className: "mneme-wikihits" },
+                state.hits.map((hit, idx) => h("button", {
+                  key: `${hit.slug}-${hit.line}-${idx}`,
+                  type: "button",
+                  className: "mneme-wikihit",
+                  onClick: () => { setState((s) => ({ ...s, hits: [] })); openPage(hit.slug); }
+                }, `${hit.slug} · ${hit.section} · L${hit.line}: ${hit.excerpt}`)),
+                h("button", { type: "button", className: "mneme-wikihitsclose", onClick: () => setState((s) => ({ ...s, hits: [] })) }, "×")),
+              pageBody)));
+      }
+
+      // 两套宿主形态，二选一，靠宿主是否声明了 sidebar.panellist 判定：
+      //  · 宿主内整页面板（首选）：sidebar.panellist 出图标、main 出中列整页。
+      //    图标长在宿主自己的面板列表里（PanelRow 自己处理点击与 aria-current），
+      //    插件只管渲染一颗 glyph，不自己造按钮、不自己调 selectPanel。
+      //  · 老宿主回落：没有这两个座位时，footer.action 出按钮 + 居中 sheet，
+      //    并保留 SidebarTopEntry 的 DOM portal（尽量把入口放到面板列表位置）。
+      // 两套都挂同一个模块级 overlay 状态，但不会同时装：panellist 一旦出现就
+      // 先把回落拆掉，否则侧栏会冒出两个记忆入口。
+      // 判定 + 装载都收在两个闭包里：谁都可以问「宿主有没有这套座位」，
+      // 也都可以在条件变化后重装回落——但同一时刻至多一份注册在册。
+      const hostHasPanelSeat = () => typeof ctx.slots.spec === "function"
+        && ctx.slots.spec("sidebar.panellist") !== undefined;
+      let footerSeat = null;
+      const dropFooterSeat = () => {
+        if (footerSeat) { footerSeat(); footerSeat = null; }
+      };
+      const mountFooterSeat = () => {
+        if (footerSeat || hostHasPanelSeat()) return;
+        footerSeat = ctx.slots.register({
           name: "sidebar.footer.action",
           id: "dsh-mneme",
           order: 0,
@@ -9496,6 +10973,56 @@ window.__ModuleLoader__.load({
           }),
           h(MemoryOverlay, { t })
         ));
+      };
+
+      ctx.slots.inject("sidebar.panellist", () => {
+        dropFooterSeat();
+        const disposeGlyph = ctx.slots.register({
+          name: "sidebar.panellist",
+          id: "dsh-mneme",
+          // 排在宿主自己的面板之后（baleen 占 45）：记忆是高频入口，但排在
+          // 已有面板之后不抢位。order 只影响列表排序，不影响可发现性。
+          order: 60,
+          label: () => t("memory.panel.open")
+        }, (props) => h(SidebarPanelGlyph, { size: props && props.size }));
+        // main 的 key 必须与上面侧栏的 id 逐字相同：宿主点面板行时调
+        // layout.selectPanel(id)，它按 options.key 在 main 槽里找 entry，
+        // 对不上直接抛 "main panel ... is not registered"。
+        const disposeMain = ctx.slots.register({
+          name: "main",
+          key: "dsh-mneme"
+        }, () => h(MnemeMainPanel, { t }));
+        // chorography 第二个座位（M1）：成对规则同上——id 与 key 逐字同为
+        // "dsh-mneme-wiki"。座位无条件注册（P11），内容层自己渲染空态；
+        // D2 拆双 Cordis 条目后这里自然变成可独立禁用的形态。
+        const disposeWikiGlyph = ctx.slots.register({
+          name: "sidebar.panellist",
+          id: "dsh-mneme-wiki",
+          order: 61,
+          label: () => t("wiki.panel.open")
+        }, (props) => h(WikiGlyph, { size: props && props.size }));
+        const disposeWikiMain = ctx.slots.register({
+          name: "main",
+          key: "dsh-mneme-wiki"
+        }, () => h(WikiMainPanel, { t }));
+        return () => {
+          disposeGlyph();
+          disposeMain();
+          disposeWikiGlyph();
+          disposeWikiMain();
+          // 座位被撤（宿主折叠该槽 / 换宿主形态）时把回落装回去：两条路径都
+          // 只靠各自的 inject 触发，谁不动谁就永远停在「没有入口」的状态。
+          mountFooterSeat();
+        };
+      });
+
+      // 老宿主回落：footer.action 这一格既能当锚点（SidebarTopEntry 靠它挂
+      // portal）也能当兜底按钮，新宿主上则整格不注册——否则侧栏两颗记忆入口。
+      ctx.slots.inject("sidebar.footer.action", () => {
+        mountFooterSeat();
+        return () => {
+          dropFooterSeat();
+        };
       });
 
       // --- better-sidebar 生态 tab（可选软依赖）---