@modusensus/dsh-mneme 0.10.0 → 0.11.0

package/lib/client.js

@@ -301,6 +301,17 @@ window.__ModuleLoader__.load({
       zh: {
         "memory.panel.empty": "暂无记忆条目",
         "memory.panel.open": "记忆",
+        "wiki.panel.open": "仓库地志",
+        "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 +333,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 一张角色卡：名字、性格、回复要求。开关打开且下方「人格定义」总闸开启时，每轮对话都会注入。",
@@ -368,7 +384,14 @@ window.__ModuleLoader__.load({
         "memory.features.personaStrictAddressing": "严格人格寻址",
         "memory.features.personaStrictAddressing.hint": "开：会话身份没有对应人格卡、或那张卡被关掉时，就不注入人格——默认卡只兜「解析不到会话身份」的会话。宿主里跑着自带身份的 bot（DS Bot 那类）时关掉这种兜底，免得两句「你是谁」撞在同一轮。默认关 = 未命中就落默认卡（历史行为）。",
         "memory.features.profileExtractEnabled": "画像提取草稿",
-        "memory.features.profileExtractEnabled.hint": "打开「设置 → 个性化 → 用户画像」里的「从记忆提取草稿」按钮：读一批活跃记忆、花一次模型调用，产一段「助手眼中的用户」草稿。草稿要你点「采用」才会写进画像，绝不自动覆盖你手写的原文。轻量档预设关（用户显式勾选仍然赢）。",
+        "memory.features.profileExtractEnabled.hint": "打开「设置 → 个性化 → 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 +413,7 @@ window.__ModuleLoader__.load({
         "memory.explorer.tabSettings": "设置",
         "memory.explorer.tabStatus": "状态",
         "memory.entities.count": "{n} 个实体",
+      "memory.entities.countSampled": "列表只列最近 {shown} 个；上方总数是全库",
         "memory.entities.pick": "从左侧选择一个实体，查看它的属性与关系",
         // 搜索框有字但一条没筛出来时用它；与 entities.none（库里真没实体）分开，
         // 否则「暂无实体」会把打错一个字误导成「你还没开抽取」。
@@ -452,6 +476,23 @@ window.__ModuleLoader__.load({
         "memory.graph.viewInGraph": "在实体视图中打开",
         "memory.graph.loading": "加载中…",
         "memory.graph.distance": "距中心 {n} 跳",
+        // issue #24 块4：被动确认的复核面。边侧卡显示权重/来源，复核区列「抬过的边」。
+        "memory.graph.weight": "权重 {w}",
+        "memory.graph.source": "来源 {s}",
+        "memory.graph.boosted.title": "被用出来的边",
+        "memory.graph.boosted.hint": "正常触达会自动抬高边的权重，这里列出被抬过的那些——抬升是唯一会改变检索形状的动作。",
+        "memory.graph.boosted.empty": "当前筛选下没有边（只列权重已高于其来源基线的边）",
+        "memory.graph.boosted.loadFailed": "这一屏没取到数据（接口不可用），不是「没有边」——稍后重试。",
+        "memory.graph.boosted.gateOff": "被动确认当前是关的，今后不会再自动抬权；下面列的是此前已经抬过的边。",
+        "memory.graph.boosted.show": "查看被用出来的边",
+        "memory.graph.boosted.hide": "收起",
+        "memory.graph.boosted.gain": "+{g}",
+        // 边的来源（#24 块2 的 RELATION_SOURCE_DEFAULTS）：决定权重的起点，
+        // 所以复核时必须和权重一起显示，否则「0.5 比 1.0 弱」这种误读无可避免。
+        "memory.graph.src.manual": "人工建立",
+        "memory.graph.src.confirmed": "人工确认",
+        "memory.graph.src.tag": "标签共现",
+        "memory.graph.src.llm": "模型抽取",
         "memory.settings.vectorTitle": "向量搜索",
         "memory.settings.vectorHint": "搜索不再只认字面：接入任意 OpenAI 兼容的 embedding 接口后，意思相近的记忆也能被召回。",
         "memory.settings.vectorEnabled": "启用向量搜索",
@@ -518,6 +559,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 的数字",
@@ -797,6 +847,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 整条不发，本机路径抹成 ~，归档与遗忘的不进。",
@@ -1079,6 +1142,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 张，点击展开）",
@@ -1093,6 +1163,17 @@ window.__ModuleLoader__.load({
       en: {
         "memory.panel.empty": "No memories yet",
         "memory.panel.open": "Memory",
+        "wiki.panel.open": "Repo Atlas",
+        "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",
@@ -1114,16 +1195,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.",
@@ -1160,7 +1246,14 @@ window.__ModuleLoader__.load({
         "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.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",
@@ -1182,6 +1275,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",
@@ -1242,6 +1336,23 @@ window.__ModuleLoader__.load({
         "memory.graph.viewInGraph": "Open in entity explorer",
         "memory.graph.loading": "Loading…",
         "memory.graph.distance": "{n} hop(s) from root",
+        // issue #24 块4：被动确认的复核面。
+        "memory.graph.weight": "weight {w}",
+        "memory.graph.source": "via {s}",
+        "memory.graph.boosted.title": "Edges put to use",
+        "memory.graph.boosted.hint": "A normal touch raises an edge's weight automatically. These are the ones that rose — raising is the only action that changes what gets recalled.",
+        "memory.graph.boosted.empty": "No edges match this filter (only edges already above their source baseline are listed)",
+        "memory.graph.boosted.loadFailed": "Couldn't load this panel (endpoint unavailable) — that is not the same as \"no edges\". Try again later.",
+        "memory.graph.boosted.gateOff": "Passive confirmation is off, so nothing more will be raised; the edges below were raised earlier.",
+        "memory.graph.boosted.show": "Show edges put to use",
+        "memory.graph.boosted.hide": "Hide",
+        "memory.graph.boosted.gain": "+{g}",
+        // 边的来源（#24 块2 的 RELATION_SOURCE_DEFAULTS）：决定权重的起点，
+        // 所以复核时必须和权重一起显示，否则「0.5 比 1.0 弱」这种误读无可避免。
+        "memory.graph.src.manual": "manual",
+        "memory.graph.src.confirmed": "confirmed",
+        "memory.graph.src.tag": "tag overlap",
+        "memory.graph.src.llm": "model-extracted",
         "memory.settings.vectorTitle": "Vector Search",
         "memory.settings.vectorHint": "Match by meaning, not just wording — connect any OpenAI-compatible embeddings API.",
         "memory.settings.vectorEnabled": "Enable vector search",
@@ -1304,6 +1415,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",
@@ -1566,6 +1686,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.",
@@ -1848,6 +1981,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)",
@@ -1934,10 +2074,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));" +
@@ -1977,6 +2119,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}",
@@ -2089,6 +2234,13 @@ window.__ModuleLoader__.load({
       ".mneme-relrow:hover{background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-reltype{flex:none;font-size:11px;line-height:16px;color:var(--mneme-accent);border:1px solid color-mix(in srgb,var(--dsw-alias-state-business-primary) 35%,transparent);border-radius:6px;padding:0 6px}",
       ".mneme-relname{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
+      // issue #24 块4 复核面：抬过的边。用虚线边色（--mneme-graphic-dim 同层）
+      // 而不是新增颜色——它表达的是「同一条边，只是被用过」，不是新类别。
+      ".mneme-boosted{margin-top:6px;padding-top:6px;border-top:1px dashed var(--dsw-alias-border-l2)}",
+      ".mneme-boostedbody{margin-top:6px}",
+      ".mneme-boostedrow{cursor:default;font-size:12px;line-height:18px;padding:5px 10px}",
+      ".mneme-boostedrow:hover{background:none}",
+      ".mneme-boostedgain{font-size:11px;color:var(--mneme-accent)}",
       // --- settings: quiet stacked sections, one concern per section ---
       ".mneme-set{flex:1;min-height:0;overflow-y:auto;padding:8px 24px 48px;box-sizing:border-box}",
       ".mneme-set-inner{max-width:720px;margin:0 auto}",
@@ -2123,6 +2275,49 @@ 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}",
+      ".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}",
+      ".mneme-wikitablerow{font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:11.5px;line-height:19px;color:var(--dsw-alias-label-secondary);white-space:pre;overflow-x:auto}",
+      ".mneme-wikiquote{margin:8px 0;padding:6px 12px;border-left:3px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-secondary);font-size:12.5px;line-height:19px}",
+      ".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 环）都可用。
@@ -2422,6 +2617,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)}",
@@ -2465,6 +2679,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}",
@@ -2790,9 +3009,12 @@ window.__ModuleLoader__.load({
     //   ④ 关系图谱  the same ego graph the old graph-only tab drew
     function EntityPanel({ t, focusEntity, onJumpMemory }) {
       const [entities, setEntities] = useState(null);
-      // #512：这条记忆的归因——窗口级（哪一段原文蒸出来的）与行级（哪一轮铸造的）。
-      // null = 还没读到（或读失败），两者要分得开，不能被当成「没有归因」。
-      const [provenance, setProvenance] = useState(null); // null = still loading
+      // 目录只取最近 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);
@@ -2801,6 +3023,10 @@ window.__ModuleLoader__.load({
       const [selected, setSelected] = useState(null); // { kind: "node"|"edge", node?|edge? }
       const [attrs, setAttrs] = useState([]);
       const [related, setRelated] = useState([]);
+      // issue #24 块4：被动确认的复核面。默认收起——它是一个「想查的时候
+      // 才查」的面，不该占实体页第一屏；展开时才去取，省一次请求。
+      const [boostedOpen, setBoostedOpen] = useState(false);
+      const [boosted, setBoosted] = useState(null); // { count, passiveConfirmEnabled, items }
       const svgRef = useRef(null);
       const posRef = useRef([]); // live simulation positions, not React state
       const dragRef = useRef(null); // { id, moved }
@@ -2811,8 +3037,12 @@ window.__ModuleLoader__.load({
         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; };
       }, []);
 
@@ -2866,6 +3096,21 @@ window.__ModuleLoader__.load({
         return () => { cancelled = true; };
       }, [entityName]);
 
+      // issue #24 块4 复核面：只在展开时取，收起时不发请求。
+      const loadBoosted = useCallback(async () => {
+        try {
+          const res = await apiFetch("/api/dsh-mneme/semantic/graph/boosted-relations?limit=100");
+          setBoosted(res.ok
+            ? await res.json()
+            : { count: 0, items: [], passiveConfirmEnabled: false, error: true });
+        } catch {
+          setBoosted({ count: 0, items: [], passiveConfirmEnabled: false, error: true });
+        }
+      }, []);
+      useEffect(() => {
+        if (boostedOpen) loadBoosted();
+      }, [boostedOpen, loadBoosted]);
+
       // Simulation: run in rAF against posRef, tick React only every few frames.
       // Re-seeds when data changes; dragging writes straight into posRef.
       useEffect(() => {
@@ -3049,8 +3294,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" }, "…"),
@@ -3096,6 +3346,17 @@ window.__ModuleLoader__.load({
               ),
               h("div", { className: "mneme-gs-meta" },
                 `${t("memory.graph.relation")} · ${formatRelativeTime(selected.edge.created_at, t)}`),
+              // issue #24 块4：复核要看得见「这条边被抬过」。weight 是当前分，
+              // source 决定它的起点（manual 1.0 / confirmed 1.0 / tag 0.3 / llm 0.4）——
+              // 只看 weight 会把「tag 边被抬到 0.5」误读成「比 manual 边弱」。
+              (selected.edge.weight !== undefined || selected.edge.source !== undefined) && h("div", { className: "mneme-gs-meta" },
+                selected.edge.weight !== undefined
+                  ? t("memory.graph.weight").replace("{w}", Number(selected.edge.weight).toFixed(2))
+                  : null,
+                selected.edge.weight !== undefined && selected.edge.source ? " · " : null,
+                selected.edge.source
+                  ? t("memory.graph.source").replace("{s}", t(`memory.graph.src.${selected.edge.source}`) || selected.edge.source)
+                  : null),
               selected.edge.memory_id && h("button", {
                 className: "mneme-footbtn",
                 onClick: () => onJumpMemory && onJumpMemory({ id: selected.edge.memory_id })
@@ -3200,7 +3461,53 @@ window.__ModuleLoader__.load({
                         h("span", { className: "mneme-reltype" }, e.relation_type),
                         h("span", { className: "mneme-relname", style: { flex: 1 } }, otherName)
                       );
-                    })
+                    }),
+                    // issue #24 块4「例外管理」的可见面。被动确认是唯一会悄悄
+                    // 改变检索形状的动作（正常触达就抬权），所以它必须有个地方
+                    // 能查——否则「自动确认」和「没人看过的自动确认」没有区别。
+                    // 默认收起：这是审计视角，不是日常视角。
+                    h("div", { className: "mneme-boosted" },
+                      h("button", {
+                        className: boostedOpen ? "mneme-chip mneme-active" : "mneme-chip",
+                        "aria-expanded": boostedOpen ? "true" : "false",
+                        onClick: () => setBoostedOpen(!boostedOpen),
+                        title: t("memory.graph.boosted.hint")
+                      }, boostedOpen ? t("memory.graph.boosted.hide") : t("memory.graph.boosted.show")),
+                      boostedOpen && h("div", { className: "mneme-boostedbody" },
+                        (() => {
+                          if (boosted === null) return h("div", { className: "mneme-hint" }, t("memory.graph.loading"));
+                          // 加载失败 ≠ 闸关：接口挂了却说「被动确认是关的」，会把人
+                          // 引去翻设置，而真正的问题是这一屏没取到数据。
+                          if (boosted.error === true) return h("div", { className: "mneme-hint" }, t("memory.graph.boosted.loadFailed"));
+                          const items = boosted.items || [];
+                          const off = boosted.passiveConfirmEnabled !== true;
+                          // 闸关 ≠ 没有数据：已经抬过的边仍然在表里，关掉闸只表示
+                          // 「今后不再自动抬」。所以先出闸关提示，再照常列历史——
+                          // 否则人永远没法复核既有的提升。
+                          // 空表提示与闸门状态无关：闸关且一条都没有时，光说「下面列的是
+                          // 此前已经抬过的边」却不给任何行，人会以为这一屏坏了。
+                          return h(react.Fragment, null,
+                            off && h("div", { className: "mneme-hint" }, t("memory.graph.boosted.gateOff")),
+                            items.length === 0
+                              ? h("div", { className: "mneme-hint" }, t("memory.graph.boosted.empty"))
+                              : h(react.Fragment, null,
+                                  h("div", { className: "mneme-hint" }, t("memory.graph.boosted.hint")),
+                                  items.map((b) => h("div", {
+                                    key: b.id,
+                                    className: "mneme-relrow mneme-boostedrow",
+                                    title: `${t("memory.graph.source").replace("{s}", t(`memory.graph.src.${b.source}`) || b.source)} · ${Number(b.weight).toFixed(2)}`
+                                  },
+                                    h("span", { className: "mneme-relname", style: { textAlign: "right", flex: 1 } }, b.from_name ?? b.from),
+                                    h("span", { className: "mneme-reltype" }, b.relation_type),
+                                    h("span", { className: "mneme-relname", style: { flex: 1 } }, `${b.to_name ?? b.to} `,
+                                      h("span", { className: "mneme-boostedgain" },
+                                        t("memory.graph.boosted.gain").replace("{g}", Number(b.gain).toFixed(2))))
+                                  ))
+                                )
+                          );
+                        })()
+                      )
+                    )
                   )
             ),
             // ② 属性 — current snapshot (valid_until IS NULL)；空层整层隐藏
@@ -3279,7 +3586,12 @@ window.__ModuleLoader__.load({
         // 人格定义页（beta）：注入总闸。分组随 enhance（行为开关，非座位闸门）；
         // 人格内容在设置页「个性化」区的人格卡。
         // 严格寻址是同一条链上的第二个口径开关（只在总闸打开时起作用）。
-        "personaEnabled", "personaStrictAddressing", "profileExtractEnabled"] },
+        "personaEnabled", "personaStrictAddressing", "profileExtractEnabled",
+        // chorography（仓库地志）的暴露闸（M1 就有的键，M3 才上 UI）：它是「是否
+        // 启用这个子系统」而不是「每轮付多少」，所以和上面这些行为开关同组；
+        // 每轮付出多少由紧随组尾的 choroSub 档位管。放组末是因为子块按组尾渲染
+        // ——档位下拉要贴着它的总闸。
+        "chorographyEnabled"] },
       { key: "group.dream", items: ["sleepModeEnabled"] },
       // v0.8.0 A4（issue #17）：作用域隔离组——标注总开关 + 严格硬过滤。
       { key: "group.scope", items: ["scopeEnabled", "strictScope"] }
@@ -3303,6 +3615,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 },
@@ -3720,6 +4035,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));
@@ -3754,7 +4087,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));
@@ -3849,6 +4182,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("");
@@ -4072,6 +4414,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",
@@ -4103,16 +4449,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;
         }
       }
 
@@ -4407,35 +4796,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 在功能开关组，双闸同真。
@@ -4567,7 +4928,45 @@ 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
         ),
         // 规则 — numbered rows, hover reveals the delete affordance
         h("section", { className: "mneme-set-card" },
@@ -4808,6 +5207,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 预填（版本+平台）/ 邮件 / 浏览已知问题。
@@ -4883,6 +5286,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/关闭时把焦点还给触发元素（侧边栏入口）。
@@ -4891,7 +5304,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;
@@ -4919,7 +5333,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 },
@@ -4932,12 +5346,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);
@@ -5009,7 +5426,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"];
@@ -5026,9 +5443,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) }));
@@ -5037,8 +5461,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
       });
     }
 
@@ -5499,6 +5926,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 审计里巩固
@@ -5540,6 +6037,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 上，而那个
@@ -5566,6 +6068,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 = () => {
@@ -5685,6 +6195,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) =>
@@ -5778,29 +6324,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"))
           )
         )
       );
@@ -6498,6 +7091,13 @@ window.__ModuleLoader__.load({
       const [saveError, setSaveError] = useState(false);
       const [copied, setCopied] = useState(false);
       const [entities, setEntities] = useState(null);
+      // #512：这条记忆的归因——窗口级（哪一段原文蒸出来的）与行级（哪一轮铸造的）。
+      // null = 还没读到（或读失败），两者要分得开，不能被当成「没有归因」。
+      // 这个 state 必须住在**读它的那个组件**里：加归因区块时它曾被误放进
+      // EntityPanel（同文件的上一个组件），于是 MemoryDrawer 的 effect 与渲染块
+      // 引用到一个不存在的绑定，一开抽屉就 ReferenceError 把整个 renderer 带走
+      // （issue #553）。同名 state 落在隔壁组件里，静态扫描与 review 都不容易看出来。
+      const [provenance, setProvenance] = useState(null); // null = still loading
       // 整包退出的两段：先干跑清点（点按钮那一发），再确认物删。撤是**物理删除**不是归档
       // （归档行仍占 share_external_id 的 UNIQUE 位，撤了会导不回来，理由在
       // src/share-import.js 的 deleteSharePack），所以这里比删除那条路多一站清点。
@@ -6890,6 +7490,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 那侧没人拦得住，面板至少要让
@@ -7333,7 +8025,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
@@ -7369,6 +8061,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);
@@ -7472,7 +8179,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
@@ -7664,7 +8374,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");
       };
@@ -7693,9 +8414,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
@@ -7722,20 +8448,41 @@ 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, {
@@ -7743,6 +8490,12 @@ window.__ModuleLoader__.load({
                 onClose: () => setImportOpen(false),
                 onImported: () => setReloadKey((k) => k + 1)
               }),
+              bootstrapOpen && h(BootstrapDialog, {
+                t,
+                onClose: () => setBootstrapOpen(false),
+                onBusyChange: reportBootstrapBusy,
+                onImported: () => setReloadKey((k) => k + 1)
+              }),
               shareOpen && h(ShareDialog, { t, onClose: () => setShareOpen(false) }),
               receiveOpen && h(ReceiveDialog, {
                 t,
@@ -8020,8 +8773,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 注释），
@@ -8096,6 +8851,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
@@ -8139,6 +8921,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 之前的旧位置。
@@ -8164,6 +8952,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;
@@ -9356,13 +10152,214 @@ 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 = [];
+        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(); inCode = true; }
+            continue;
+          }
+          if (inCode) { codeLines.push(line); continue; }
+          const heading = line.match(/^(#{1,6})\s+(.*)$/);
+          if (heading) {
+            flushList();
+            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) {
+            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;
+          }
+          flushList();
+          if (/^\s*\|/.test(line)) { out.push(h("div", { key: out.length, className: "mneme-wikitablerow" }, inline(line.trim()))); continue; }
+          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();
+        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 });
+        // 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]);
+
+        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("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,
@@ -9375,6 +10372,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（可选软依赖）---