@modusensus/dsh-mneme 0.8.15 → 0.9.0

package/lib/client.js

@@ -74,15 +74,12 @@ window.__ModuleLoader__.load({
     //    这是记忆插件（issue 走维护者自开通道）；
     //  · 宿主耦合——宿主图标名会换代（#287：Outline20 → OutlineRegular/Medium），
     //    只认某一代就取到 undefined，h(undefined) 即 React #130 把整个 slot entry
-    //    崩掉。自绘后这一整类问题消失，也不再需要「探测多代名字 + 缺名降级」。
-    // 形状：单线螺旋（记忆痕迹 / 召回回路）。规格逐条对齐宿主图标，才不像外来户：
-    // 16 栅格、fill:none、stroke:currentColor、描边 1（宿主 Regular 档）、圆头圆角。
-    // 路径是 6 段三次贝塞尔拟合同一螺旋（拟合版与逐点采样版逐像素一致，已核验），
-    // 所以源码里只有 200 字符，不是一百多个采样点。
-    // 改形状只需换 MNEME_MARK_D，并同步 assets/icon.svg（插件列表那份，同一个 d）。
-    const MNEME_MARK_D = "M4.43 12.31C2.19 10.17 2.27 6.81 4.18 4.84C6.10 2.88 9.06 2.99 10.74 4.68C12.43 6.37 12.28 8.92 10.82 10.33C9.35 11.74 7.22 11.55 6.08 10.32C4.95 9.08 5.18 7.35 6.18 6.50C6.57 6.17 7.03 5.99 7.48 5.97";
-
-    /** mneme mark 的内联 SVG；currentColor + 描边 1，随主题与字号走。 */
+    //    崩掉。改用本地 Lucide 路径数据后，不再需要「探测多代名字 + 缺名降级」。
+    // Lucide Brain（项目现有 Lucide 1.42 图标数据，ISC）；静态内嵌路径，避免插件运行时加载 ESM 包。
+    // 宿主图标名会随版本换代，因此插件标识仍由本地 helper 渲染；插件列表 SVG 与这里共用同一路径。
+    const MNEME_MARK_D = "M12 18V5M15 13a4.17 4.17 0 0 1-3-4 4.17 4.17 0 0 1-3 4M17.598 6.5A3 3 0 1 0 12 5a3 3 0 1 0-5.598 1.5M17.997 5.125a4 4 0 0 1 2.526 5.77M18 18a4 4 0 0 0 2-7.464M19.967 17.483A4 4 0 1 1 12 18a4 4 0 1 1-7.967-.517M6 18a4 4 0 0 1-2-7.464M6.003 5.125a4 4 0 0 0-2.526 5.77";
+
+    /** 24 栅格 Lucide Brain 映射到宿主 16 栅格，颜色仍随主题走。 */
     const MnemeMark = ({ size = 16, className }) => h("svg", {
       width: size,
       height: size,
@@ -92,10 +89,10 @@ window.__ModuleLoader__.load({
       xmlns: "http://www.w3.org/2000/svg",
       "aria-hidden": "true",
       stroke: "currentColor",
-      strokeWidth: 1,
+      strokeWidth: 2,
       strokeLinecap: "round",
       strokeLinejoin: "round"
-    }, h("path", { d: MNEME_MARK_D }));
+    }, h("path", { d: MNEME_MARK_D, transform: "scale(0.666667)" }));
 
     /** 渲染 mneme mark：四个入口（浮层标题栏 / footer 回退 / 侧边栏 portal / better-sidebar tab）共用同一颗。 */
     const renderMnemeMark = (props) => h(MnemeMark, props);
@@ -425,30 +422,48 @@ window.__ModuleLoader__.load({
         "memory.tab.constraint": "工程约束",
         "memory.tab.document": "文档",
         "memory.features.title": "功能开关",
-        "memory.features.desc": "控制插件在后台做哪些事。改动即时保存，重启 DSH 后生效。",
-        "memory.features.group.core": "基础",
-        "memory.features.group.enhance": "检索与增强",
-        "memory.features.group.dream": "巩固与睡眠",
-        "memory.features.group.scope": "多会话隔离",
+        "memory.features.desc": "控制插件在后台做哪些事。先看「常用」里的总开关就够了，其余项收在「全部设置」里。改动即时保存，重启 DSH 后生效。",
+        // Issue #427：分组原先按「实现」分（基础/检索与增强/巩固与睡眠/多会话隔离
+        // 是架构图的分区），而人真正会问的是四个问题：它会记住什么、它什么时候
+        // 写进去、它怎么用回来、不同会话会不会串。组名改成人话，术语留在 hint。
+        // group.basic 是首屏层：新用户不读文档就该答得出「会不会自动记」；
+        // 「别的会话能不能看到」由同在首屏的 scope 组回答。
+        "memory.features.group.basic": "常用（先动这几个）",
+        "memory.features.group.core": "它会记住什么",
+        "memory.features.group.enhance": "它什么时候写进去",
+        "memory.features.group.dream": "它怎么用回来",
+        "memory.features.group.scope": "不同会话之间",
         "memory.features.group.advanced": "高级",
-        "memory.features.advancedToggle": "高级（注入策略 · 反思 · 实验项）",
+        // 「全部设置」= 第一层折叠（issue #427 建议 1），常显只留 basic + scope
+        // 两组；「高级」是它内部的第二层（进阶 7 项）。
+        "memory.features.allToggle": "全部设置",
+        "memory.features.advancedToggle": "更少用的 7 个开关",
         "memory.features.restartHint": "重启 DSH 后生效",
         "memory.features.loadFailed": "加载失败",
-        "memory.features.autoInject": "自动注入",
-        "memory.features.autoInject.hint": "每轮对话自动携带相关记忆",
-        "memory.features.injectGuidanceEnabled": "能力说明",
-        "memory.features.injectGuidanceEnabled.hint": "教 Agent 怎么用记忆：什么时候该查、什么时候该写、拿不准就不动",
-        "memory.features.continuityRescueEnabled": "压缩边缘抢救",
-        "memory.features.continuityRescueEnabled.hint": "长对话被压缩前，先存一份「正在做什么 / 下一步 / 未决问题」的快照，让关键上下文活过压缩",
-        "memory.features.parentOff": "父开关关闭时不生效",
-        "memory.features.autoSummarize": "自动总结",
-        "memory.features.autoSummarize.hint": "对话结束自动提炼记忆条目",
-        "memory.features.hotMemoryEnabled": "热记忆",
-        "memory.features.hotMemoryEnabled.hint": "最近几轮对话原文随注入携带，不写入长期记忆",
-        "memory.features.injectTimePrefix": "对话开始注入当前时间",
-        "memory.features.injectTimePrefix.hint": "每次新会话的首轮注入一次日期与星期（默认关）",
-        "memory.features.entityExtractionEnabled": "实体抽取",
-        "memory.features.entityExtractionEnabled.hint": "从记忆中提取人物/项目/概念，图谱随之生长",
+        "memory.features.saveFailed": "保存失败",
+        // Issue #427 建议 2：条目名给「打开会怎样、关掉会怎样」，术语放末尾。
+        // 括号里的英文是设置项键名，末尾的「（BM25）」才是术语。
+        "memory.features.autoInject": "自动带上旧记忆（每轮都用）",
+        "memory.features.autoInject.hint": "开：每轮自动挑相关记忆塞给 Agent，它不用问就能想起；关：Agent 得自己调用查记忆的工具",
+        "memory.features.injectGuidanceEnabled": "顺带教 Agent 怎么用记忆",
+        "memory.features.injectGuidanceEnabled.hint": "开：在记忆工具的说明里写清什么时候该查、什么时候该写；关：只给工具不给用法",
+        "memory.features.continuityRescueEnabled": "长对话被压缩前先存一份快照",
+        "memory.features.continuityRescueEnabled.hint": "开：压缩前先存「正在做什么 / 下一步 / 未决问题」，关键上下文活过压缩；关：压缩可能把它压掉",
+        "memory.features.parentOff": "上一项关闭时不生效",
+        // 「默认 / 已改」徽标：overrides 里没有这个键 = 值来自 config schema 的
+        // 默认值，一条命令就能退回。徽标让这件事不必去读配置文件才成立。
+        "memory.features.tagDefault": "默认",
+        "memory.features.tagDefault.hint": "这一项用的是出厂默认值，没有被你改过",
+        "memory.features.tagChanged": "已改",
+        "memory.features.tagChanged.hint": "你改过这一项，它不再用默认值",
+        "memory.features.autoSummarize": "自动把对话记下来（自动注入之外）",
+        "memory.features.autoSummarize.hint": "开：对话结束自动提炼成长期记忆条目（autoSummarize）；关：只有你手动存或 Agent 主动存才有记忆",
+        "memory.features.hotMemoryEnabled": "顺带带上最近几轮原话",
+        "memory.features.hotMemoryEnabled.hint": "开：注入时把最近几轮的对话原文一并带上，Agent 眼前就是刚才聊的内容；关：只带提炼后的长期记忆。这几轮原文不会写进长期记忆（热记忆，默认开）",
+        "memory.features.injectTimePrefix": "会话开头告诉它今天几号",
+        "memory.features.injectTimePrefix.hint": "开：每个新会话的第一轮注入一次日期与星期，「今天」「上周」这类说法更稳；关：注入里不带时间（时间前缀，默认关）",
+        "memory.features.entityExtractionEnabled": "顺手抽出人名、项目和概念",
+        "memory.features.entityExtractionEnabled.hint": "开：每条新记忆里抽出人物/项目/概念，关系图谱自己长起来，也能按「谁」找记忆；关：只存整条记忆，不建关系（实体抽取，默认关）",
         "memory.features.entityExtractionProvider": "实体抽取 Provider",
         "memory.features.entityExtractionModel": "实体抽取模型",
         "memory.features.entityExtractionReasoning": "实体抽取思考强度",
@@ -464,68 +479,140 @@ window.__ModuleLoader__.load({
         "memory.features.summarizeReasoningEffort.high": "高",
         "memory.features.summarizeReasoningEffort.hint": "思考型模型建议选「低」或「关闭思考」，避免推理占满输出导致总结失败",
         "memory.features.entityExtractionModelHint": "Provider / 模型留空 = 跟随主对话模型；思考强度选「跟随默认」= 服务商默认",
-        "memory.features.codingRetrospect": "编码记忆蒸馏",
-        "memory.features.codingRetrospect.hint": "回顾写代码的完整过程（含报错与工具调用），沉淀踩坑、约束和被否决的方案",
-        "memory.features.rerankEnabled": "结果重排",
-        "memory.features.rerankEnabled.hint": "本地重排模型对召回结果精排，更慢更准",
-        "memory.features.heatEnabled": "热度衰减",
-        "memory.features.heatEnabled.hint": "像遗忘曲线一样给记忆降温：越久没用到排得越靠后，不占注入名额",
-        "memory.features.documentMemoryEnabled": "document 型记忆",
-        "memory.features.documentMemoryEnabled.hint": "Agent 写的长文档只在记忆里放一张「摘要卡」：正文仍由 Agent 保管、按需读取，注入时只带摘要，不占上下文",
-        "memory.features.resilientModelDownload": "模型下载断点续传",
-        "memory.features.resilientModelDownload.hint": "模型下载中断后从断点续传并自动重试；关闭则回到一次性下载",
-        "memory.features.searchSemanticDedup": "语义去重",
-        "memory.features.searchSemanticDedup.hint": "搜索结果中意思相近的条目只保留一条",
-        "memory.features.autoDream": "记忆巩固",
-        "memory.features.autoDream.hint": "后台自动合并、沉淀碎片记忆",
-        "memory.features.sleepModeEnabled": "睡眠模式",
-        "memory.features.sleepModeEnabled.hint": "空闲时段做分层压缩与整理",
-        "memory.features.hybridInject": "混合注入",
-        "memory.features.hybridInject.hint": "关键词 + 向量双路召回后合并注入",
-        "memory.features.selectiveInjectEnabled": "选择性注入",
-        "memory.features.selectiveInjectEnabled.hint": "按相关性筛选，只注入值得携带的记忆",
-        "memory.features.adaptiveThresholdEnabled": "自适应阈值",
-        "memory.features.adaptiveThresholdEnabled.hint": "按召回质量动态调整相关性门槛",
-        "memory.features.reflectionUpdateEnabled": "反思更新",
-        "memory.features.reflectionUpdateEnabled.hint": "巩固时允许修正已有记忆",
+        "memory.features.codingRetrospect": "写代码的过程也记下来",
+        "memory.features.codingRetrospect.hint": "开：整段编码过程（含报错与工具调用）一并回顾，沉淀踩坑、约束和被否决的方案；关：只提炼对话内容（编码记忆蒸馏，默认关）",
+        "memory.features.rerankEnabled": "搜出来的结果再精排一遍",
+        "memory.features.rerankEnabled.hint": "开：本地重排模型给召回结果重新打分，更准但更慢；关：直接用检索时的排序（结果重排，默认关）",
+        "memory.features.heatEnabled": "越久没用越靠后（像会忘）",
+        "memory.features.heatEnabled.hint": "开：像遗忘曲线一样给记忆降温，长期没用过的往后排、不占注入名额；关：一直按相关度排（热度衰减，默认关）",
+        "memory.features.documentMemoryEnabled": "长文档只存一张摘要卡",
+        "memory.features.documentMemoryEnabled.hint": "开：Agent 写的长文档在记忆里只放「摘要卡」，正文仍由 Agent 保管、按需读取，注入只带摘要；关：整篇都往上下文里带（document 型记忆，默认关）",
+        // --- v0.9.0 M.O.（Modus Operandi · 手法，beta）---
+        // M.O. = Modus Operandi，拉丁语「一个人一贯的做事方式」；也是 org 词根
+        // modus（modusensus）。界面主显示 M.O.，设置项 hint 第一句给全名。
+        "memory.actions.beta": "beta",
+        "memory.actions.notice": "提炼结果是候选，可能有错、过时、会被推翻。",
+        "memory.actions.title": "M.O. · 手法",
+        "memory.actions.open": "打开 M.O.",
+        "memory.actions.viewFull": "完整视图",
+        "memory.actions.openPane": "在右栏打开完整视图",
+        "memory.actions.announce.open": "M.O. 面板已打开",
+        "memory.actions.announce.close": "M.O. 面板已关闭",
+        "memory.actions.close": "关闭",
+        "memory.actions.candidates": "候选 {n} 条",
+        "memory.actions.runs": "最近运行",
+        "memory.actions.runOf": "运行 {n}",
+        "memory.actions.run.ok": "成功",
+        "memory.actions.run.failed": "失败",
+        "memory.actions.run.refuted": "被推翻",
+        "memory.actions.state.candidate": "候选",
+        "memory.actions.state.trusted": "可信",
+        "memory.actions.state.stale": "过时",
+        "memory.actions.state.refuted": "被推翻",
+        "memory.actions.gate.has": "有闸门证据",
+        "memory.actions.gate.none": "还没闸门",
+        "memory.actions.gate.tag": "闸",
+        "memory.actions.who.main": "主",
+        "memory.actions.who.human": "人",
+        "memory.actions.who.ci": "CI",
+        "memory.actions.ov.done": "完成判据",
+        "memory.actions.ov.trigger": "何时触发",
+        "memory.actions.band.count": "{n} 步",
+        "memory.actions.legend.states": "状态",
+        "memory.actions.detail.situation": "情形",
+        "memory.actions.detail.action": "动作",
+        "memory.actions.detail.why": "为什么",
+        "memory.actions.detail.cf": "反事实",
+        "memory.actions.detail.noCf": "该节点还没有反事实记录",
+        "memory.actions.detail.source": "来源记忆",
+        "memory.actions.credit": "复用",
+        "memory.actions.creditValue": "{n} 次 · 上次 {d} 天前",
+        "memory.actions.dep": "依赖",
+        "memory.actions.zoom.in": "放大",
+        "memory.actions.zoom.out": "缩小",
+        "memory.actions.zoom.fit": "适应宽度",
+        "memory.actions.zoom.hint": "Ctrl/⌘ + 滚轮也能缩放",
+        "memory.actions.list.heading": "这个项目里的工作流",
+        "memory.actions.list.count": "工作流 {n} 条",
+        "memory.actions.list.meta": "{steps} 步 · {gates} 道闸门 · 反事实 {cf}/{steps}",
+        "memory.actions.scope.project": "项目 {name}",
+        "memory.actions.scope.global": "全局",
+        "memory.actions.scope.none": "项目未知",
+        "memory.actions.broken": "有文件读不出来：",
+        "memory.actions.empty.title": "这个项目里还没有工作流",
+        "memory.actions.empty.body": "工作流的本体住在项目里的 .mneme/pipelines/ 下——跟着仓库走，能被提交、能被 review、能被 CI 读。做法被复用第二次才算节点类型，第一次只是实例；同一路径被走通两次之后，它才会从会话里被提炼出来、落到那个目录里。",
+        "memory.actions.noRuns": "这一条还没有运行记录，所以每个节点都还是候选。",
+        "memory.actions.settle.title": "本次运行",
+        "memory.actions.settle.line": "「{title}」",
+        "memory.actions.settle.used": "本次复用 {n} 条做法（勾选为被用上）",
+        "memory.actions.settle.refutedWarn": "本次路径里有已被推翻的节点，结果仅供参考",
+        "memory.features.actionPipelineEnabled": "M.O.（beta）",
+        "memory.features.actionPipelineEnabled.hint": "⚠️ 开发中：目前只有「看」这一层能用，自己沉淀和触发都还没做，建议暂时保持关闭。Modus Operandi（手法）：把真实会话里反复走通的「做法」连成一张只读图谱——会话头图标、右栏完整视图、每次运行的结算卡。重启 DSH 后生效",
+        "memory.features.resilientModelDownload": "模型下载断了能续上",
+        "memory.features.resilientModelDownload.hint": "开：下载中断后从断点续传并自动重试；关：中断就整份重来（断点续传，默认开）",
+        "memory.features.searchSemanticDedup": "搜到意思相同的只留一条",
+        "memory.features.searchSemanticDedup.hint": "开：检索结果里意思相近的条目合并成一条，少占名额；关：同义条目一起出现（语义去重，默认关）",
+        "memory.features.autoDream": "后台自动整理记忆（合并 · 去重）",
+        "memory.features.autoDream.hint": "开：后台自动合并、沉淀碎片记忆（autoDream）；关：记忆只增不减，越用越散",
+        "memory.features.sleepModeEnabled": "你不在的时候它整理记忆",
+        "memory.features.sleepModeEnabled.hint": "开：空闲时段做分层压缩与整理，白天少打扰；关：只有你手动触发的整理（睡眠模式，默认关）",
+        // #427 建议 5：hybridInject / selectiveInjectEnabled / adaptiveThresholdEnabled
+        // 是同一件事「带什么回来」的三档，相邻摆放并在 hint 里点明，不再摊成
+        // 三个不相干的并列开关。
+        "memory.features.hybridInject": "关键词 + 意思 两路一起找",
+        "memory.features.hybridInject.hint": "开：两路检索各取一批再合并，召回更全；关：只用一路。「带什么回来」共三档（混合注入 / 选择性注入 / 自适应阈值），可只开其中一档（混合注入，默认开）",
+        "memory.features.selectiveInjectEnabled": "只带真正相关的记忆",
+        "memory.features.selectiveInjectEnabled.hint": "开：按相关性筛一遍再注入，上下文更干净；关：带出去的更多也更杂。三档之一（选择性注入，默认开）",
+        "memory.features.adaptiveThresholdEnabled": "按检索质量自动调松紧",
+        "memory.features.adaptiveThresholdEnabled.hint": "开：召回质量差时放宽门槛、好时收紧；关：门槛固定。三档之一（自适应阈值，默认开）",
+        "memory.features.reflectionUpdateEnabled": "整理时允许改已有记忆",
+        "memory.features.reflectionUpdateEnabled.hint": "开：巩固可以改写、合并已有条目，不是只增不改；关：旧记忆永不被自动改动（反思更新，默认开）",
         "memory.features.distill": "蒸馏与限流",
         "memory.features.distillRateLimitIntervalMs": "蒸馏放行间隔 (ms)",
         "memory.features.distillRateLimitRetries": "429 重试次数",
         "memory.features.distillRateLimitBaseDelayMs": "退避起始延迟 (ms)",
         "memory.features.distillMaxChars": "转录截断上限（字符）",
+        // #399 的两个留存键。此前只有后端白名单、面板够不着，而
+        // docs/CONFIGURATION.md 写的是「面板可启停」——补 UI 让文档成真。
+        // hint 必须写清两件事：这是**原始对话**落盘（隐私面），以及天数只管
+        // 启动期裁剪（reclaim 走另一条 --older-than，不读这个键）。
+        "memory.features.distillRecords.enabled": "留存蒸馏原文",
+        "memory.features.distillRecords.enabled.hint": "蒸馏时把窗口内的公开对话原文一并落盘，并记下每条记忆的来源区间；私密推理与工具结果不落。关 = 一行不写、连收集都不做",
+        "memory.features.distillRecords.retentionDays": "原文保留天数",
+        "memory.features.distillRecords.retentionDays.hint": "1–3650 天；只管启动期裁剪。想让 reclaim 也按这个天数回收，需显式传 --older-than 同一数值",
         "memory.features.codingBoostFactor": "编码记忆加权",
-        "memory.features.memoryQualityFilter.enabled": "记忆质量过滤",
-        "memory.features.memoryQualityFilter.enabled.hint": "低价值记忆自动归档，注入按质量降权",
-        "memory.features.llmAudit.enabled": "后台调用审计",
-        "memory.features.llmAudit.enabled.hint": "记录巩固/总结的后台模型调用与 token 消耗",
+        "memory.features.memoryQualityFilter.enabled": "没价值的记忆自动收起来",
+        "memory.features.memoryQualityFilter.enabled.hint": "开：低价值条目自动归档、注入时按质量降权；关：什么都留着，噪声也一起带（记忆质量过滤，默认开）",
+        "memory.features.llmAudit.enabled": "记下后台用了多少模型调用",
+        "memory.features.llmAudit.enabled.hint": "开：巩固/总结的后台调用与 token 消耗都有账可查；关：后台开销无从核对（调用审计，默认开）",
         // #254：写入准入两层。检测关时整条路径不碰；检测开、拦截关 = 仅告警 +
         // 留审计；两个都开才真拦。文案要写清「只留审计」与「真拦下」的区别，
         // 否则操作者会以为打开检测就已经在拦。
-        "memory.features.writeAdmission.enabled": "写入准入判定",
-        "memory.features.writeAdmission.enabled.hint": "写入前判空白/噪声，命中留审计（不拦）",
-        "memory.features.writeAdmission.enforce": "写入准入拦截",
-        "memory.features.writeAdmission.enforce.hint": "真拦下命中的写入；关闭时只留审计不拦",
-        "memory.features.preInjectGate.enabled": "注入前判定",
-        "memory.features.preInjectGate.enabled.hint": "注入前判意见/立场记忆，先观察分布（不拦）",
-        "memory.features.preInjectGate.enforce": "注入前判定拦截",
-        "memory.features.preInjectGate.enforce.hint": "判定命中的候选在注入时滤除；关闭时只留审计不拦",
+        "memory.features.writeAdmission.enabled": "写入前先判一下是不是废话（只记不拦）",
+        "memory.features.writeAdmission.enabled.hint": "开：空白/噪声写入判为命中并留一条审计记录，但仍存进去；关：完全不判。要真拦，见下一项（写入准入判定，默认关）",
+        "memory.features.writeAdmission.enforce": "真把没用的写入挡下来",
+        "memory.features.writeAdmission.enforce.hint": "开：命中直接拒绝写入；关：只留审计、照存不误。需先打开上面那项判定（写入准入拦截，默认关）",
+        "memory.features.preInjectGate.enabled": "注入前先筛掉「只是我的看法」的记忆（只记不拦）",
+        "memory.features.preInjectGate.enabled.hint": "开：注入前判出意见/立场类记忆并留审计，先观察分布；关：照常注入（注入前判定，默认关）",
+        "memory.features.preInjectGate.enforce": "注入时真滤掉判定不合适的",
+        "memory.features.preInjectGate.enforce.hint": "开：命中的候选在注入时丢掉；关：只留审计、照常注入。需先打开上面那项判定（注入前判定拦截，默认关）",
         // #164 A2：密钥/PII 判据自己的闸。文案要写清它管的是哪一批判据（与上面的
         // 空白/噪声分开）、它跑在「写入准入判定」里面（那一项关着就不跑），以及
         // 「开着也不拦」——拦是上面那项的事。
-        "memory.features.sensitiveScanEnabled": "密钥/PII 扫描",
-        "memory.features.sensitiveScanEnabled.hint": "写入前扫密钥与个人信息；需先打开写入准入判定才会执行，命中只留审计，要拦再打开写入准入拦截",
-        "memory.features.bm25SearchEnabled": "BM25 关键词检索",
-        "memory.features.bm25SearchEnabled.hint": "传统关键词打分检索，与向量召回互补",
-        "memory.features.conflictFreezeEnabled": "冲突冻结",
-        "memory.features.conflictFreezeEnabled.hint": "巩固发现互相矛盾的记忆时先冻结待确认",
-        "memory.features.scopeEnabled": "作用域标注",
-        "memory.features.scopeEnabled.hint": "新记忆自动记下来自哪个会话（Agent / 工作区），供隔离与检索过滤使用",
-        "memory.features.strictScope": "严格隔离",
-        "memory.features.strictScope.hint": "开启后，其他会话明确设为私有的记忆对你完全不可见；关闭时仍可见、只是排到后面。要做到彻底隔离，请用条目的「敏感度」字段",
-        "memory.features.trustEpistemicWeighting": "可信度加权",
-        "memory.features.trustEpistemicWeighting.hint": "按来源可信度调整召回排序（实验性）",
-        "memory.features.reflectionFailureTracking": "反思失败追踪",
-        "memory.features.reflectionFailureTracking.hint": "记录巩固失败的案例供后续改进（诊断用）",
+        "memory.features.sensitiveScanEnabled": "写入前扫一遍密钥和个人信息",
+        "memory.features.sensitiveScanEnabled.hint": "开：在写入准入判定里面扫密钥/个人信息，命中只留审计；要真拦，再打开「写入准入拦截」。判定关着时它不跑（密钥/PII 扫描，默认关）",
+        "memory.features.bm25SearchEnabled": "也用关键词方式找记忆",
+        "memory.features.bm25SearchEnabled.hint": "开：多一个字少一个字也搜得到，专名、报错码、路径更易命中，与「按意思找」互补；关：只按语义相近度（BM25 关键词检索，默认开）",
+        "memory.features.conflictFreezeEnabled": "互相矛盾的记忆先冻结",
+        "memory.features.conflictFreezeEnabled.hint": "开：整理发现矛盾时先冻结待你确认，不让两条同时生效；关：两边都照用（冲突冻结，默认关）",
+        "memory.features.scopeEnabled": "记住每条记忆来自哪个会话",
+        "memory.features.scopeEnabled.hint": "开：每条新记忆标上来自哪个 Agent / 工作区，别的会话能不能看到由它说了算；关：新记忆不带来源，所有会话共用一批记忆（作用域标注，默认关）",
+        "memory.features.strictScope": "别人设为私有的记忆我看不见",
+        "memory.features.strictScope.hint": "开：其他会话明确标私有的记忆对你彻底不可见；关：仍可见、只是排到后面。要彻底隔离请用条目的「敏感度」字段。需先打开上面那项标注（严格隔离，默认关）",
+        "memory.features.trustEpistemicWeighting": "按来源可信度调排序",
+        "memory.features.trustEpistemicWeighting.hint": "开：可信度高的来源排前面；关：一视同仁（可信度加权，实验性，默认关）",
+        "memory.features.reflectionFailureTracking": "整理失败时留下案例",
+        "memory.features.reflectionFailureTracking.hint": "开：把失败原因与案例记下来供诊断改进；关：失败不留记录（失败追踪，默认开）",
         "memory.features.embedRoute": "语义检索路线",
         "memory.features.embedProvider": "Embedding 提供方",
         "memory.features.embedProvider.openai": "OpenAI 兼容接口",
@@ -553,6 +640,7 @@ window.__ModuleLoader__.load({
         "memory.features.modelTestOk": "连通正常",
         "memory.features.modelTestFail": "测试失败",
         "memory.features.modelTestHint": "真实发起一次最小巩固调用，验证 Provider/模型连通与 effort 支持",
+        "memory.features.modelTestDowngraded": "档位不被该模型接受，已去掉档位连通（与真实巩固一致）",
         "memory.features.routeStaleMark": "（不在可用列表）",
         "memory.features.routeStaleHint": "该值不在当前可用列表（常见于切换过 Provider）：请重新选择，或点「测试连通性」当场验证",
         "memory.explorer.viewCards": "卡片",
@@ -577,6 +665,20 @@ window.__ModuleLoader__.load({
         "memory.explorer.imported": "已合并 {n} 条编辑",
         "memory.explorer.importFailed": "导入失败",
         "memory.explorer.importNoFile": "请先选择文件",
+        "memory.explorer.newMemory": "新增记忆…",
+        "memory.explorer.newTitle": "新增记忆",
+        "memory.explorer.newHint": "手动写一条记忆。同类型同标题会并入既有条目，而不是长出第二行。",
+        "memory.explorer.newType": "类型",
+        "memory.explorer.newTitlePlaceholder": "短标题，也是去重键",
+        "memory.explorer.newContentPlaceholder": "正文",
+        "memory.explorer.newTagsPlaceholder": "标签，逗号分隔（可留空）",
+        "memory.explorer.newConfirm": "新建",
+        "memory.explorer.newSaving": "保存中…",
+        "memory.explorer.newCreated": "已新建",
+        "memory.explorer.newMerged": "已并入同标题的既有条目",
+        "memory.explorer.newFailed": "新建失败",
+        "memory.explorer.newNoTitle": "请先填写标题",
+        "memory.explorer.newNoContent": "请先填写内容",
         "memory.explorer.exportFailed": "导出失败",
         "memory.explorer.conflictBadge": "冲突",
         "memory.explorer.archivedBadge": "已归档",
@@ -643,6 +745,14 @@ window.__ModuleLoader__.load({
         "memory.status.conflictQueue.similarity": "相似度",
         "memory.status.conflictQueue.diffTitle": "差异已高亮：红=删除、绿=新增",
         "memory.status.conflictQueue.diffFallback": "两段文本差异较大，请对照原文阅读",
+        "memory.status.conflictQueue.expand": "展开全文",
+        "memory.status.conflictQueue.collapse": "收起全文",
+        "memory.status.conflictQueue.copySide": "复制本侧",
+        "memory.status.conflictQueue.copiedSide": "本侧全文已复制",
+        "memory.status.conflictQueue.importance": "重要度 {n}",
+        "memory.status.conflictQueue.chars": "{n} 字符",
+        "memory.status.conflictQueue.updated": "更新于 {time}",
+        "memory.status.conflictQueue.created": "创建于 {time}",
         "memory.status.conflictQueue.emptyTitle": "暂无待确认冲突",
         "memory.status.conflictQueue.emptyBody": "当巩固发现两条互相矛盾或高度相似的记忆时，会先冻结在这里等你裁决，不会自动修改。裁决前双方都不参与注入。",
         "memory.status.conflictQueue.applyHintTitle": "确认后：保留方正文追加已否决注记，另一方归档",
@@ -724,8 +834,62 @@ window.__ModuleLoader__.load({
         "memory.status.mirror.foot": "记忆条目在磁盘上的 Markdown 副本同步状态",
         "memory.status.sec.overview": "库内一览",
         "memory.status.sec.engine": "后台运转",
-        "memory.status.llm": "LLM 消耗",
-        "memory.status.llmCalls": "近 7 天 · {n} 次调用",
+        "memory.status.sec.maintenance": "维护",
+        "memory.status.maint": "存储回收",
+        "memory.status.maint.freelist": "空闲页可立刻回收",
+        "memory.status.maint.plannedInputs": "待清理输入快照",
+        "memory.status.maint.plannedEmbeddings": "待清理归档向量",
+        "memory.status.maint.window": "保留窗口",
+        "memory.status.maint.windowUnit": "天",
+        "memory.status.maint.windowLabel": "保留窗口（天）",
+        "memory.status.maint.reestimate": "重新估算",
+        "memory.status.maint.reestimating": "估算中…",
+        "memory.status.maint.stale": "窗口已改动：先点「重新估算」再执行，否则执行的是上一次估算的数字。",
+        "memory.status.maint.vacuum": "同时 VACUUM",
+        "memory.status.maint.vacuumHint": "VACUUM 会短暂独占数据库，期间其它读写要等待；不做也不影响清理结果。",
+        "memory.status.maint.execute": "执行回收",
+        "memory.status.maint.confirm": "确认执行（不可逆）",
+        "memory.status.maint.running": "执行中…",
+        "memory.status.maint.cancel": "取消",
+        "memory.status.maint.confirmHint": "将清理 {inputs} 行输入快照与 {embeddings} 行归档向量，且不可逆。",
+        "memory.status.maint.badWindow": "保留窗口要填不小于 0 的整数",
+        "memory.status.maint.failed": "回收失败",
+        "memory.status.maint.done": "回收已完成",
+        "memory.status.maint.size": "体积（前 → 后）",
+        "memory.status.maint.reclaimed": "实际释放",
+        "memory.status.maint.clearedInputs": "已清理输入快照",
+        "memory.status.maint.clearedEmbeddings": "已清理归档向量",
+        "memory.status.maint.receipt": "审计回执",
+        "memory.status.maint.receiptNone": "未记录（审计未启用或回执写入失败）",
+        "memory.status.maint.duration": "耗时",
+        "memory.status.maint.vacuumRan": "VACUUM 已执行",
+        "memory.status.maint.vacuumOff": "未 VACUUM",
+        "memory.status.maint.vacuumFailed": "VACUUM 失败",
+        "memory.status.maint.vacuumFailedHint": "清理已完成且不可逆，但文件暂时不会变小；稍后重跑即可（清理是幂等的）。",
+        "memory.status.sec.token": "Token 去向 · 近 7 天",
+        "memory.status.token.in": "输入",
+        "memory.status.token.out": "输出",
+        "memory.status.token.total": "7 天 token 总量",
+        "memory.status.token.calls": "调用次数",
+        "memory.status.token.callsCap": "近 7 天 · 全部后台组件",
+        "memory.status.token.share": "巩固占比",
+        "memory.status.token.shareFoot": "dream_consolidate · {n} token",
+        "memory.status.token.conflicts": "待确认冲突",
+        "memory.status.token.conflictsFoot": "来自 /dream-status · 实时",
+        "memory.status.token.donut": "按组件 · 谁花了这些 token",
+        "memory.status.token.days": "按天 · 7 天趋势",
+        "memory.status.token.heat": "8 周热力 · 每天花了多少",
+        "memory.status.token.heatLess": "少",
+        "memory.status.token.heatMore": "多",
+        "memory.status.token.last7": "近 7 天",
+        "memory.status.token.meterOnly": "（只计量）",
+        "memory.status.token.detail": "详细状态卡（原「库内一览 / 后台运转」9 张，点击展开）",
+        "memory.status.token.op.dream_consolidate": "记忆巩固",
+        "memory.status.token.op.summarize_compress": "会话蒸馏",
+        "memory.status.token.op.entity_extract": "实体抽取",
+        "memory.status.token.op.dream_summarize": "总览摘要",
+        "memory.status.token.op.sleep_pattern": "睡眠模式",
+        "memory.status.token.op.write_admission": "写入准入",
         "memory.status.error": "加载失败"
       },
       en: {
@@ -892,30 +1056,43 @@ window.__ModuleLoader__.load({
         "memory.tab.constraint": "Constraints",
         "memory.tab.document": "Documents",
         "memory.features.title": "Features",
-        "memory.features.desc": "Choose what the plugin does in the background. Changes are saved immediately and take effect after restarting DSH.",
-        "memory.features.group.core": "Basics",
-        "memory.features.group.enhance": "Search & enrichment",
-        "memory.features.group.dream": "Consolidation & sleep",
-        "memory.features.group.scope": "Multi-session isolation",
+        "memory.features.desc": "Choose what the plugin does in the background. The Common switches at the top are all you need to start; everything else lives under All settings. Changes are saved immediately and take effect after restarting DSH.",
+        // Issue #427: groups used to be implementation slices (the architecture
+        // diagram's partitions). What a person actually asks is four questions —
+        // what gets remembered, when it gets written, how it comes back, and
+        // whether sessions bleed into each other. Terminology stays in the hints.
+        // group.basic is the first-screen tier; the scope group sits there too so
+        // "can other sessions see this?" is answerable without opening anything.
+        "memory.features.group.basic": "Common (start here)",
+        "memory.features.group.core": "What gets remembered",
+        "memory.features.group.enhance": "When it gets written",
+        "memory.features.group.dream": "How it comes back",
+        "memory.features.group.scope": "Between sessions",
         "memory.features.group.advanced": "Advanced",
-        "memory.features.advancedToggle": "Advanced (injection · reflection · experimental)",
+        "memory.features.allToggle": "All settings",
+        "memory.features.advancedToggle": "7 rarer switches",
         "memory.features.restartHint": "Takes effect after restarting DSH",
         "memory.features.loadFailed": "Failed to load",
-        "memory.features.autoInject": "Auto injection",
-        "memory.features.autoInject.hint": "Carry relevant memories into every turn",
-        "memory.features.injectGuidanceEnabled": "Capability guide",
-        "memory.features.injectGuidanceEnabled.hint": "Teach the agent how to use memory: when to search, when to save, when to leave things alone",
-        "memory.features.continuityRescueEnabled": "Compaction-edge rescue",
-        "memory.features.continuityRescueEnabled.hint": "Before a long conversation gets compacted, store a snapshot of what's in progress / next steps / open questions so key context survives the compaction",
-        "memory.features.parentOff": "Inactive while auto injection is off",
-        "memory.features.autoSummarize": "Auto summarization",
-        "memory.features.autoSummarize.hint": "Distill memory entries when a conversation ends",
-        "memory.features.hotMemoryEnabled": "Hot memory",
-        "memory.features.hotMemoryEnabled.hint": "Carry the last few turns verbatim; never written to long-term memory",
-        "memory.features.injectTimePrefix": "Inject current time at conversation start",
-        "memory.features.injectTimePrefix.hint": "Adds the date and weekday once at each new session's first turn (off by default)",
-        "memory.features.entityExtractionEnabled": "Entity extraction",
-        "memory.features.entityExtractionEnabled.hint": "Extract people / projects / concepts so the graph grows by itself",
+        "memory.features.saveFailed": "Failed to save",
+        "memory.features.autoInject": "Carry old memories into every turn",
+        "memory.features.autoInject.hint": "On: relevant memories are handed to the agent every turn, so it remembers without being asked. Off: the agent has to call the search tool itself",
+        "memory.features.injectGuidanceEnabled": "Also teach the agent how to use memory",
+        "memory.features.injectGuidanceEnabled.hint": "On: the memory tools' description says when to search and when to write. Off: the tools ship without guidance",
+        "memory.features.continuityRescueEnabled": "Snapshot before a long chat gets compacted",
+        "memory.features.continuityRescueEnabled.hint": "On: a snapshot of what's in progress / next steps / open questions is stored before compaction, so key context survives it. Off: compaction can crush it",
+        "memory.features.parentOff": "Inactive while the switch above is off",
+        "memory.features.tagDefault": "default",
+        "memory.features.tagDefault.hint": "This one is at its factory default — you have not changed it",
+        "memory.features.tagChanged": "changed",
+        "memory.features.tagChanged.hint": "You changed this one; it no longer uses the default",
+        "memory.features.autoSummarize": "Turn conversations into memory automatically",
+        "memory.features.autoSummarize.hint": "On: memory entries are distilled when a conversation ends (autoSummarize). Off: memory only exists if you save it, or the agent decides to",
+        "memory.features.hotMemoryEnabled": "Carry the last few turns verbatim",
+        "memory.features.hotMemoryEnabled.hint": "On: the recent turns ride along with each injection, so the agent sees what was just said. Off: only distilled memories travel. Those turns are never written to long-term memory (hot memory, on by default)",
+        "memory.features.injectTimePrefix": "Tell it today's date at session start",
+        "memory.features.injectTimePrefix.hint": "On: the first turn of each new session gets the date and weekday once, so \"today\" and \"last week\" land reliably. Off: no time in the injection (time prefix, off by default)",
+        "memory.features.entityExtractionEnabled": "Also pull out people, projects and concepts",
+        "memory.features.entityExtractionEnabled.hint": "On: each new memory yields people / projects / concepts, so the relation graph grows by itself and recall can key on who. Off: memories stay whole, no relations (entity extraction, off by default)",
         "memory.features.entityExtractionProvider": "Entity extraction provider",
         "memory.features.entityExtractionModel": "Entity extraction model",
         "memory.features.entityExtractionReasoning": "Entity extraction reasoning",
@@ -931,68 +1108,134 @@ window.__ModuleLoader__.load({
         "memory.features.summarizeReasoningEffort.high": "High",
         "memory.features.summarizeReasoningEffort.hint": "For thinking models, prefer Low or No reasoning so thinking cannot fill the output budget and break summaries",
         "memory.features.entityExtractionModelHint": "Provider / model empty = follow the main conversation model; reasoning \"Follow default\" = provider default",
-        "memory.features.codingRetrospect": "Coding retrospection",
-        "memory.features.codingRetrospect.hint": "Review the full coding session (tools and errors included) and distill pitfalls, constraints and rejected solutions",
-        "memory.features.rerankEnabled": "Reranking",
-        "memory.features.rerankEnabled.hint": "Rerank recalled results with a local model — slower, more precise",
-        "memory.features.heatEnabled": "Heat decay",
-        "memory.features.heatEnabled.hint": "Cool memories down like a forgetting curve: the longer unused, the lower they rank — they stop taking injection slots",
-        "memory.features.documentMemoryEnabled": "Document memory",
-        "memory.features.documentMemoryEnabled.hint": "Long agent-authored documents are stored as a \"summary card\" only: the full text stays agent-owned and is read on demand, so injection carries the summary without filling the context",
-        "memory.features.resilientModelDownload": "Resumable model downloads",
-        "memory.features.resilientModelDownload.hint": "Resume model downloads from where they stopped and retry automatically; off = one-shot downloads",
-        "memory.features.searchSemanticDedup": "Semantic dedup",
-        "memory.features.searchSemanticDedup.hint": "Keep one entry when search hits near-duplicates",
-        "memory.features.autoDream": "Memory consolidation",
-        "memory.features.autoDream.hint": "Merge and settle fragmented memories in the background",
-        "memory.features.sleepModeEnabled": "Sleep mode",
-        "memory.features.sleepModeEnabled.hint": "Layered compaction during idle periods",
-        "memory.features.hybridInject": "Hybrid injection",
-        "memory.features.hybridInject.hint": "Merge keyword + vector recall before injecting",
-        "memory.features.selectiveInjectEnabled": "Selective injection",
-        "memory.features.selectiveInjectEnabled.hint": "Only inject memories worth carrying, filtered by relevance",
-        "memory.features.adaptiveThresholdEnabled": "Adaptive threshold",
-        "memory.features.adaptiveThresholdEnabled.hint": "Adjust the relevance floor with recall quality",
-        "memory.features.reflectionUpdateEnabled": "Reflective update",
-        "memory.features.reflectionUpdateEnabled.hint": "Allow consolidation to revise existing memories",
+        "memory.features.codingRetrospect": "Remember how the code was written too",
+        "memory.features.codingRetrospect.hint": "On: the whole coding session (errors and tool calls included) is reviewed, yielding pitfalls, constraints and rejected solutions. Off: only conversation content is distilled (coding retrospection, off by default)",
+        "memory.features.rerankEnabled": "Rerank search results once more",
+        "memory.features.rerankEnabled.hint": "On: a local rerank model re-scores recalled candidates — more precise, slower. Off: the search-time order stands (reranking, off by default)",
+        "memory.features.heatEnabled": "The longer unused, the lower it ranks",
+        "memory.features.heatEnabled.hint": "On: memories cool down like a forgetting curve — long-unused ones rank later and stop taking injection slots. Off: relevance order always (heat decay, off by default)",
+        "memory.features.documentMemoryEnabled": "Store long documents as a summary card",
+        "memory.features.documentMemoryEnabled.hint": "On: long agent-authored documents live in memory as a \"summary card\"; the full text stays agent-owned and is read on demand. Off: the whole document travels into context (document memory, off by default)",
+        // --- v0.9.0 M.O. / Modus Operandi (beta) ---
+        "memory.actions.beta": "Beta",
+        "memory.actions.notice": "Extracted steps are candidates: they may be wrong, outdated, or refuted.",
+        "memory.actions.title": "Modus Operandi",
+        "memory.actions.open": "Open Modus Operandi",
+        "memory.actions.viewFull": "Full view",
+        "memory.actions.openPane": "Open full view in sidebar",
+        "memory.actions.announce.open": "Modus Operandi panel opened",
+        "memory.actions.announce.close": "Modus Operandi panel closed",
+        "memory.actions.close": "Close",
+        "memory.actions.candidates": "{n} candidates",
+        "memory.actions.runs": "Recent runs",
+        "memory.actions.runOf": "Run {n}",
+        "memory.actions.run.ok": "ok",
+        "memory.actions.run.failed": "failed",
+        "memory.actions.run.refuted": "refuted",
+        "memory.actions.state.candidate": "candidate",
+        "memory.actions.state.trusted": "trusted",
+        "memory.actions.state.stale": "stale",
+        "memory.actions.state.refuted": "refuted",
+        "memory.actions.gate.has": "has counterfactual",
+        "memory.actions.gate.none": "no gate yet",
+        "memory.actions.gate.tag": "GATE",
+        "memory.actions.who.main": "main",
+        "memory.actions.who.human": "human",
+        "memory.actions.who.ci": "CI",
+        "memory.actions.ov.done": "Done when",
+        "memory.actions.ov.trigger": "Triggered by",
+        "memory.actions.band.count": "{n} steps",
+        "memory.actions.legend.states": "States",
+        "memory.actions.detail.situation": "Situation",
+        "memory.actions.detail.action": "Action",
+        "memory.actions.detail.why": "Why",
+        "memory.actions.detail.cf": "Counterfactual",
+        "memory.actions.detail.noCf": "No counterfactual recorded yet",
+        "memory.actions.detail.source": "Source memories",
+        "memory.actions.credit": "Reuse",
+        "memory.actions.creditValue": "{n} uses · last {d}d ago",
+        "memory.actions.dep": "depends on",
+        "memory.actions.zoom.in": "Zoom in",
+        "memory.actions.zoom.out": "Zoom out",
+        "memory.actions.zoom.fit": "Fit width",
+        "memory.actions.zoom.hint": "Ctrl/⌘ + wheel also zooms",
+        "memory.actions.list.heading": "Workflows in this project",
+        "memory.actions.list.count": "{n} workflow(s)",
+        "memory.actions.list.meta": "{steps} steps · {gates} gates · counterfactual {cf}/{steps}",
+        "memory.actions.scope.project": "project {name}",
+        "memory.actions.scope.global": "global",
+        "memory.actions.scope.none": "project unknown",
+        "memory.actions.broken": "Some files could not be read:",
+        "memory.actions.empty.title": "No workflows in this project yet",
+        "memory.actions.empty.body": "A workflow lives in the project, under .mneme/pipelines/ — it travels with the repository: committable, reviewable, readable by CI. A practice becomes a node type on its second reuse; the first run is just an instance. Once the same path has been walked twice it gets distilled out of the session and lands in that directory.",
+        "memory.actions.noRuns": "No runs recorded for this workflow yet, so every step is still a candidate.",
+        "memory.actions.settle.title": "This run",
+        "memory.actions.settle.line": "\"{title}\"",
+        "memory.actions.settle.used": "Reused {n} steps this run (checked = actually used)",
+        "memory.actions.settle.refutedWarn": "This path contains refuted steps; take the result with caution",
+        "memory.features.actionPipelineEnabled": "M.O. (beta)",
+        "memory.features.actionPipelineEnabled.hint": "⚠️ Under development: only the viewing layer works today — self-distillation and triggering are not built yet, so leave this off for now. Modus Operandi: the ways of working that actually got walked through in real sessions, drawn as a read-only graph — session-header icon, full sidebar view, and a per-run settlement card. Takes effect after restarting DSH",
+        "memory.features.resilientModelDownload": "Model downloads resume after interruption",
+        "memory.features.resilientModelDownload.hint": "On: downloads continue from where they stopped and retry automatically. Off: an interrupted download starts over (resumable downloads, on by default)",
+        "memory.features.searchSemanticDedup": "Keep one entry when search hits near-duplicates",
+        "memory.features.searchSemanticDedup.hint": "On: near-duplicate entries merge into one, saving injection slots. Off: duplicates all show up (semantic dedup, off by default)",
+        "memory.features.autoDream": "Tidy memories in the background (merge · dedupe)",
+        "memory.features.autoDream.hint": "On: fragmented memories are merged and settled in the background (autoDream). Off: memory only accumulates, so it gets messier the longer you use it",
+        "memory.features.sleepModeEnabled": "It tidies memories while you are away",
+        "memory.features.sleepModeEnabled.hint": "On: layered compaction and tidying happen during idle periods. Off: only consolidation you trigger manually (sleep mode, off by default)",
+        // #427 suggestion 5: hybridInject / selectiveInjectEnabled /
+        // adaptiveThresholdEnabled are three dials of one question — what comes
+        // back. Adjacent placement plus a hint that names the other two.
+        "memory.features.hybridInject": "Search by keywords and meaning together",
+        "memory.features.hybridInject.hint": "On: both channels each fetch a batch and merge — broader recall. Off: one channel only. Three dials exist for \"what comes back\" (hybrid / selective / adaptive threshold); one is enough (hybrid injection, on by default)",
+        "memory.features.selectiveInjectEnabled": "Only carry memories that truly matter",
+        "memory.features.selectiveInjectEnabled.hint": "On: relevance is filtered before injecting — cleaner context. Off: more comes along, and noisier. One of the three dials (selective injection, on by default)",
+        "memory.features.adaptiveThresholdEnabled": "Tighten or loosen by retrieval quality",
+        "memory.features.adaptiveThresholdEnabled.hint": "On: a poor-recall day loosens the floor, a good one tightens it. Off: the floor is fixed. One of the three dials (adaptive threshold, on by default)",
+        "memory.features.reflectionUpdateEnabled": "Let tidying revise existing memories",
+        "memory.features.reflectionUpdateEnabled.hint": "On: consolidation may rewrite and merge existing entries, not only add. Off: old memories are never auto-edited (reflective update, on by default)",
         "memory.features.distill": "Distillation & rate limiting",
         "memory.features.distillRateLimitIntervalMs": "Distill spacing (ms)",
         "memory.features.distillRateLimitRetries": "429 retries",
         "memory.features.distillRateLimitBaseDelayMs": "Backoff base delay (ms)",
         "memory.features.distillMaxChars": "Transcript cap (chars)",
+        "memory.features.distillRecords.enabled": "Keep distilled transcripts",
+        "memory.features.distillRecords.enabled.hint": "Also store the public parts of the distilled window, with a provenance link per memory; private reasoning and tool output are never stored. Off writes nothing and skips collection entirely",
+        "memory.features.distillRecords.retentionDays": "Transcript retention (days)",
+        "memory.features.distillRecords.retentionDays.hint": "1–3650 days; startup pruning only. To make reclaim use the same window, pass the same value via --older-than",
         "memory.features.codingBoostFactor": "Coding boost factor",
-        "memory.features.memoryQualityFilter.enabled": "Memory quality filter",
-        "memory.features.memoryQualityFilter.enabled.hint": "Archive low-value memories automatically; injection downranks by quality",
-        "memory.features.llmAudit.enabled": "Background call audit",
-        "memory.features.llmAudit.enabled.hint": "Log background model calls and token usage from consolidation / summaries",
+        "memory.features.memoryQualityFilter.enabled": "Tuck low-value memories away automatically",
+        "memory.features.memoryQualityFilter.enabled.hint": "On: low-value entries are archived automatically and injection downranks by quality. Off: everything stays, noise included (memory quality filter, on by default)",
+        "memory.features.llmAudit.enabled": "Keep tabs on background model usage",
+        "memory.features.llmAudit.enabled.hint": "On: background consolidation / summary calls and token usage are all on record. Off: there is no way to check what the background spent (call audit, on by default)",
         // #254 — two layers: enabled runs the check (audit only), enforce actually
         // blocks. The hints must keep that difference explicit.
-        "memory.features.writeAdmission.enabled": "Write admission checks",
-        "memory.features.writeAdmission.enabled.hint": "Flag blank / noise writes before storing, with an audit row (never blocks)",
-        "memory.features.writeAdmission.enforce": "Write admission enforcement",
-        "memory.features.writeAdmission.enforce.hint": "Actually reject flagged writes; off keeps the audit row only",
-        "memory.features.preInjectGate.enabled": "Pre-inject gate",
-        "memory.features.preInjectGate.enabled.hint": "Judge opinion/stance memories before injection, audit-only (never blocks)",
-        "memory.features.preInjectGate.enforce": "Pre-inject gate enforcement",
-        "memory.features.preInjectGate.enforce.hint": "Actually drop flagged candidates at injection; off keeps the audit row only",
+        "memory.features.writeAdmission.enabled": "Judge blank / noise writes before storing (audit only)",
+        "memory.features.writeAdmission.enabled.hint": "On: blank / noise writes are flagged with an audit row but still stored. Off: nothing is judged. To actually block, see the next switch (write admission checks, off by default)",
+        "memory.features.writeAdmission.enforce": "Really reject useless writes",
+        "memory.features.writeAdmission.enforce.hint": "On: flagged writes are rejected outright. Off: audit row only, stored anyway. Needs the checks switch above (write admission enforcement, off by default)",
+        "memory.features.preInjectGate.enabled": "Screen out \"just my opinion\" memories before injection (audit only)",
+        "memory.features.preInjectGate.enabled.hint": "On: opinion / stance memories are judged before injection and audited, so you can watch the distribution first. Off: injected as usual (pre-inject gate, off by default)",
+        "memory.features.preInjectGate.enforce": "Really drop flagged candidates at injection",
+        "memory.features.preInjectGate.enforce.hint": "On: flagged candidates are dropped at injection time. Off: audit row only, injected anyway. Needs the gate switch above (pre-inject gate enforcement, off by default)",
         // #164 A2: its own gate for the secret / PII rules (separate from the
         // blank/noise pair above), and it runs inside the write admission checks
         // above, so with those off it never runs. Hits are audited only;
         // enforcement stays with the key above.
-        "memory.features.sensitiveScanEnabled": "Secret / PII scan",
-        "memory.features.sensitiveScanEnabled.hint": "Scan writes for credentials and personal data; needs write admission checks to run. Hits are audited only; enforcement needs the enforcement toggle too",
-        "memory.features.bm25SearchEnabled": "BM25 keyword search",
-        "memory.features.bm25SearchEnabled.hint": "Classic keyword scoring, complementary to vector recall",
-        "memory.features.conflictFreezeEnabled": "Conflict freezing",
-        "memory.features.conflictFreezeEnabled.hint": "Freeze contradictory memories for confirmation during consolidation",
-        "memory.features.scopeEnabled": "Scope tagging",
-        "memory.features.scopeEnabled.hint": "New memories record which session (agent / workspace) they came from, for isolation and filtered recall",
-        "memory.features.strictScope": "Strict isolation",
-        "memory.features.strictScope.hint": "When on, memories explicitly made private by other sessions become fully invisible; when off they stay visible but rank lower. For true isolation use a memory's sensitivity field",
-        "memory.features.trustEpistemicWeighting": "Credibility weighting",
-        "memory.features.trustEpistemicWeighting.hint": "Adjust recall ranking by source credibility (experimental)",
-        "memory.features.reflectionFailureTracking": "Reflection failure tracking",
-        "memory.features.reflectionFailureTracking.hint": "Record failed consolidation cases for later improvement (diagnostics)",
+        "memory.features.sensitiveScanEnabled": "Scan writes for credentials and personal data",
+        "memory.features.sensitiveScanEnabled.hint": "On: secret / PII rules run inside the write admission checks; hits are audited only — to block, also enable enforcement. Nothing runs while the checks switch is off (secret / PII scan, off by default)",
+        "memory.features.bm25SearchEnabled": "Also search by exact keywords",
+        "memory.features.bm25SearchEnabled.hint": "On: exact-term scoring joins in, so proper nouns, error codes and paths hit reliably — a complement to meaning-based search. Off: semantic similarity only (BM25 keyword search, on by default)",
+        "memory.features.conflictFreezeEnabled": "Freeze contradictory memories first",
+        "memory.features.conflictFreezeEnabled.hint": "On: contradictions found while tidying are frozen for your confirmation instead of both staying live. Off: both stay in use (conflict freezing, off by default)",
+        "memory.features.scopeEnabled": "Record which session each memory came from",
+        "memory.features.scopeEnabled.hint": "On: every new memory is tagged with the agent / workspace it came from — that tag decides whether other sessions see it. Off: new memories carry no origin and all sessions share one pool (scope tagging, off by default)",
+        "memory.features.strictScope": "Memories others marked private stay invisible to me",
+        "memory.features.strictScope.hint": "On: memories explicitly made private by other sessions are fully invisible. Off: they stay visible but rank lower. For true isolation use a memory's sensitivity field. Needs the tagging switch above (strict isolation, off by default)",
+        "memory.features.trustEpistemicWeighting": "Rank by source credibility",
+        "memory.features.trustEpistemicWeighting.hint": "On: more credible sources rank higher. Off: everything counts the same (credibility weighting, experimental, off by default)",
+        "memory.features.reflectionFailureTracking": "Keep failed tidying cases on record",
+        "memory.features.reflectionFailureTracking.hint": "On: failure causes and cases are stored for diagnosis and improvement. Off: failures leave no record (failure tracking, on by default)",
         "memory.features.embedRoute": "Semantic search route",
         "memory.features.embedProvider": "Embedding provider",
         "memory.features.embedProvider.openai": "OpenAI-compatible API",
@@ -1020,6 +1263,7 @@ window.__ModuleLoader__.load({
         "memory.features.modelTestOk": "Connected",
         "memory.features.modelTestFail": "Test failed",
         "memory.features.modelTestHint": "Fires one minimal consolidation call to verify provider/model connectivity and effort support",
+        "memory.features.modelTestDowngraded": "Effort not accepted by this model; connected without it (same as a real consolidation)",
         "memory.features.routeStaleMark": " (not in list)",
         "memory.features.routeStaleHint": "This value is not in the currently available list (often a leftover from switching providers): reselect, or run a connectivity test to verify now",
         "memory.explorer.viewCards": "Cards",
@@ -1044,6 +1288,20 @@ window.__ModuleLoader__.load({
         "memory.explorer.imported": "Merged {n} edits",
         "memory.explorer.importFailed": "Import failed",
         "memory.explorer.importNoFile": "Choose a file first",
+        "memory.explorer.newMemory": "New memory…",
+        "memory.explorer.newTitle": "New memory",
+        "memory.explorer.newHint": "Write one memory by hand. Same type + same title merges into the existing entry instead of minting a second row.",
+        "memory.explorer.newType": "Type",
+        "memory.explorer.newTitlePlaceholder": "Short title; also the dedupe key",
+        "memory.explorer.newContentPlaceholder": "Body",
+        "memory.explorer.newTagsPlaceholder": "Tags, comma separated (optional)",
+        "memory.explorer.newConfirm": "Create",
+        "memory.explorer.newSaving": "Saving…",
+        "memory.explorer.newCreated": "Created",
+        "memory.explorer.newMerged": "Merged into the existing entry with that title",
+        "memory.explorer.newFailed": "Create failed",
+        "memory.explorer.newNoTitle": "Title is required",
+        "memory.explorer.newNoContent": "Body is required",
         "memory.explorer.exportFailed": "Export failed",
         "memory.explorer.conflictBadge": "Conflict",
         "memory.explorer.archivedBadge": "Archived",
@@ -1110,6 +1368,14 @@ window.__ModuleLoader__.load({
         "memory.status.conflictQueue.similarity": "similarity",
         "memory.status.conflictQueue.diffTitle": "Differences highlighted: red = removed, green = added",
         "memory.status.conflictQueue.diffFallback": "The two texts differ substantially — compare the originals",
+        "memory.status.conflictQueue.expand": "Expand full text",
+        "memory.status.conflictQueue.collapse": "Collapse",
+        "memory.status.conflictQueue.copySide": "Copy this side",
+        "memory.status.conflictQueue.copiedSide": "Full text copied",
+        "memory.status.conflictQueue.importance": "importance {n}",
+        "memory.status.conflictQueue.chars": "{n} chars",
+        "memory.status.conflictQueue.updated": "updated {time}",
+        "memory.status.conflictQueue.created": "created {time}",
         "memory.status.conflictQueue.emptyTitle": "No pending conflicts",
         "memory.status.conflictQueue.emptyBody": "When consolidation finds two contradictory or highly similar memories, it freezes them here for your review instead of changing anything automatically. Neither side participates in injection until resolved.",
         "memory.status.conflictQueue.applyHintTitle": "On confirm: a veto note is appended to the kept side and the other side is archived",
@@ -1191,8 +1457,62 @@ window.__ModuleLoader__.load({
         "memory.status.mirror.foot": "Sync state of the on-disk Markdown mirror of memory entries",
         "memory.status.sec.overview": "Library",
         "memory.status.sec.engine": "Background activity",
-        "memory.status.llm": "LLM Usage",
-        "memory.status.llmCalls": "Last 7 days · {n} calls",
+        "memory.status.sec.maintenance": "Maintenance",
+        "memory.status.maint": "Storage reclaim",
+        "memory.status.maint.freelist": "Free pages reclaimable now",
+        "memory.status.maint.plannedInputs": "Input snapshots to clear",
+        "memory.status.maint.plannedEmbeddings": "Archived embeddings to clear",
+        "memory.status.maint.window": "Retention window",
+        "memory.status.maint.windowUnit": "days",
+        "memory.status.maint.windowLabel": "Retention window (days)",
+        "memory.status.maint.reestimate": "Re-estimate",
+        "memory.status.maint.reestimating": "Estimating…",
+        "memory.status.maint.stale": "Window changed - re-estimate before running, or the run would use the previous estimate's numbers.",
+        "memory.status.maint.vacuum": "VACUUM as well",
+        "memory.status.maint.vacuumHint": "VACUUM briefly takes an exclusive lock on the database; other reads and writes wait. Skipping it does not change what gets cleared.",
+        "memory.status.maint.execute": "Run reclaim",
+        "memory.status.maint.confirm": "Confirm (irreversible)",
+        "memory.status.maint.running": "Running…",
+        "memory.status.maint.cancel": "Cancel",
+        "memory.status.maint.confirmHint": "This clears {inputs} input-snapshot rows and {embeddings} archived-embedding rows. It cannot be undone.",
+        "memory.status.maint.badWindow": "The retention window must be an integer of at least 0",
+        "memory.status.maint.failed": "Reclaim failed",
+        "memory.status.maint.done": "Reclaim finished",
+        "memory.status.maint.size": "Size (before → after)",
+        "memory.status.maint.reclaimed": "Actually freed",
+        "memory.status.maint.clearedInputs": "Input snapshots cleared",
+        "memory.status.maint.clearedEmbeddings": "Archived embeddings cleared",
+        "memory.status.maint.receipt": "Audit receipt",
+        "memory.status.maint.receiptNone": "Not recorded (audit disabled or receipt write failed)",
+        "memory.status.maint.duration": "Duration",
+        "memory.status.maint.vacuumRan": "VACUUM ran",
+        "memory.status.maint.vacuumOff": "Not VACUUMed",
+        "memory.status.maint.vacuumFailed": "VACUUM failed",
+        "memory.status.maint.vacuumFailedHint": "The reclaim already completed and cannot be undone, but the file will not shrink yet; run it again later (reclaim is idempotent).",
+        "memory.status.sec.token": "Token flow · last 7 days",
+        "memory.status.token.in": "input",
+        "memory.status.token.out": "output",
+        "memory.status.token.total": "7-day token total",
+        "memory.status.token.calls": "Calls",
+        "memory.status.token.callsCap": "Last 7 days · all background components",
+        "memory.status.token.share": "Consolidation share",
+        "memory.status.token.shareFoot": "dream_consolidate · {n} token",
+        "memory.status.token.conflicts": "Pending conflicts",
+        "memory.status.token.conflictsFoot": "From /dream-status · live",
+        "memory.status.token.donut": "By component · who spent these tokens",
+        "memory.status.token.days": "By day · 7-day trend",
+        "memory.status.token.heat": "8-week heat · daily spend",
+        "memory.status.token.heatLess": "less",
+        "memory.status.token.heatMore": "more",
+        "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)",
+        "memory.status.token.op.dream_consolidate": "Memory consolidation",
+        "memory.status.token.op.summarize_compress": "Session distillation",
+        "memory.status.token.op.entity_extract": "Entity extraction",
+        "memory.status.token.op.dream_summarize": "Overview summary",
+        "memory.status.token.op.sleep_pattern": "Sleep patterns",
+        "memory.status.token.op.write_admission": "Write admission",
         "memory.status.error": "Failed to load"
       }
     };
@@ -1253,18 +1573,50 @@ window.__ModuleLoader__.load({
       // --- shared controls ---
       ".mneme-search{box-sizing:border-box;height:30px;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:13px;outline:none;transition:border-color .12s,box-shadow .12s}",
       ".mneme-search: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-search::placeholder{color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-search::placeholder{color:var(--mneme-fg-dim)}",
       ".mneme-chip{height:26px;padding:0 10px;border-radius:8px;border:1px solid transparent;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;display:inline-flex;align-items:center}",
       ".mneme-chip:hover{background:var(--dsw-alias-interactive-bg-hover)}",
-      ".mneme-chip.mneme-active{color:var(--dsw-alias-state-business-primary);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent)}",
+      ".mneme-chip.mneme-active{color:var(--mneme-accent);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent)}",
       ".mneme-select{box-sizing:border-box;height:30px;padding:0 8px;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:13px;outline:none}",
       ".mneme-routeselect{width:240px;max-width:60%}",
       ".mneme-footbtn{border:none;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;padding:3px 8px;border-radius:6px}",
       ".mneme-footbtn:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
-      ".mneme-hint{color:var(--dsw-alias-label-tertiary);padding:24px 0;text-align:center;font-size:13px}",
-      ".mneme-entitychip{flex:none;height:26px;padding:0 10px;border-radius:8px;border:none;background:none;color:var(--dsw-alias-state-business-primary);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;display:inline-flex;align-items:center}",
+      ".mneme-hint{color:var(--mneme-fg-dim);padding:24px 0;text-align:center;font-size:13px}",
+      ".mneme-entitychip{flex:none;height:26px;padding:0 10px;border-radius:8px;border:none;background:none;color:var(--mneme-accent);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;display:inline-flex;align-items:center}",
       ".mneme-entitychip:hover{background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent)}",
       // --- main-area memory library page ---
+      // 面板语义色层（#178）：宿主 token 在浅色下给正文/次要文字只有 1.26–4.49
+      // 的对比度，且面板还一直在引用 5 个根本不存在的宿主名（--dsw-alias-state-error
+      // / -warning / -success / -warn / --dsw-alias-border），
+      // 于是长年吃的是写在 fallback 里的硬编码色。这里按宿主真实 token 现算一组
+      // 面板自有语义色：混色基准全是宿主 token，宿主换肤时跟着走，不引入新字面量。
+      // 必须挂四个根——面板不只长在 .mneme-x 下：记忆库 sheet portal 到 body
+      // （.mneme-overlay）、侧边栏入口在宿主插槽（.mneme-triggerwrap）、顶部入口
+      // portal 到宿主侧边栏（.mneme-topentry）。
+      ".mneme-x,.mneme-overlay,.mneme-triggerwrap,.mneme-topentry{" +
+        "--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));" +
+        "--mneme-danger:color-mix(in srgb,var(--dsw-alias-state-error-primary) 80%,var(--dsw-alias-label-primary));" +
+        "--mneme-warn:color-mix(in srgb,var(--dsw-static-amber-600,#dd8629) 65%,var(--dsw-alias-label-primary));" +
+        "--mneme-ok:color-mix(in srgb,var(--dsw-static-green-500,#22c55e) 65%,var(--dsw-alias-label-primary));" +
+        // Token 去向三屏（2026-10 可观测性改造）：图表六色全部单层 color-mix、
+        // 基准只用宿主 token，test/contrast.test.js GRAPHICS 逐 selector 锁浅/深
+        // ≥3:1。配比按 2026-10 审计数据校准（巩固 37% 是最大弧，占最深主色）。
+        "--mneme-chart-1:color-mix(in srgb,var(--dsw-alias-state-business-primary) 70%,var(--dsw-alias-label-primary));" +
+        "--mneme-chart-2:color-mix(in srgb,var(--dsw-static-green-500,#22c55e) 55%,var(--dsw-alias-label-primary));" +
+        "--mneme-chart-3:color-mix(in srgb,var(--dsw-static-amber-600,#dd8629) 60%,var(--dsw-alias-label-primary));" +
+        "--mneme-chart-4:color-mix(in srgb,var(--dsw-alias-state-error-primary) 65%,var(--dsw-alias-label-primary));" +
+        "--mneme-chart-5:color-mix(in srgb,var(--dsw-static-green-500,#22c55e) 45%,var(--dsw-alias-state-business-primary));" +
+        // chart-6 与 graphic-dim 同款但内联写：对比度解析器不递归 --mneme-* 变量。
+        "--mneme-chart-6:color-mix(in srgb,var(--dsw-alias-label-primary) 50%,transparent);" +
+        // 热力档位用 label 补余而非 transparent：transparent 混色在浅色主题下
+        // 低档位对白底不足 3:1；label 补余两套主题各档都过线且单调。
+        "--mneme-heat-1:color-mix(in srgb,var(--dsw-alias-state-business-primary) 85%,var(--dsw-alias-label-primary));" +
+        "--mneme-heat-2:color-mix(in srgb,var(--dsw-alias-state-business-primary) 70%,var(--dsw-alias-label-primary));" +
+        "--mneme-heat-3:color-mix(in srgb,var(--dsw-alias-state-business-primary) 55%,var(--dsw-alias-label-primary));" +
+        "--mneme-heat-4:color-mix(in srgb,var(--dsw-alias-state-business-primary) 40%,var(--dsw-alias-label-primary))" +
+      "}",
       ".mneme-x{flex:1;min-height:0;height:100%;width:100%;box-sizing:border-box;display:flex;flex-direction:column;background:var(--dsw-alias-bg-layer-1);--dsh-scrollbar-thumb:var(--dsw-alias-scrollbar-bg-l2);--dsh-scrollbar-thumb-hover:var(--dsw-alias-scrollbar-hover-l2);container-type:inline-size}",
       // 窄容器（better-sidebar 工作台 ~500px）下中央 vtabs 会与右缘悬浮的
       // 卡片/时间线切换器重叠：容器查询收窄时隐藏切换器，视图模式沿用
@@ -1273,14 +1625,14 @@ window.__ModuleLoader__.load({
       ".mneme-xbar{position:relative;flex:none;display:flex;align-items:center;justify-content:center;gap:6px;border-bottom:1px solid var(--dsw-alias-border-l2);padding:0 16px;min-height:52px}",
       ".mneme-filterbar{flex:none;display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding:8px 16px;border-bottom:1px solid var(--dsw-alias-border-l2)}",
       ".mneme-vtabs{display:flex;align-items:stretch;height:46px}",
-      ".mneme-vtab{position:relative;border:0;background:none;cursor:pointer;padding:0 16px;color:var(--dsw-alias-label-tertiary);font-family:inherit;font-size:14px;font-weight:500;line-height:20px;display:inline-flex;align-items:center;gap:7px}",
+      ".mneme-vtab{position:relative;border:0;background:none;cursor:pointer;padding:0 16px;color:var(--mneme-fg-dim);font-family:inherit;font-size:14px;font-weight:500;line-height:20px;display:inline-flex;align-items:center;gap:7px}",
       ".mneme-vtab:hover{color:var(--dsw-alias-label-primary)}",
-      ".mneme-vtab.mneme-active{color:var(--dsw-alias-state-business-primary)}",
+      ".mneme-vtab.mneme-active{color:var(--mneme-accent)}",
       ".mneme-vtab.mneme-active::after{content:\"\";position:absolute;left:10px;right:10px;bottom:-1px;height:2.5px;border-radius:2px;background:var(--dsw-alias-state-business-primary)}",
       // transform 会自建层叠上下文：层级必须给在容器上——3 高于吸顶月份头(2)、
       // 低于详情抽屉(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(--dsw-alias-label-tertiary);white-space:nowrap}",
+      ".mneme-xcount{flex:none;font-size:12px;line-height:16px;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:236px;min-width:0;min-height:0;overflow-y:auto;padding:16px 14px;border-right:1px solid var(--dsw-alias-border-l2);box-sizing:border-box;display:flex;flex-direction:column;gap:8px}",
@@ -1289,23 +1641,23 @@ window.__ModuleLoader__.load({
       ".mneme-xrow{display:flex;align-items:center;gap:8px;flex-wrap:wrap}",
       ".mneme-xsearch{width:100%}",
       ".mneme-xselect{flex:1;min-width:0}",
-      ".mneme-xcolhead{flex:none;font-size:12px;font-weight:500;margin:0;color:var(--dsw-alias-label-tertiary);padding:2px 8px 8px}",
+      ".mneme-xcolhead{flex:none;font-size:12px;font-weight:500;margin:0;color:var(--mneme-fg-dim);padding:2px 8px 8px}",
       ".mneme-xtype{display:flex;justify-content:flex-start;align-items:center;gap:8px;width:100%;padding:5px 8px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;line-height:18px;text-align:left}",
       ".mneme-xtype:hover{background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-xtype.mneme-active{background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary);font-weight:500}",
-      ".mneme-xcount2{flex:none;margin-left:auto;font-size:12px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-xcount2{flex:none;margin-left:auto;font-size:12px;color:var(--mneme-fg-dim)}",
       ".mneme-xmonth{display:flex;align-items:center;gap:4px;width:100%;padding:6px 8px 4px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-primary);cursor:pointer;font-family:inherit;font-size:13px;font-weight:500;line-height:18px;text-align:left}",
       ".mneme-xmonth:first-child{margin-top:0}",
       ".mneme-xmonth:hover{background:var(--dsw-alias-interactive-bg-hover)}",
-      ".mneme-xcaret{flex:none;font-size:10px;color:var(--dsw-alias-label-tertiary);width:10px}",
-      ".mneme-xday{display:flex;align-items:center;gap:4px;margin:6px 0 2px 22px;padding:2px 6px;border:none;border-radius:6px;background:none;font-family:inherit;font-size:12px;line-height:16px;color:var(--dsw-alias-label-tertiary);cursor:pointer;text-align:left}",
+      ".mneme-xcaret{flex:none;font-size:10px;color:var(--mneme-fg-dim);width:10px}",
+      ".mneme-xday{display:flex;align-items:center;gap:4px;margin:6px 0 2px 22px;padding:2px 6px;border:none;border-radius:6px;background:none;font-family:inherit;font-size:12px;line-height:16px;color:var(--mneme-fg-dim);cursor:pointer;text-align:left}",
       ".mneme-xday:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
       ".mneme-xitem{display:flex;gap:8px;align-items:baseline;width:calc(100% - 22px);margin-left:22px;padding:4px 8px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;line-height:18px;text-align:left}",
       ".mneme-xitem:hover{background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-xitem.mneme-active{background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary)}",
-      ".mneme-xtime{flex:none;font-size:12px;line-height:16px;color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums}",
+      ".mneme-xtime{flex:none;font-size:12px;line-height:16px;color:var(--mneme-fg-dim);font-variant-numeric:tabular-nums}",
       ".mneme-xname{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
-      ".mneme-xempty{padding:18px 16px;text-align:center;color:var(--dsw-alias-label-tertiary);font-size:13px}",
+      ".mneme-xempty{padding:18px 16px;text-align:center;color:var(--mneme-fg-dim);font-size:13px}",
       // --- memory-type color dots (mirrored across filter / timeline / detail) ---
       ".mneme-xdot{flex:none;display:inline-block;width:8px;height:8px;border-radius:50%;background:currentColor}",
       ".mneme-xdot--all{background:transparent;border:1.5px solid currentColor;opacity:.55;box-sizing:border-box}",
@@ -1317,7 +1669,7 @@ window.__ModuleLoader__.load({
       ".mneme-xtree{flex:1;min-height:0;overflow-y:auto;padding:8px 10px 28px}",
       ".mneme-xdinner{max-width:720px}",
       ".mneme-xdtitle{font-size:16px;font-weight:600;line-height:24px;color:var(--dsw-alias-label-primary);margin-bottom:10px;word-break:break-word}",
-      ".mneme-xdmeta{display:flex;flex-wrap:wrap;gap:4px 14px;margin-bottom:6px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-xdmeta{display:flex;flex-wrap:wrap;gap:4px 14px;margin-bottom:6px;font-size:12px;line-height:18px;color:var(--mneme-fg-dim)}",
       ".mneme-xdsrc{display:inline-block;max-width:200px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;vertical-align:bottom}",
       ".mneme-xdcontent{margin-top:14px;font-size:14px;line-height:1.75;color:var(--dsw-alias-label-primary);white-space:pre-wrap;word-break:break-word}",
       ".mneme-xdactions{display:flex;gap:8px;margin-top:18px}",
@@ -1330,42 +1682,44 @@ window.__ModuleLoader__.load({
       ".mneme-gnode:hover circle{stroke-width:4}",
       ".mneme-gnode.mneme-groot circle{stroke:var(--dsw-alias-state-business-primary);stroke-width:3}",
       ".mneme-glabel{fill:var(--dsw-alias-label-secondary);font-size:11px;text-anchor:middle;pointer-events:none;user-select:none}",
-      ".mneme-gedge{stroke:var(--dsw-alias-label-dimmed);stroke-width:1.5;cursor:pointer}",
+      ".mneme-gedge{stroke:var(--mneme-graphic-dim);stroke-width:1.5;cursor:pointer}",
       ".mneme-gedge:hover{stroke:var(--dsw-alias-state-business-primary)}",
-      ".mneme-gedge-dashed{stroke-dasharray:5 4;opacity:.7}",
-      ".mneme-graphhint{flex:none;color:var(--dsw-alias-label-tertiary);font-size:13px;text-align:center;padding:6px 0 2px}",
+      // 虚线态靠 dash 图案区分，不再叠 opacity：50% 的描边再乘 .7 后浅色画布上
+      // 只剩 2.28，低于图形要求的 3:1（图案已经承担了「没有 memory_id」这个语义）。
+      ".mneme-gedge-dashed{stroke-dasharray:5 4}",
+      ".mneme-graphhint{flex:none;color:var(--mneme-fg-dim);font-size:13px;text-align:center;padding:6px 0 2px}",
       ".mneme-graphside{flex:none;max-height:220px;overflow-y:auto;border-top:1px solid var(--dsw-alias-border-l1);margin-top:10px;padding-top:10px}",
       ".mneme-gs-title{font-size:14px;font-weight:600;color:var(--dsw-alias-label-primary);margin-bottom:4px;display:flex;justify-content:space-between;align-items:baseline;gap:8px}",
-      ".mneme-gs-meta{font-size:13px;color:var(--dsw-alias-label-tertiary);margin-bottom:6px}",
+      ".mneme-gs-meta{font-size:13px;color:var(--mneme-fg-dim);margin-bottom:6px}",
       ".mneme-gs-attr{display:flex;gap:6px;font-size:13px;padding:2px 0}",
-      ".mneme-gs-attrkey{flex:none;color:var(--dsw-alias-label-tertiary);font-size:13px}",
+      ".mneme-gs-attrkey{flex:none;color:var(--mneme-fg-dim);font-size:13px}",
       ".mneme-gs-attrval{color:var(--dsw-alias-label-secondary);word-break:break-word;font-size:13px}",
       ".mneme-gs-link{display:block;width:100%;text-align:left;border:none;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;padding:3px 6px;border-radius:6px;word-break:break-word}",
       ".mneme-gs-link:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
       // --- entity explorer: rail + layered detail (entities → attrs → relations → graph) ---
       ".mneme-ent{flex:1;min-height:0;display:flex;overflow:hidden}",
       ".mneme-entrail{flex:none;width:224px;min-height:0;overflow-y:auto;padding:12px;border-right:1px solid var(--dsw-alias-border-l2);box-sizing:border-box;display:flex;flex-direction:column;gap:4px}",
-      ".mneme-enttype{display:flex;align-items:center;gap:6px;width:100%;padding:8px 8px 2px;border:none;background:none;color:var(--dsw-alias-label-tertiary);cursor:pointer;font-family:inherit;font-size:11px;font-weight:600;line-height:16px;text-align:left;letter-spacing:.02em}",
+      ".mneme-enttype{display:flex;align-items:center;gap:6px;width:100%;padding:8px 8px 2px;border:none;background:none;color:var(--mneme-fg-dim);cursor:pointer;font-family:inherit;font-size:11px;font-weight:600;line-height:16px;text-align:left;letter-spacing:.02em}",
       ".mneme-entitem{display:flex;align-items:center;gap:8px;width:100%;padding:5px 8px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;line-height:18px;text-align:left}",
       ".mneme-entitem:hover{background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-entitem.mneme-active{background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary)}",
       ".mneme-entname{min-width:0;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
-      ".mneme-entmentions{flex:none;font-size:11px;color:var(--dsw-alias-label-tertiary);font-variant-numeric:tabular-nums}",
+      ".mneme-entmentions{flex:none;font-size:11px;color:var(--mneme-fg-dim);font-variant-numeric:tabular-nums}",
       ".mneme-entdetail{flex:1;min-width:0;min-height:0;overflow-y:auto;padding:20px 24px 32px;box-sizing:border-box}",
       ".mneme-entinner{max-width:720px}",
       ".mneme-enttitle{display:flex;align-items:center;gap:10px;font-size:17px;font-weight:600;line-height:24px;color:var(--dsw-alias-label-primary);word-break:break-word}",
       ".mneme-enttitle .mneme-xdot{width:10px;height:10px}",
-      ".mneme-entmeta{display:flex;flex-wrap:wrap;gap:4px 14px;margin-top:6px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-entmeta{display:flex;flex-wrap:wrap;gap:4px 14px;margin-top:6px;font-size:12px;line-height:18px;color:var(--mneme-fg-dim)}",
       ".mneme-layer{margin-top:24px}",
       ".mneme-layerhead{display:flex;align-items:baseline;gap:8px;font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);margin-bottom:10px}",
-      ".mneme-layercount{font-size:12px;font-weight:400;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-layercount{font-size:12px;font-weight:400;color:var(--mneme-fg-dim)}",
       ".mneme-attrgrid{display:grid;grid-template-columns:repeat(auto-fill,minmax(200px,1fr));gap:8px}",
       ".mneme-attrcard{min-width:0;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;padding:8px 12px}",
-      ".mneme-attrkey{font-size:11px;color:var(--dsw-alias-label-tertiary);margin-bottom:2px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
+      ".mneme-attrkey{font-size:11px;color:var(--mneme-fg-dim);margin-bottom:2px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
       ".mneme-attrval{font-size:13px;line-height:19px;color:var(--dsw-alias-label-primary);word-break:break-word}",
       ".mneme-relrow{display:flex;align-items:center;gap:10px;width:100%;padding:7px 10px;border:none;border-radius:10px;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;line-height:20px;text-align:left}",
       ".mneme-relrow:hover{background:var(--dsw-alias-interactive-bg-hover)}",
-      ".mneme-reltype{flex:none;font-size:11px;line-height:16px;color:var(--dsw-alias-state-business-primary);border:1px solid color-mix(in srgb,var(--dsw-alias-state-business-primary) 35%,transparent);border-radius:6px;padding:0 6px}",
+      ".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}",
       // --- 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}",
@@ -1373,25 +1727,25 @@ window.__ModuleLoader__.load({
       // 设置页各节一律用 boxed 卡（.mneme-set-card）+ 分组标题（.mneme-set-grouphead）：
       // 旧的「无框 set-sec + 有框 set-card」混排是版面杂乱的一半来源
       ".mneme-set-title{font-size:14px;font-weight:600;color:var(--dsw-alias-label-primary);margin-bottom:4px}",
-      ".mneme-set-desc{font-size:13px;line-height:19px;color:var(--dsw-alias-label-tertiary);margin-bottom:14px}",
+      ".mneme-set-desc{font-size:13px;line-height:19px;color:var(--mneme-fg-dim);margin-bottom:14px}",
       ".mneme-set-input{box-sizing:border-box;width:100%;height:34px;padding:0 12px;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:13px;outline:none;margin-bottom:10px;transition:border-color .12s,box-shadow .12s}",
       ".mneme-set-input: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-set-input::placeholder{color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-set-input::placeholder{color:var(--mneme-fg-dim)}",
       ".mneme-set-input--area{height:auto;min-height:76px;padding:8px 12px;resize:vertical;line-height:1.6}",
       ".mneme-btn{flex:none;height:30px;padding:0 12px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:none;color:var(--dsw-alias-label-primary);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;display:inline-flex;align-items:center;gap:6px}",
       ".mneme-btn:hover{background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-btn:disabled{opacity:.5;cursor:default}",
-      ".mneme-saved{font-size:12px;color:var(--dsw-alias-state-success,#2a7)}",
+      ".mneme-saved{font-size:12px;color:var(--mneme-ok)}",
       // rule rows: numbered chips + hover-revealed delete
       ".mneme-set-row{display:flex;align-items:flex-start;gap:10px;padding:10px 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;margin-bottom:8px;background:var(--dsw-alias-bg-base,transparent)}",
-      ".mneme-set-idx{flex:none;width:20px;height:20px;border-radius:50%;border:1px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:18px;display:inline-flex;align-items:center;justify-content:center;font-variant-numeric:tabular-nums}",
+      ".mneme-set-idx{flex:none;width:20px;height:20px;border-radius:50%;border:1px solid var(--dsw-alias-border-l2);color:var(--mneme-fg-dim);font-size:11px;line-height:18px;display:inline-flex;align-items:center;justify-content:center;font-variant-numeric:tabular-nums}",
       ".mneme-set-ruletext{flex:1;min-width:0;font-size:13px;line-height:20px;color:var(--dsw-alias-label-primary);word-break:break-word}",
-      ".mneme-set-del{flex:none;opacity:0;transition:opacity .12s;border:none;background:none;color:var(--dsw-alias-label-tertiary);cursor:pointer;font-size:14px;line-height:20px;padding:0 4px;border-radius:6px}",
+      ".mneme-set-del{flex:none;opacity:0;transition:opacity .12s;border:none;background:none;color:var(--mneme-fg-dim);cursor:pointer;font-size:14px;line-height:20px;padding:0 4px;border-radius:6px}",
       ".mneme-set-row:hover .mneme-set-del,.mneme-set-row:focus-within .mneme-set-del{opacity:1}",
-      ".mneme-set-del:hover{color:var(--dsw-alias-state-error,#c33);background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-set-del:hover{color:var(--mneme-danger);background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-set-cmd{flex:1;min-width:0}",
-      ".mneme-set-cmdname{font-size:13px;font-weight:600;color:var(--dsw-alias-state-business-primary)}",
-      ".mneme-set-cmddesc{font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary);margin-top:1px;word-break:break-word}",
+      ".mneme-set-cmdname{font-size:13px;font-weight:600;color:var(--mneme-accent)}",
+      ".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}",
       // --- 记忆库页面：居中 sheet，非全屏 ---
@@ -1411,9 +1765,9 @@ window.__ModuleLoader__.load({
       ".mneme-stars{display:inline-flex;align-items:center;gap:2px}",
       // 热度徽章三档：热（橙）/温（次级文字）/冷（弱化文字），冷档藏百分比只留图标。
       ".mneme-heat{display:inline-flex;align-items:center;gap:2px;font-size:11px;line-height:14px;font-variant-numeric:tabular-nums}",
-      ".mneme-heat--hot{color:var(--dsw-alias-state-warning,#d97706)}",
+      ".mneme-heat--hot{color:var(--mneme-warn)}",
       ".mneme-heat--warm{color:var(--dsw-alias-label-secondary)}",
-      ".mneme-heat--cold{color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-heat--cold{color:var(--mneme-fg-dim)}",
       ".mneme-heat--cold .mneme-heatpct{display:none}",
       // 侧边栏入口两种形态的样式（挂载与搬移逻辑见 SidebarTopEntry 的头注释）。
       // 展开态兜底：逐条镜像宿主 panelRow（36px 行高 / 透明底 / 2px 外边距 /
@@ -1436,12 +1790,12 @@ window.__ModuleLoader__.load({
       // 菜单让位只在「收起 + 入口确实挂在标题栏里」时生效；展开态完全不碰宿主变量。
       "html[data-windows-titlebar]:has([data-sidebar-collapsed=true]):has([data-plugin-entry=\"@modusensus/dsh-mneme\"]){--dsh-windows-menu-start:120px}",
       // --- 功能开关：一行一开关，Claude 式安静排版 ---
-      ".mneme-featgroup{flex:none;font-size:12px;font-weight:600;letter-spacing:.02em;color:var(--dsw-alias-label-tertiary);margin:16px 0 2px}",
+      ".mneme-featgroup{flex:none;font-size:12px;font-weight:600;letter-spacing:.02em;color:var(--mneme-fg-dim);margin:16px 0 2px}",
       ".mneme-featrow{display:flex;align-items:center;gap:14px;padding:11px 2px;border-bottom:1px solid var(--dsw-alias-border-l1)}",
       ".mneme-featrow:last-child{border-bottom:none}",
       ".mneme-featmain{flex:1;min-width:0}",
       ".mneme-featname{font-size:13.5px;font-weight:500;line-height:20px;color:var(--dsw-alias-label-primary)}",
-      ".mneme-feathint{font-size:12.5px;line-height:18px;color:var(--dsw-alias-label-tertiary);margin-top:2px}",
+      ".mneme-feathint{font-size:12.5px;line-height:18px;color:var(--mneme-fg-dim);margin-top:2px}",
       ".mneme-switch{position:relative;flex:none;width:36px;height:22px;border-radius:11px;border:none;cursor:pointer;background:var(--dsw-alias-interactive-bg-active);transition:background .15s}",
       ".mneme-switch::after{content:\"\";position:absolute;top:2px;left:2px;width:18px;height:18px;border-radius:50%;background:var(--dsw-alias-bg-layer-1,#fff);box-shadow:0 1px 3px color-mix(in srgb,var(--dsw-alias-label-primary) 25%,transparent);transition:transform .15s}",
       ".mneme-switch.mneme-on{background:var(--dsw-alias-state-business-primary)}",
@@ -1457,14 +1811,14 @@ window.__ModuleLoader__.load({
       ".mneme-strinput: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-featsub{margin:2px 0 8px;padding:10px 12px;border:1px solid var(--dsw-alias-border-l1);border-radius:10px;display:flex;flex-direction:column;gap:6px}",
       ".mneme-featsub .mneme-featnum{padding:6px 0;border-bottom:none}",
-      ".mneme-featsubhint{font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-featsubhint{font-size:12px;line-height:17px;color:var(--mneme-fg-dim)}",
       // 运行时那一块的说明文字：比常规 hint 再小一档，它是背景信息而不是要读的正文。
-      ".mneme-runtimehint{font-size:11px;line-height:16px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-runtimehint{font-size:11px;line-height:16px;color:var(--mneme-fg-dim)}",
       // --- 交互式记忆库：工具栏 / 卡片网格 / 详情抽屉 / 更多菜单 ---
       // sheet 边距放宽：与窗口边缘保持呼吸距离，居中不顶满。
       // 视图切换（卡片/时间线）分段控件挂在子页栏右侧。
       ".mneme-seg{display:inline-flex;align-items:center;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;overflow:hidden}",
-      ".mneme-seg button{border:none;background:none;color:var(--dsw-alias-label-tertiary);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;padding:5px 10px;display:inline-flex;align-items:center;gap:5px}",
+      ".mneme-seg button{border:none;background:none;color:var(--mneme-fg-dim);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;padding:5px 10px;display:inline-flex;align-items:center;gap:5px}",
       ".mneme-seg button:hover{color:var(--dsw-alias-label-primary)}",
       ".mneme-seg button.mneme-active{background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary);font-weight:500}",
       // 卡片网格：响应式 auto-fill，卡片悬停轻浮起
@@ -1472,53 +1826,68 @@ window.__ModuleLoader__.load({
       ".mneme-card{display:flex;flex-direction:column;gap:7px;min-width:0;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;padding:12px 13px;background:var(--dsw-alias-bg-layer-1);cursor:pointer;font-family:inherit;text-align:left;transition:border-color .12s,box-shadow .12s,transform .12s}",
       ".mneme-card:hover{border-color:color-mix(in srgb,var(--dsw-alias-state-business-primary) 45%,var(--dsw-alias-border-l2));box-shadow:0 6px 20px color-mix(in srgb,var(--dsw-alias-label-primary) 10%,transparent);transform:translateY(-1px)}",
       ".mneme-card.mneme-active{border-color:var(--dsw-alias-state-business-primary)}",
-      ".mneme-cardhead{display:flex;align-items:center;gap:6px;font-size:11.5px;line-height:16px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-cardhead{display:flex;align-items:center;gap:6px;font-size:11.5px;line-height:16px;color:var(--mneme-fg-dim)}",
       ".mneme-cardtitle{font-size:13.5px;font-weight:600;line-height:19px;color:var(--dsw-alias-label-primary);word-break:break-word;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}",
       ".mneme-cardexcerpt{font-size:12.5px;line-height:18px;color:var(--dsw-alias-label-secondary);word-break:break-word;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden}",
-      ".mneme-cardfoot{display:flex;align-items:center;gap:8px;margin-top:auto;font-size:11.5px;line-height:16px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-cardfoot{display:flex;align-items:center;gap:8px;margin-top:auto;font-size:11.5px;line-height:16px;color:var(--mneme-fg-dim)}",
       ".mneme-cardsrc{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
       // 徽章：冲突待确认 / 已归档
       ".mneme-badge{flex:none;display:inline-flex;align-items:center;gap:4px;height:18px;padding:0 7px;border-radius:6px;font-size:11px;line-height:14px}",
-      ".mneme-badge--conflict{color:var(--dsw-alias-state-error,#c33);background:color-mix(in srgb,var(--dsw-alias-state-error,#c33) 10%,transparent);border:1px solid color-mix(in srgb,var(--dsw-alias-state-error,#c33) 30%,transparent)}",
-      ".mneme-badge--archived{color:var(--dsw-alias-label-tertiary);background:var(--dsw-alias-interactive-bg-hover)}",
-      ".mneme-badge--scope{color:var(--dsw-alias-state-business-primary);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent);border:1px solid color-mix(in srgb,var(--dsw-alias-state-business-primary) 30%,transparent)}",
+      ".mneme-badge--conflict{color:var(--mneme-danger);background:color-mix(in srgb,var(--mneme-danger) 10%,transparent);border:1px solid color-mix(in srgb,var(--mneme-danger) 30%,transparent)}",
+      ".mneme-badge--archived{color:var(--mneme-fg-dim);background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-badge--scope{color:var(--mneme-accent);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent);border:1px solid color-mix(in srgb,var(--dsw-alias-state-business-primary) 30%,transparent)}",
+      // 「默认 / 已改」徽标（#427）：default 复用 --archived 的语义色组合
+      // （fg-dim on interactive-bg-hover），changed 复用 --scope 的 accent 组
+      // 合——两组配对都已过 contrast.test.js 的重算，不再发明新颜色。
+      ".mneme-badge--default{color:var(--mneme-fg-dim);background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-badge--changed{color:var(--mneme-accent);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent);border:1px solid color-mix(in srgb,var(--dsw-alias-state-business-primary) 30%,transparent)}",
       // 冲突集中处理队列（v0.8.0）：状态页的待确认冲突列表
       ".mneme-conflictq{display:flex;flex-direction:column;gap:10px}",
       ".mneme-conflictq-head{display:flex;align-items:center;gap:8px}",
-      ".mneme-conflict-item{border:1px solid var(--dsw-alias-border,var(--dsw-alias-interactive-bg-hover));border-radius:10px;padding:10px;display:flex;flex-direction:column;gap:8px}",
+      ".mneme-conflict-item{border:1px solid var(--dsw-alias-border-l1,var(--dsw-alias-interactive-bg-hover));border-radius:10px;padding:10px;display:flex;flex-direction:column;gap:8px}",
       ".mneme-conflict-reason{font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary)}",
       ".mneme-conflict-pair{display:grid;grid-template-columns:1fr 1fr;gap:8px}",
-      ".mneme-conflict-side{border:1px solid var(--dsw-alias-border,var(--dsw-alias-interactive-bg-hover));border-radius:8px;padding:8px;display:flex;flex-direction:column;gap:4px;min-width:0}",
-      ".mneme-conflict-sidelabel{font-size:11px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-conflict-side{border:1px solid var(--dsw-alias-border-l1,var(--dsw-alias-interactive-bg-hover));border-radius:8px;padding:8px;display:flex;flex-direction:column;gap:4px;min-width:0}",
+      ".mneme-conflict-sidelabel{font-size:11px;color:var(--mneme-fg-dim)}",
       ".mneme-conflict-sidetitle{font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
       ".mneme-conflict-snippet{font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary);display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden}",
-      ".mneme-conflict-missing{font-size:12px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-conflict-missing{font-size:12px;color:var(--mneme-fg-dim)}",
       ".mneme-conflict-actions{display:flex;align-items:center;gap:6px;flex-wrap:wrap}",
-      ".mneme-conflict-hint{font-size:11px;color:var(--dsw-alias-label-tertiary);margin-right:auto}",
+      ".mneme-conflict-hint{font-size:11px;color:var(--mneme-fg-dim);margin-right:auto}",
       // #177 冲突队列视觉批次：A/B 侧色、相似度条、词级 diff、主色按钮、空态
       ".mneme-conflict-side--a{border-color:color-mix(in srgb,var(--dsw-alias-state-business-primary) 35%,transparent);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 4%,transparent)}",
-      ".mneme-conflict-side--a .mneme-conflict-sidelabel{color:var(--dsw-alias-state-business-primary);font-weight:600}",
-      ".mneme-conflict-side--b{border-color:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 45%,transparent);background:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 5%,transparent)}",
-      ".mneme-conflict-side--b .mneme-conflict-sidelabel{color:var(--dsw-alias-state-warning,#e6a23c);font-weight:600}",
+      ".mneme-conflict-side--a .mneme-conflict-sidelabel{color:var(--mneme-accent);font-weight:600}",
+      ".mneme-conflict-side--b{border-color:color-mix(in srgb,var(--mneme-warn) 45%,transparent);background:color-mix(in srgb,var(--mneme-warn) 5%,transparent)}",
+      ".mneme-conflict-side--b .mneme-conflict-sidelabel{color:var(--mneme-warn);font-weight:600}",
       ".mneme-conflict-simrow{display:flex;align-items:center;gap:8px;font-size:11px;color:var(--dsw-alias-label-secondary)}",
       ".mneme-conflict-simbar{position:relative;flex:1;height:5px;border-radius:3px;background:var(--dsw-alias-interactive-bg-hover);overflow:hidden}",
       ".mneme-conflict-simfill{position:absolute;top:0;bottom:0;left:0;border-radius:3px;background:var(--dsw-alias-state-business-primary)}",
       ".mneme-conflict-diff{font-size:12px;line-height:18px;color:var(--dsw-alias-label-primary);display:-webkit-box;-webkit-line-clamp:4;-webkit-box-orient:vertical;overflow:hidden}",
+      // 展开全文：取消行数钳制并给一个内部滚动区——报障点是「窗口太小又不能
+      // 放大，完全对比不了内容」，所以展开态必须能容纳长文本且不撑破面板。
+      // 上限用 em 而非 vh：宿主可能把面板放在零高视口里（隐藏 webview / 后台
+      // 页），那时 46vh 会算成 0px，展开态直接看不见字——实测踩过。
+      ".mneme-conflict-diff--full{display:block;-webkit-line-clamp:unset;max-height:28em;overflow-y:auto}",
+      ".mneme-conflict-text{font-size:12px;line-height:18px;color:var(--dsw-alias-label-primary);white-space:pre-wrap;overflow-wrap:anywhere;max-height:28em;overflow-y:auto}",
+      ".mneme-conflict-meta{display:flex;align-items:center;gap:6px;flex-wrap:wrap;font-size:11px;line-height:16px;color:var(--mneme-fg-dim)}",
+      ".mneme-conflict-metaval{color:var(--dsw-alias-label-secondary)}",
+      // 窄面板下并排会把每侧挤到无法阅读，退成单列（容器查询按面板实际宽度判）
+      "@container (max-width:560px){.mneme-conflict-pair{grid-template-columns:1fr}}",
       ".mneme-conflict-mark{text-decoration:none;border-radius:3px;padding:0 1px}",
-      ".mneme-conflict-mark--del{background:color-mix(in srgb,var(--dsw-alias-state-error,#c33) 16%,transparent);text-decoration:line-through}",
-      ".mneme-conflict-mark--ins{background:color-mix(in srgb,var(--dsw-alias-state-success,#3c9) 18%,transparent)}",
-      ".mneme-conflict-primary{display:inline-flex;align-items:center;gap:4px;height:24px;padding:0 10px;border-radius:8px;border:none;background:var(--dsw-alias-state-business-primary);color:var(--dsw-alias-bg-layer-1);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px}",
+      ".mneme-conflict-mark--del{background:color-mix(in srgb,var(--mneme-danger) 16%,transparent);text-decoration:line-through}",
+      ".mneme-conflict-mark--ins{background:color-mix(in srgb,var(--mneme-ok) 18%,transparent)}",
+      ".mneme-conflict-primary{display:inline-flex;align-items:center;gap:4px;height:24px;padding:0 10px;border-radius:8px;border:none;background:var(--mneme-accent);color:var(--dsw-alias-bg-layer-1);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px}",
       ".mneme-conflict-primary:disabled{opacity:.55;cursor:default}",
-      ".mneme-conflict-primary:hover:not(:disabled){background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 85%,black)}",
-      ".mneme-badge--frozen{color:var(--dsw-alias-state-warning,#e6a23c);background:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 12%,transparent)}",
+      ".mneme-conflict-primary:hover:not(:disabled){background:color-mix(in srgb,var(--mneme-accent) 85%,var(--dsw-alias-label-primary))}",
+      ".mneme-badge--frozen{color:var(--mneme-warn);background:color-mix(in srgb,var(--mneme-warn) 12%,transparent)}",
       ".mneme-conflict-empty{border:1px dashed var(--dsw-alias-border-l2);border-radius:10px;padding:12px 14px;display:flex;flex-direction:column;gap:4px}",
       ".mneme-conflict-empty-title{font-size:12.5px;font-weight:600;color:var(--dsw-alias-label-secondary)}",
-      ".mneme-conflict-empty-body{font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}",
-      ".mneme-statuscard--actionable{border-color:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 55%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 35%,transparent)}",
-      ".mneme-entrybadge{position:absolute;top:-3px;right:-3px;min-width:16px;height:16px;padding:0 4px;border-radius:8px;background:var(--dsw-alias-state-error,#c33);color:var(--dsw-alias-bg-layer-1,#fff);font-size:10.5px;line-height:16px;font-weight:600;text-align:center;box-shadow:0 0 0 2px var(--dsw-alias-bg-layer-1)}",
+      ".mneme-conflict-empty-body{font-size:12px;line-height:18px;color:var(--mneme-fg-dim)}",
+      ".mneme-statuscard--actionable{border-color:color-mix(in srgb,var(--mneme-warn) 55%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--mneme-warn) 35%,transparent)}",
+      ".mneme-entrybadge{position:absolute;top:-3px;right:-3px;min-width:16px;height:16px;padding:0 4px;border-radius:8px;background:var(--mneme-danger);color:var(--dsw-alias-bg-layer-1,#fff);font-size:10.5px;line-height:16px;font-weight:600;text-align:center;box-shadow:0 0 0 2px var(--dsw-alias-bg-layer-1)}",
       ".mneme-triggerwrap{position:relative;pointer-events:none}",
       ".mneme-triggerwrap .mneme-trigger{pointer-events:auto}",
-      ".mneme-conflict-jump .mneme-statuscard{border-color:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 55%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 35%,transparent)}",
+      ".mneme-conflict-jump .mneme-statuscard{border-color:color-mix(in srgb,var(--mneme-warn) 55%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--mneme-warn) 35%,transparent)}",
       ".mneme-conflict-jump:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:2px;border-radius:12px}",
       // 详情抽屉：sheet 内右侧滑出，覆盖在浏览区之上
       ".mneme-xmain{position:relative}",
@@ -1530,7 +1899,7 @@ window.__ModuleLoader__.load({
       ".mneme-drawertitle{width:100%;font-size:16px;font-weight:600;line-height:23px;color:var(--dsw-alias-label-primary);word-break:break-word}",
       ".mneme-drawertitle-input{width:100%;box-sizing:border-box;font-size:15px;font-weight:600;line-height:22px;padding:7px 10px;border-radius:8px;border:1px solid var(--dsw-alias-state-business-primary);background:var(--dsw-alias-bg-base,transparent);color:var(--dsw-alias-label-primary);font-family:inherit;outline:none;box-shadow:0 0 0 3px color-mix(in srgb,var(--dsw-alias-state-business-primary) 15%,transparent)}",
       ".mneme-dmeta{display:grid;grid-template-columns:auto 1fr;gap:4px 14px;margin-top:12px;font-size:12.5px;line-height:19px}",
-      ".mneme-dmetakey{color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-dmetakey{color:var(--mneme-fg-dim)}",
       ".mneme-dmetaval{color:var(--dsw-alias-label-secondary);min-width:0;word-break:break-word}",
       ".mneme-dcontent{margin-top:14px;font-size:13.5px;line-height:1.75;color:var(--dsw-alias-label-primary);white-space:pre-wrap;word-break:break-word}",
       ".mneme-dcontent-input{width:100%;box-sizing:border-box;min-height:180px;font-size:13.5px;line-height:1.7;padding:9px 11px;border-radius:8px;border:1px solid var(--dsw-alias-state-business-primary);background:var(--dsw-alias-bg-base,transparent);color:var(--dsw-alias-label-primary);font-family:inherit;outline:none;resize:vertical;box-shadow:0 0 0 3px color-mix(in srgb,var(--dsw-alias-state-business-primary) 15%,transparent)}",
@@ -1550,12 +1919,12 @@ window.__ModuleLoader__.load({
       // --- explorer refresh: paged month tree, sticky headers, inline icons ---
       ".mneme-vtabico{flex:none;opacity:.85}",
       ".mneme-xsearchwrap{position:relative;flex:none}",
-      ".mneme-xsearchico{position:absolute;left:9px;top:50%;transform:translateY(-50%);color:var(--dsw-alias-label-tertiary);pointer-events:none}",
+      ".mneme-xsearchico{position:absolute;left:9px;top:50%;transform:translateY(-50%);color:var(--mneme-fg-dim);pointer-events:none}",
       ".mneme-xsearchwrap .mneme-xsearch{padding-left:27px}",
       ".mneme-footbtn{display:inline-flex;align-items:center;gap:4px}",
       ".mneme-xmonth{position:sticky;top:0;z-index:2;background:var(--dsw-alias-bg-layer-1);display:flex;align-items:center;gap:6px}",
-      ".mneme-xmonthcount{margin-left:auto;color:var(--dsw-alias-label-tertiary);font-weight:400;font-variant-numeric:tabular-nums}",
-      ".mneme-xcaret{display:inline-flex;align-items:center;justify-content:center;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-xmonthcount{margin-left:auto;color:var(--mneme-fg-dim);font-weight:400;font-variant-numeric:tabular-nums}",
+      ".mneme-xcaret{display:inline-flex;align-items:center;justify-content:center;color:var(--mneme-fg-dim)}",
       ".mneme-xmore{display:flex;justify-content:center;align-items:center;padding:10px 0 24px;min-height:20px}",
       ".mneme-xemptyico{display:block;margin:0 auto 6px;opacity:.7}",
       // --- status sub-view: responsive stat-card grid (auto-fill, ~220px min) ---
@@ -1569,45 +1938,103 @@ window.__ModuleLoader__.load({
       "@container (min-width:452px) and (max-width:683px){.mneme-statuscard--vectorwide{grid-column:span 2}}",
       "@container (min-width:452px){.mneme-statuscard--wide{grid-column:span 2}}",
       // 状态页分组标题（库内一览 / 后台运转）：只做扫读锚点，压得比卡片标题低
-      ".mneme-statushead{max-width:1000px;margin:0 auto 10px;font-size:12px;font-weight:600;letter-spacing:.02em;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-statushead{max-width:1000px;margin:0 auto 10px;font-size:12px;font-weight:600;letter-spacing:.02em;color:var(--mneme-fg-dim)}",
       ".mneme-statusgrid+.mneme-statushead{margin-top:26px}",
       ".mneme-statuscard{min-width:0;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;padding:16px 16px 14px}",
       // 指标行：一行一指标（label 左 / 数值右），取代「·」串联的说明长句——
       // 拥挤感的根源是把多指标压进一段会换行的散文
       ".mneme-statrows{margin-top:10px;display:flex;flex-direction:column;gap:4px}",
-      ".mneme-statrow{display:flex;align-items:baseline;justify-content:space-between;gap:12px;font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-statrow{display:flex;align-items:baseline;justify-content:space-between;gap:12px;font-size:12px;line-height:17px;color:var(--mneme-fg-dim)}",
       ".mneme-statrow>span:first-child{flex:none;white-space:nowrap}",
       ".mneme-statrow .mneme-heatdot{align-self:center}",
       ".mneme-statrowval{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--dsw-alias-label-secondary);font-variant-numeric:tabular-nums;text-align:right}",
-      ".mneme-statfoot{margin-top:8px;font-size:11px;line-height:16px;color:var(--dsw-alias-label-dimmed)}",
+      ".mneme-statfoot{margin-top:8px;font-size:11px;line-height:16px;color:var(--mneme-fg-dim)}",
       // 热度分布条：三档占比一图看清，行标只补数字（类名带双横线，与 heatdot 同款）
       ".mneme-heatbar{display:flex;height:6px;border-radius:3px;overflow:hidden;margin-top:12px;background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-heatbar-seg{min-width:2px}",
-      ".mneme-heatbar--hot{background:var(--dsw-alias-state-warning,#d97706)}",
-      ".mneme-heatbar--warm{background:var(--dsw-alias-label-tertiary)}",
-      ".mneme-heatbar--cold{background:var(--dsw-alias-label-dimmed)}",
+      ".mneme-heatbar--hot{background:var(--mneme-warn)}",
+      ".mneme-heatbar--warm{background:var(--mneme-fg-dim)}",
+      ".mneme-heatbar--cold{background:var(--mneme-graphic-dim)}",
       ".mneme-heatdot{flex:none;width:8px;height:8px;border-radius:50%}",
-      ".mneme-heatdot--hot{background:var(--dsw-alias-state-warning,#d97706)}",
-      ".mneme-heatdot--warm{background:var(--dsw-alias-label-tertiary)}",
-      ".mneme-heatdot--cold{background:var(--dsw-alias-label-dimmed)}",
+      ".mneme-heatdot--hot{background:var(--mneme-warn)}",
+      ".mneme-heatdot--warm{background:var(--mneme-fg-dim)}",
+      ".mneme-heatdot--cold{background:var(--mneme-graphic-dim)}",
+      // --- Token 去向三屏（2026-10 可观测性改造）：KPI 带 / donut / 7 天柱状 / 8 周热力 ---
+      // KPI 带固定 4 列、容器收窄降 2 列：用 @container 不用 @media——面板同时长在
+      // 宿主侧栏（~500px）与 sheet（1240px）里，决定布局的是容器宽度而非视口。
+      ".mneme-kpiband{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px;max-width:1000px;margin:0 auto 12px}",
+      "@container (max-width:560px){.mneme-kpiband{grid-template-columns:repeat(2,minmax(0,1fr))}}",
+      ".mneme-tokenflow{max-width:1000px;margin:0 auto 12px;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;padding:16px 16px 14px}",
+      ".mneme-donutwrap{display:flex;gap:20px;align-items:center;margin-top:12px}",
+      "@container (max-width:480px){.mneme-donutwrap{flex-direction:column;align-items:stretch}.mneme-donutbox{align-self:center}}",
+      ".mneme-donutbox{position:relative;flex:none;width:148px;height:148px}",
+      ".mneme-donutbox svg{width:100%;height:100%;display:block}",
+      ".mneme-donut-center{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;pointer-events:none}",
+      ".mneme-donut-center b{font-size:19px;font-weight:650;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-primary)}",
+      ".mneme-donut-center span{font-size:11px;color:var(--mneme-fg-dim);margin-top:1px}",
+      // r=15.9155 让周长≈100，dasharray 直接填百分比；段缝靠 JS 侧留，这里只管观感。
+      ".mneme-donut circle.mneme-seg{fill:none;stroke-width:5.6;transition:opacity .15s}",
+      ".mneme-donut.has-focus circle.mneme-seg:not(.focused){opacity:.35}",
+      ".mneme-seg--1{stroke:var(--mneme-chart-1)}",
+      ".mneme-seg--2{stroke:var(--mneme-chart-2)}",
+      ".mneme-seg--3{stroke:var(--mneme-chart-3)}",
+      ".mneme-seg--4{stroke:var(--mneme-chart-4)}",
+      ".mneme-seg--5{stroke:var(--mneme-chart-5)}",
+      ".mneme-seg--6{stroke:color-mix(in srgb,var(--dsw-alias-label-primary) 50%,transparent)}",
+      ".mneme-legend{flex:1;min-width:0;display:flex;flex-direction:column;gap:2px}",
+      ".mneme-legendrow{display:flex;align-items:center;gap:8px;padding:5px 8px;border-radius:8px;cursor:default;font-size:12.5px;line-height:18px;color:var(--dsw-alias-label-primary)}",
+      ".mneme-legendrow:hover,.mneme-legendrow.focused{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-legendrow.dim{opacity:.45}",
+      ".mneme-legenddot{flex:none;width:10px;height:10px;border-radius:3px}",
+      ".mneme-dot--1{background:var(--mneme-chart-1)}",
+      ".mneme-dot--2{background:var(--mneme-chart-2)}",
+      ".mneme-dot--3{background:var(--mneme-chart-3)}",
+      ".mneme-dot--4{background:var(--mneme-chart-4)}",
+      ".mneme-dot--5{background:var(--mneme-chart-5)}",
+      ".mneme-dot--6{background:color-mix(in srgb,var(--dsw-alias-label-primary) 50%,transparent)}",
+      ".mneme-legendname{color:var(--dsw-alias-label-primary);white-space:nowrap}",
+      ".mneme-legendsub{color:var(--mneme-fg-dim);font-size:11px}",
+      ".mneme-legendval{margin-left:auto;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-secondary);white-space:nowrap}",
+      ".mneme-legendpct{flex:none;width:46px;text-align:right;font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-primary);font-weight:600}",
+      ".mneme-bars{position:relative;height:150px;margin-top:14px}",
+      ".mneme-gridline{position:absolute;left:0;right:0;border-top:1px dashed var(--dsw-alias-border-l2)}",
+      ".mneme-gridlabel{position:absolute;right:0;transform:translateY(-58%);font-size:10px;color:var(--mneme-fg-dim)}",
+      ".mneme-barcols{position:absolute;inset:0;display:flex;align-items:flex-end;gap:8px;padding:0 2px}",
+      ".mneme-barcol{flex:1;min-width:0;display:flex;flex-direction:column;justify-content:flex-end;height:100%}",
+      ".mneme-bar{border-radius:5px 5px 2px 2px;background:var(--mneme-accent);min-height:2px;transition:opacity .15s}",
+      ".mneme-barcol:hover .mneme-bar{opacity:.8}",
+      ".mneme-barlabels{display:flex;gap:8px;padding:6px 2px 0}",
+      ".mneme-barlabels span{flex:1;min-width:0;text-align:center;font-size:10.5px;color:var(--mneme-fg-dim);font-variant-numeric:tabular-nums}",
+      ".mneme-heatgrid{display:grid;grid-auto-flow:column;grid-template-rows:repeat(7,12px);gap:3px;margin-top:12px}",
+      ".mneme-heatcell{width:12px;height:12px;border-radius:3px;background:var(--dsw-alias-interactive-bg-hover)}",
+      // 类名编号=视觉档位（l1 最浅…l4 最深），变量编号=business 占比降序，故交叉引用。
+      ".mneme-heatcell.l1{background:var(--mneme-heat-4)}",
+      ".mneme-heatcell.l2{background:var(--mneme-heat-3)}",
+      ".mneme-heatcell.l3{background:var(--mneme-heat-2)}",
+      ".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}",
+      // 原 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)}",
       // --- 状态页工作台：让用户看见插件在干活（动态/沉淀/归档） ---
       ".mneme-wbhead{margin:28px auto 10px;font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);max-width:1000px;display:flex;align-items:baseline;justify-content:space-between;gap:8px}",
       ".mneme-wblist{max-width:1000px;display:flex;flex-direction:column;gap:6px}",
       ".mneme-wbrow{display:flex;gap:10px;align-items:flex-start;padding:10px 14px;border:1px solid var(--dsw-alias-border-l1);border-radius:10px}",
-      ".mneme-wbdot{flex:none;width:8px;height:8px;border-radius:50%;margin-top:6px;background:var(--dsw-alias-state-success,#2a9d6a)}",
-      ".mneme-wbdot--err{background:var(--dsw-alias-state-error,#c33)}",
+      ".mneme-wbdot{flex:none;width:8px;height:8px;border-radius:50%;margin-top:6px;background:var(--mneme-ok)}",
+      ".mneme-wbdot--err{background:var(--mneme-danger)}",
       ".mneme-wbmain{min-width:0;flex:1}",
       ".mneme-wbtitle{font-size:13px;line-height:19px;color:var(--dsw-alias-label-primary)}",
-      ".mneme-wbsub{font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary);margin-top:1px}",
+      ".mneme-wbsub{font-size:12px;line-height:17px;color:var(--mneme-fg-dim);margin-top:1px}",
       ".mneme-wbmemo{display:flex;gap:10px;align-items:center;padding:10px 14px;border:1px solid var(--dsw-alias-border-l1);border-radius:10px}",
       ".mneme-wbmemo .mneme-xdot{flex:none}",
       ".mneme-wbmemo-main{min-width:0;flex:1}",
       ".mneme-statusnum{font-size:24px;font-weight:600;line-height:32px;color:var(--dsw-alias-label-primary);font-variant-numeric:tabular-nums}",
-      ".mneme-statuscap{margin-top:4px;font-size:13px;line-height:19px;color:var(--dsw-alias-label-tertiary);word-break:break-word}",
+      ".mneme-statuscap{margin-top:4px;font-size:13px;line-height:19px;color:var(--mneme-fg-dim);word-break:break-word}",
       // --- destructive actions: red outline = delete, solid red = confirm ---
-      ".mneme-btndanger{color:var(--dsw-alias-state-error,#c33);border-color:var(--dsw-alias-state-error,#c33)}",
-      ".mneme-btndanger:hover{background:color-mix(in srgb,var(--dsw-alias-state-error,#c33) 12%,transparent)}",
-      ".mneme-btndangerconfirm{background:var(--dsw-alias-state-error,#c33);border-color:var(--dsw-alias-state-error,#c33);color:#fff}",
+      ".mneme-btndanger{color:var(--mneme-danger);border-color:var(--mneme-danger)}",
+      ".mneme-btndanger:hover{background:color-mix(in srgb,var(--mneme-danger) 12%,transparent)}",
+      ".mneme-btndangerconfirm{background:var(--mneme-danger);border-color:var(--mneme-danger);color:var(--dsw-alias-bg-layer-1)}",
       ".mneme-btndangerconfirm:hover{filter:brightness(.9)}",
       // --- settings cards: boxed cards for the runtime-mode and external-API
       // sections — each card owns its fetch/PUT state, so it renders as a
@@ -1615,14 +2042,14 @@ window.__ModuleLoader__.load({
       ".mneme-set-card{border:1px solid var(--dsw-alias-border-l2);border-radius:12px;padding:16px;margin-bottom:10px}",
       // 设置页分组标题（个性化 / 记忆引擎 / 搜索 / 连接与安全 / 帮助）：
       // 先给「这一段在管什么」，卡片才是具体选项
-      ".mneme-set-grouphead{font-size:12px;font-weight:600;letter-spacing:.02em;color:var(--dsw-alias-label-tertiary);margin:24px 0 10px}",
+      ".mneme-set-grouphead{font-size:12px;font-weight:600;letter-spacing:.02em;color:var(--mneme-fg-dim);margin:24px 0 10px}",
       ".mneme-set-grouphead:first-child{margin-top:8px}",
       ".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(--dsw-alias-label-tertiary)}",
+      ".mneme-set-hint{font-size:12px;color:var(--mneme-fg-dim)}",
       // --- 重要性编辑行：与查看态同一份 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}",
-      ".mneme-starbtn--on{color:var(--dsw-alias-state-warning,#d97706)}",
+      ".mneme-starbtn--on{color:var(--mneme-warn)}",
       ".mneme-starbtn:hover{transform:scale(1.12)}",
       ".mneme-starbtn:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px;border-radius:4px}",
       // --- 意见与反馈：图标行 + 版本 footer，收在设置页末尾当「关于」用 ---
@@ -1633,8 +2060,170 @@ window.__ModuleLoader__.load({
       ".mneme-feedrow:hover .mneme-feedico{background:var(--dsw-alias-interactive-bg-active)}",
       ".mneme-feedtext{display:flex;flex-direction:column;gap:1px;min-width:0}",
       ".mneme-feedname{font-size:13px;line-height:18px;font-weight:500;color:var(--dsw-alias-label-primary)}",
-      ".mneme-feedsub{font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary)}",
-      ".mneme-set-foot{display:flex;align-items:baseline;justify-content:space-between;gap:12px;margin-top:12px;padding-top:10px;border-top:1px solid var(--dsw-alias-border-l1);font-size:12px;color:var(--dsw-alias-label-tertiary)}"
+      ".mneme-feedsub{font-size:12px;line-height:17px;color:var(--mneme-fg-dim)}",
+      ".mneme-set-foot{display:flex;align-items:baseline;justify-content:space-between;gap:12px;margin-top:12px;padding-top:10px;border-top:1px solid var(--dsw-alias-border-l1);font-size:12px;color:var(--mneme-fg-dim)}",
+      // --- 存储回收卡（#386 第 4 条）：控制行 + 两步确认的警告块 ---
+      ".mneme-maintrow{display:flex;align-items:center;gap:8px;flex-wrap:wrap;margin-top:10px}",
+      ".mneme-maintlbl{flex:none;font-size:12px;line-height:17px;color:var(--mneme-fg-dim)}",
+      ".mneme-maintrow .mneme-set-input{flex:none;width:96px;margin-bottom:0}",
+      ".mneme-maintcheck{display:flex;align-items:center;gap:8px;margin-top:12px;font-size:13px;line-height:19px;color:var(--dsw-alias-label-primary)}",
+      ".mneme-maintwarn{margin-top:12px;padding:10px 12px;border-radius:10px;border:1px solid color-mix(in srgb,var(--mneme-danger) 45%,transparent);background:color-mix(in srgb,var(--mneme-danger) 8%,transparent)}",
+      ".mneme-maintwarnhead{font-size:13px;line-height:19px;font-weight:600;color:var(--mneme-danger)}",
+      ".mneme-maintresult{margin-top:12px;padding-top:10px;border-top:1px solid var(--dsw-alias-border-l1)}",
+      ".mneme-maintresulthead{font-size:13px;line-height:19px;font-weight:600;color:var(--mneme-ok)}",
+      ".mneme-mainterr{margin-top:10px;font-size:12px;line-height:17px;color:var(--mneme-danger)}",
+      // --- v0.9.0 M.O.（beta）---------------------------------------------
+      // 语义色层第二份：浮层面板（portal 到 body）、右栏 pane、退化 sheet、
+      // 对话行结算卡都不在原四个渲染根之下。contrast.test.js 对原四根选择器
+      // 做精确匹配锁，所以这里另起一条规则、取值逐字相同，且必须排在其后
+      // （测试按首次出现抓取 --mneme-* 定义）。引用的宿主 token 全部在
+      // test/contrast.test.js 的 HOST_TOKENS 快照里，不许新增名字。
+      ".mneme-pipe,.mneme-pipeview,.mneme-pipe-settle,.mneme-pipe-root{" +
+        "--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));" +
+        "--mneme-danger:color-mix(in srgb,var(--dsw-alias-state-error-primary) 80%,var(--dsw-alias-label-primary));" +
+        "--mneme-warn:color-mix(in srgb,var(--dsw-static-amber-600,#dd8629) 65%,var(--dsw-alias-label-primary));" +
+        "--mneme-ok:color-mix(in srgb,var(--dsw-static-green-500,#22c55e) 65%,var(--dsw-alias-label-primary))" +
+      "}",
+      // 会话头 trigger：与 Agent Teams 同规格（28px 行高、12px 字号），
+      // 页头窄容器下文字标签隐藏、降级纯图标。
+      ".mneme-pipe-root{position:relative;display:inline-flex}",
+      ".mneme-pipe-trigger{min-height:28px;color:var(--dsw-alias-label-secondary);cursor:pointer;background:0 0;border:0;border-radius:6px;align-items:center;gap:5px;padding:3px 7px;font-family:inherit;font-size:12px;display:inline-flex}",
+      ".mneme-pipe-trigger:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-pipe-trigger:focus-visible{color:var(--dsw-alias-label-primary);outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}",
+      ".mneme-pipe-triggerLabel{white-space:nowrap}",
+      "@container (width<=480px){.mneme-pipe-triggerLabel{display:none}}",
+      ".mneme-pipe-dot{flex:none;min-width:14px;height:14px;border-radius:7px;padding:0 3px;background:color-mix(in srgb,var(--mneme-warn) 14%,transparent);color:var(--dsw-alias-label-primary);font-size:10px;line-height:14px;font-weight:600;font-variant-numeric:tabular-nums;text-align:center}",
+      // 浮层面板：几何抄 Agent Teams（min(500px,100vw-32px) / 12px 圆角 /
+      // fixed 定位由 useAnchoredPosition 给出）。阴影用中性 rgba：宿主的
+      // elevation token 不在面板 token 快照白名单里，不能引用。
+      ".mneme-pipe-panel{z-index:100;box-sizing:border-box;width:min(500px,100vw - 32px);max-height:min(680px,100vh - 32px);border:1px solid var(--dsw-alias-border-l2);border-radius:12px;flex-direction:column;padding:0;display:flex;position:fixed;overflow:hidden;background:var(--dsw-alias-bg-layer-1);box-shadow:0 8px 28px rgba(0,0,0,0.28);color:var(--dsw-alias-label-primary)}",
+      ".mneme-pipe-head{flex:none;display:flex;align-items:center;gap:8px;padding:10px 12px 8px 14px;border-bottom:1px solid var(--dsw-alias-border-l1)}",
+      ".mneme-pipe-title{font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);display:inline-flex;align-items:center;gap:6px;min-width:0}",
+      ".mneme-pipe-beta{flex:none;font-size:11px;line-height:16px;font-weight:600;color:var(--mneme-warn);border:1px solid color-mix(in srgb,var(--mneme-warn) 55%,transparent);border-radius:6px;padding:0 6px}",
+      // 内测免责：界面常驻一行，「候选」是可见状态词不是 tooltip。
+      ".mneme-pipe-notice{flex:none;display:flex;gap:6px;align-items:flex-start;padding:7px 14px 0;font-size:12px;line-height:17px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-scope{flex:none;font-size:11px;line-height:16px;color:var(--mneme-fg-dim)}",
+      // 运行档位：一次运行一个芯片；失败/被推翻的运行照常列出（留痕）。
+      ".mneme-pipe-runs{flex:none;display:flex;gap:6px;flex-wrap:wrap;padding:6px 14px 2px}",
+      ".mneme-pipe-run{border:1px solid var(--dsw-alias-border-l2);background:0 0;border-radius:8px;cursor:pointer;color:var(--mneme-fg-dim);font-family:inherit;font-size:12px;line-height:16px;padding:2px 8px;display:inline-flex;gap:6px;align-items:center}",
+      ".mneme-pipe-run:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-pipe-run:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}",
+      ".mneme-pipe-run.mneme-on{border-color:var(--dsw-alias-state-business-primary);color:var(--dsw-alias-label-primary);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent)}",
+      ".mneme-pipe-runDot{flex:none;width:8px;height:8px;border-radius:4px}",
+      ".mneme-pipe-runDot--ok{background:var(--mneme-ok)}",
+      ".mneme-pipe-runDot--failed{background:var(--mneme-warn)}",
+      ".mneme-pipe-runDot--refuted{background:var(--mneme-danger)}",
+      // 图：宽态 SVG 分层 DAG（trace viewer 读法），窄态整块换成竖排列表。
+      // 高度下限：flex:1 的基准是 0，只要某一层祖先没有确定高度（浮层与居中 sheet 都是 max-height
+      // 封顶），分到的就是 0 像素——画布「在 DOM 里、但看不见」。下限不修复成因，只保证最坏情况下
+      // 还能看见图；这跟上面那条撞车是两件事，别把任何一条当成另一条的修复。
+      ".mneme-pipe-graph{flex:1;min-height:220px;overflow:auto;padding:4px 8px 2px}",
+      // 缩放条与缩放容器。画布本身是 width:100% 的 SVG，所以「缩放」= 改外层容器的百分比宽度：
+      // 100% 就是适应栏宽，放大则容器比栏宽，滚动条自己出来——平移不必另写一套。
+      ".mneme-pipe-zoombar{flex:none;display:flex;align-items:center;gap:6px;padding:5px 12px 0;font-size:12px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-zoombtn{border:1px solid var(--dsw-alias-border-l2);background:0 0;border-radius:6px;cursor:pointer;color:var(--mneme-fg-dim);font-family:inherit;font-size:12px;line-height:16px;padding:1px 7px}",
+      ".mneme-pipe-zoombtn:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-pipe-zoombtn:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}",
+      ".mneme-pipe-zoomval{min-width:40px;text-align:right;font-variant-numeric:tabular-nums}",
+      ".mneme-pipe-zoomwrap{min-width:0}",
+      ".mneme-pipe-svg{display:block;width:100%;height:auto}",
+      ".mneme-pipe-edge{stroke:var(--mneme-graphic-dim);fill:none;stroke-width:1.5}",
+      ".mneme-pipe-edgeOn{stroke:var(--mneme-accent);fill:none;stroke-width:2.5}",
+      ".mneme-pipe-edgeFail{stroke:var(--mneme-danger);fill:none;stroke-width:2;stroke-dasharray:5 3}",
+      // 节点形状按 kind 区分（step 矩形 / gate 菱形 / branch 圆角 / artifact 胶囊），
+      // 状态走描边+填充：refuted 是全篇核心信号，双份危险色最扎眼。
+      ".mneme-pipe-node{fill:var(--dsw-alias-bg-layer-2);stroke:var(--mneme-graphic-dim);stroke-width:1.2}",
+      ".mneme-pipe-node--trusted{stroke:var(--mneme-ok);stroke-width:1.6}",
+      ".mneme-pipe-node--candidate{stroke:var(--mneme-graphic-dim)}",
+      ".mneme-pipe-node--stale{stroke:var(--dsw-alias-border-l2);stroke-dasharray:3 2;fill:var(--dsw-alias-bg-base)}",
+      ".mneme-pipe-node--refuted{stroke:var(--mneme-danger);stroke-width:2;fill:color-mix(in srgb,var(--mneme-danger) 10%,transparent)}",
+      ".mneme-pipe-node--onpath{stroke:var(--dsw-alias-state-business-primary);stroke-width:2}",
+      ".mneme-pipe-nodeT{fill:var(--dsw-alias-label-primary);font-size:11px;font-weight:600}",
+      ".mneme-pipe-nodeS{fill:var(--mneme-fg-dim);font-size:9.5px}",
+      ".mneme-pipe-nodeK{fill:var(--mneme-fg-dim);font-size:9px}",
+      // 图例：四个状态 + 闸门有无（counterfactual null = 空心圈「还没闸门」）。
+      ".mneme-pipe-legend{flex:none;display:flex;gap:10px;flex-wrap:wrap;align-items:center;padding:2px 14px 8px;font-size:11px;line-height:16px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-pill{flex:none;border-radius:6px;padding:0 6px;font-size:11px;line-height:18px;font-weight:600;border:1px solid transparent}",
+      ".mneme-pipe-pill--candidate{color:var(--mneme-fg-dim);border-color:var(--dsw-alias-border-l2)}",
+      ".mneme-pipe-pill--trusted{color:var(--mneme-ok);border-color:color-mix(in srgb,var(--mneme-ok) 45%,transparent)}",
+      ".mneme-pipe-pill--stale{color:var(--mneme-fg-dim);border-color:var(--dsw-alias-border-l2);border-style:dashed}",
+      ".mneme-pipe-pill--refuted{color:var(--mneme-danger);border-color:color-mix(in srgb,var(--mneme-danger) 55%,transparent);background:color-mix(in srgb,var(--mneme-danger) 10%,transparent)}",
+      ".mneme-pipe-gate{flex:none;width:10px;height:10px;border-radius:5px;border:1.5px solid var(--mneme-graphic-dim)}",
+      ".mneme-pipe-gate--has{border-color:var(--mneme-ok);background:var(--mneme-ok)}",
+      // 阶段带（2026-10-16）：段底用宿主 hover 层而不是自造色——对比度锁不认识
+      // 「SVG 文字底下还有一层 rect」，所以段底必须淡到不参与文字对比度。
+      ".mneme-pipe-bandbg{fill:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-pipe-bandline{stroke:var(--dsw-alias-border-l2);stroke-width:1}",
+      ".mneme-pipe-bandT{fill:var(--dsw-alias-label-primary);font-size:12px;font-weight:600}",
+      // 闸门节点与风险条：颜色只做冗余，信息本体在文本（闸 / R0-R3）里——
+      // 不许靠单一色相区分（AGENTS.md 自查清单第 9 条）。
+      ".mneme-pipe-node--gate{stroke:var(--mneme-warn);stroke-width:2}",
+      ".mneme-pipe-gatetag{fill:var(--mneme-warn);font-size:9px;font-weight:600}",
+      ".mneme-pipe-risk--r0{stroke:var(--mneme-graphic-dim)}",
+      ".mneme-pipe-risk--r1{stroke:var(--mneme-accent)}",
+      ".mneme-pipe-risk--r2{stroke:var(--mneme-warn)}",
+      ".mneme-pipe-risk--r3{stroke:var(--mneme-danger)}",
+      // 流程概览带：读投影里 pipeline.done 与 pipeline.trigger，回答「这条流程
+      // 在干什么、何时起跑」。正文用 label-secondary（与节点详情屏同档）。
+      ".mneme-pipe-overview{flex:none;padding:8px 14px 6px;border-bottom:1px solid var(--dsw-alias-border-l1);font-size:12px;line-height:17px;color:var(--dsw-alias-label-secondary);display:flex;flex-direction:column;gap:3px}",
+      // 节点详情（宽态点选展开 / 窄态 details 手风琴共用）。
+      ".mneme-pipe-detail{flex:none;border-top:1px solid var(--dsw-alias-border-l1);padding:8px 14px 10px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary);max-height:180px;overflow:auto}",
+      ".mneme-pipe-detailTitle{font-size:12px;font-weight:600;color:var(--dsw-alias-label-primary);margin-bottom:2px}",
+      ".mneme-pipe-dt{font-weight:600;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-cf{margin-top:4px;padding:4px 8px;border-radius:8px;background:color-mix(in srgb,var(--mneme-ok) 10%,transparent);color:var(--dsw-alias-label-secondary)}",
+      ".mneme-pipe-cf--none{background:0 0;border:1px dashed var(--dsw-alias-border-l2);color:var(--mneme-fg-dim)}",
+      // 窄态（better-sidebar ~500px / 浮层内）：节点竖排列表化，边收成
+      // 左侧轨道线 + 「依赖」芯片——换布局，不是缩放。
+      ".mneme-pipe-list{flex:1;min-height:180px;overflow:auto;padding:4px 12px 8px}",
+      ".mneme-pipe-item{position:relative;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-2);padding:8px 10px 8px 30px;margin:0 0 10px}",
+      ".mneme-pipe-item::before{content:\"\";position:absolute;left:13px;top:-10px;height:10px;border-left:2px solid var(--mneme-graphic-dim)}",
+      ".mneme-pipe-item:first-child::before{display:none}",
+      ".mneme-pipe-itemDot{position:absolute;left:8px;top:12px;width:10px;height:10px;border-radius:5px;border:2px solid var(--mneme-graphic-dim);background:var(--dsw-alias-bg-layer-2)}",
+      ".mneme-pipe-itemDot--trusted{border-color:var(--mneme-ok)}",
+      ".mneme-pipe-itemDot--stale{border-style:dashed;border-color:var(--dsw-alias-border-l2)}",
+      ".mneme-pipe-itemDot--refuted{border-color:var(--mneme-danger);background:var(--mneme-danger)}",
+      ".mneme-pipe-itemDot--onpath{border-color:var(--dsw-alias-state-business-primary)}",
+      ".mneme-pipe-itemName{font-size:13px;font-weight:600;line-height:18px;color:var(--dsw-alias-label-primary)}",
+      ".mneme-pipe-itemName--refuted{color:var(--mneme-danger)}",
+      ".mneme-pipe-itemMeta{display:flex;gap:6px;flex-wrap:wrap;align-items:center;margin-top:2px;font-size:11px;line-height:16px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-dep{font-size:11px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-item summary{cursor:pointer;list-style:none}",
+      ".mneme-pipe-item summary::-webkit-details-marker{display:none}",
+      ".mneme-pipe-itemBody{margin-top:6px;padding-top:6px;border-top:1px solid var(--dsw-alias-border-l1);font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary)}",
+      // 对话行结算卡（turnTail）：死数据，跟这次运行绑死。
+      ".mneme-pipe-settle{border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-2);padding:8px 10px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary);margin:4px 0;max-width:620px}",
+      ".mneme-pipe-settleHead{display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin-bottom:4px}",
+      ".mneme-pipe-settleTitle{font-size:12px;font-weight:600;color:var(--dsw-alias-label-primary);display:inline-flex;align-items:center;gap:6px}",
+      ".mneme-pipe-steps{display:flex;gap:4px;flex-wrap:wrap;align-items:center;margin:2px 0}",
+      ".mneme-pipe-stepChip{border:1px solid var(--dsw-alias-border-l2);border-radius:7px;padding:0 7px;font-size:11px;line-height:18px;color:var(--mneme-fg-dim);display:inline-flex;gap:4px;align-items:center}",
+      ".mneme-pipe-stepChip--used{border-color:color-mix(in srgb,var(--dsw-alias-state-business-primary) 55%,transparent);color:var(--dsw-alias-label-primary);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent)}",
+      ".mneme-pipe-stepArrow{color:var(--mneme-fg-dim);font-size:11px}",
+      // 老宿主退化：居中 sheet（形态沿用记忆库 overlay 的背板 + 居中面板）。
+      ".mneme-pipe-sheet{position:fixed;left:50%;top:50%;transform:translate(-50%,-50%);z-index:60;width:min(860px,calc(100vw - 48px));max-height:calc(100vh - 96px);border-radius:14px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1);display:flex;flex-direction:column;overflow:hidden;box-shadow:0 12px 40px rgba(0,0,0,0.3)}",
+      ".mneme-pipe-sheetbar{flex:none;display:flex;align-items:center;justify-content:space-between;gap:8px;padding:10px 14px;border-bottom:1px solid var(--dsw-alias-border-l2)}",
+      ".mneme-pipe-sheetbody{flex:1;min-height:0;overflow:auto;display:flex;flex-direction:column}",
+      // 空态/加载/错误共用文案块。
+      ".mneme-pipe-empty{flex:none;padding:18px 14px;text-align:center;font-size:13px;line-height:20px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-emptyTitle{font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);margin-bottom:4px}",
+      // 工作流清单：**选择器**，不是「一屏」。它在上面占一条、图在下面占其余——
+      // 第一版把它做成吃掉整屏、点条目才换屏，结果画布藏在一次点击后面且界面上没有任何
+      // 提示，反馈连着两次说「看不到画布和节点」。上限用固定值不用百分比：百分比在
+      // 高度不确定的祖先下会被当成 none，又变回吃掉整屏。
+      ".mneme-pipe-wflist{flex:none;max-height:220px;min-height:0;overflow:auto;padding:8px 14px 10px;display:flex;flex-direction:column;gap:8px;border-bottom:1px solid var(--dsw-alias-border-l1)}",
+      ".mneme-pipe-wfhead{flex:none;display:flex;align-items:baseline;justify-content:space-between;gap:8px;font-size:12px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-wf{display:block;width:100%;text-align:left;font-family:inherit;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-2);padding:9px 11px;cursor:pointer;color:var(--dsw-alias-label-primary)}",
+      ".mneme-pipe-wf:hover{background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-pipe-wf:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:1px}",
+      // 当前展开的那条：只有颜色不同，图仍由下面的画布独占——选择器不该抢主语的位置。
+      ".mneme-pipe-wf.mneme-on{border-color:var(--dsw-alias-state-business-primary)}",
+      ".mneme-pipe-wfTop{display:flex;align-items:baseline;justify-content:space-between;gap:8px}",
+      ".mneme-pipe-wfName{font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);min-width:0}",
+      ".mneme-pipe-wfScope{flex:none;font-size:11px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-wfMeta{display:block;margin-top:3px;font-size:12px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-wfId{display:block;margin-top:2px;font-size:11px;color:var(--mneme-fg-dim)}",
+      ".mneme-pipe-broken{flex:none;font-size:12px;line-height:17px;color:var(--mneme-warn);padding:6px 14px 0}",
     ].join("\n");
     if (typeof document !== "undefined" && document.querySelector(`style[data-plugin-css="${CSS_TAG}"]`) === null) {
       const tag = document.createElement("style");
@@ -2190,10 +2779,24 @@ window.__ModuleLoader__.load({
     // 后端 src/config.js 的 INJECT_CHILD_FLAGS（运行时闸门），两侧漂移由
     // test/inject-parent-gate.test.js 钉住。
     const FEATURE_CHILDREN = { autoInject: ["injectGuidanceEnabled", "continuityRescueEnabled"] };
+    // Issue #427 建议 1：折叠线挪到「新手之外」。group.basic 是首屏层，只列新
+    // 用户敢动的总开关；group.scope 也在首屏——它回答新用户的第二个必答题
+    // 「它记的东西会不会被别的会话看到」。其余组整组收进「全部设置」折叠
+    // （showAll）。成员从原组里移走而不是渲染时过滤：同一项永远只渲染一次。
+    // 首屏可点项 = 3 总开关 + autoInject 的 2 个子开关 + scope 2 开关 +
+    // 「全部设置」按钮 = 8（验收线 ≤ 8；RuntimeProvisionBlock 配好即消失，
+    // 常态首屏更少）。
+    const FEATURE_FIRST_SCREEN = ["group.basic", "group.scope"];
     const FEATURE_GROUPS = [
-      { key: "group.core", items: ["autoInject", "autoSummarize", "hotMemoryEnabled", "injectTimePrefix", "memoryQualityFilter.enabled", "llmAudit.enabled", "writeAdmission.enabled", "writeAdmission.enforce", "preInjectGate.enabled", "preInjectGate.enforce", "sensitiveScanEnabled"] },
-      { key: "group.enhance", items: ["entityExtractionEnabled", "codingRetrospect", "rerankEnabled", "resilientModelDownload", "searchSemanticDedup", "bm25SearchEnabled", "heatEnabled", "documentMemoryEnabled"] },
-      { key: "group.dream", items: ["autoDream", "sleepModeEnabled"] },
+      { key: "group.basic", items: ["autoInject", "autoSummarize", "autoDream"] },
+      { key: "group.core", items: ["hotMemoryEnabled", "injectTimePrefix", "memoryQualityFilter.enabled", "llmAudit.enabled", "writeAdmission.enabled", "writeAdmission.enforce", "preInjectGate.enabled", "preInjectGate.enforce", "sensitiveScanEnabled",
+        // #399 的留存总闸（见下方 distillSub：天数行是它的子块）。放在组末，
+        // 子块才能紧跟在它后面展开——items.map 之后的子块是按组尾渲染的。
+        "distillRecords.enabled"] },
+      // v0.9.0 M.O.（beta）：开关挂在 enhance 组。它不是行为开关而是
+      // 座位闸门——关=一个座位都不注册（见 apply 内的 M.O. 块）。
+      { key: "group.enhance", items: ["entityExtractionEnabled", "codingRetrospect", "rerankEnabled", "resilientModelDownload", "searchSemanticDedup", "bm25SearchEnabled", "heatEnabled", "documentMemoryEnabled", "actionPipelineEnabled"] },
+      { key: "group.dream", items: ["sleepModeEnabled"] },
       // v0.8.0 A4（issue #17）：作用域隔离组——标注总开关 + 严格硬过滤。
       { key: "group.scope", items: ["scopeEnabled", "strictScope"] }
     ];
@@ -2204,6 +2807,12 @@ window.__ModuleLoader__.load({
       // Issue #239 第 4 项：错峰时段串（巩固侧与蒸馏侧）。此前只有后端白名单、
       // 面板调不到——两个错峰键一个能调一个不能比都不给更让人困惑。
       "dreamPeakHours", "summarizePeakHours"];
+    // 整数键（blur/Enter 提交，非法值不提交、退回生效值）：
+    // issue #399 的 distillRecords.retentionDays。此前它与 enabled 一样只有
+    // 后端白名单、面板够不着——而 CONFIGURATION.md 明写「面板可启停」。
+    // 其余整数键（429 调速器参数、distillMaxChars、codingBoostFactor）是有意
+    // 不上 UI 的调优噪音，见上方注释，别顺手搬进来。
+    const FEATURE_NUMBERS = ["distillRecords.retentionDays"];
     const EMBED_PROVIDERS = ["openai", "local", "ollama"];
     // 实体抽取思考强度（issue #109）：与后端 FEATURE_FLAG_ENUMS 枚举对齐。
     const ENTITY_REASONING = ["none", "low", "medium", "high"];
@@ -2211,10 +2820,14 @@ window.__ModuleLoader__.load({
     // 蒸馏防推理烧预算）。后端枚举含 off，面板必须能选到，否则操作者用不上。
     const SUMMARIZE_REASONING = ["off", "none", "low", "medium", "high"];
 
-    function FeatureRow({ name, hint, on, disabled, onToggle, sub }) {
+    function FeatureRow({ name, hint, on, disabled, onToggle, sub, tag }) {
       return h("div", { className: "mneme-featrow", style: sub ? { paddingLeft: 18, opacity: 0.86 } : undefined },
         h("div", { className: "mneme-featmain" },
-          h("div", { className: "mneme-featname" }, name),
+          h("div", { className: "mneme-featname" }, name,
+            // 「默认 / 已改」徽标（#427 建议 3）：不用点开配置文件就知道哪
+            // 些是出厂值、哪些被你改过；title 给完整解释（键盘/读屏可达）。
+            tag && h("span", { className: "mneme-badge " + tag.kind, title: tag.title }, tag.text)
+          ),
           h("div", { className: "mneme-feathint" }, hint)
         ),
         h("button", {
@@ -2232,10 +2845,18 @@ window.__ModuleLoader__.load({
     function FeaturesCard({ t }) {
       const [state, setState] = useState(null); // { overrides, effective }
       const [error, setError] = useState("");
+      // 保存失败的提示要单独的座位：上面那个 error 只在首屏加载失败（state 还是
+      // null）时渲染，state 一到手它就永不出现——于是每一次 put 失败都静默，
+      // 草稿留在输入框里，人以为改成功了。
+      const [saveError, setSaveError] = useState("");
       const [busy, setBusy] = useState(false);
       const [savedTick, setSavedTick] = useState(false);
       const [showAdv, setShowAdv] = useState(false);
+      // Issue #427 建议 1：「全部设置」是第一层折叠（默认收起），「高级」是它
+      // 内部的第二层。两个状态独立：收起全部设置时高级的展开与否被记住。
+      const [showAll, setShowAll] = useState(false);
       const [strs, setStrs] = useState({}); // 字符串输入的本地草稿：key -> string
+      const [nums, setNums] = useState({}); // 数值输入的本地草稿：key -> string（提交时才转整数）
       // 巩固/睡眠模型路由下拉的数据源：GET /llm-providers 探测（云端 v0.7.26+
       // 的插件侧端点）。null = 端点不可用（404/失败）→ 回退纯文本输入，不挡旧后端。
       const [routes, setRoutes] = useState(null);
@@ -2255,6 +2876,9 @@ window.__ModuleLoader__.load({
             const draft = {};
             for (const key of FEATURE_STRINGS) draft[key] = String(e[key] ?? "");
             setStrs(draft);
+            const numDraft = {};
+            for (const key of FEATURE_NUMBERS) numDraft[key] = String(e[key] ?? "");
+            setNums(numDraft);
           })
           .catch(() => { if (!cancelled) setError(t("memory.features.loadFailed")); });
         return () => { cancelled = true; };
@@ -2272,6 +2896,7 @@ window.__ModuleLoader__.load({
 
       const eff = (state && state.effective) || {};
 
+      // 返回值 = 这次写入有没有落库。调用方要据此决定草稿的去留。
       const put = async (patch) => {
         setBusy(true);
         try {
@@ -2280,13 +2905,25 @@ window.__ModuleLoader__.load({
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify(patch)
           });
-          if (!res.ok) throw new Error("HTTP " + res.status);
+          if (!res.ok) {
+            // 服务端的校验失败把键名与范围写进 error（api.js 里那条 400 的注释
+            // 就是这么设计的），读出来给人看。拿不到 body 才退回状态码——
+            // 总之不能只剩一句「失败」让人猜是哪个开关、错在哪。
+            const detail = await res.json()
+              .then((j) => (j && j.error) || "")
+              .catch(() => "");
+            throw new Error(detail || ("HTTP " + res.status));
+          }
           setState(await res.json());
+          setSaveError("");
           announce(t("memory.features.restartHint"));
           setSavedTick(true);
           setTimeout(() => setSavedTick(false), 1800);
-        } catch {
-          setError(t("memory.features.loadFailed"));
+          return true;
+        } catch (err) {
+          const why = (err && err.message) || String(err);
+          setSaveError(`${t("memory.features.saveFailed")} — ${why}`);
+          return false;
         } finally {
           setBusy(false);
         }
@@ -2294,15 +2931,45 @@ window.__ModuleLoader__.load({
 
       // 字符串项失焦/回车提交：trim 后与生效值相同则回填放弃，否则交给
       // 后端校验（ollamaBaseUrl 的协议、embedProvider 的枚举在后端把关）。
+      // 后端拒了就退回生效值并出声——留着被拒的文本，人以为改成功了。
       const commitString = (key) => {
         const raw = (strs[key] ?? "").trim();
         if (raw === String(eff[key] ?? "")) {
           setStrs((c) => ({ ...c, [key]: String(eff[key] ?? "") }));
           return;
         }
-        put({ [key]: raw });
+        put({ [key]: raw }).then((ok) => {
+          if (!ok) setStrs((c) => ({ ...c, [key]: String(eff[key] ?? "") }));
+        });
       };
 
+      // 整数项失焦/回车提交。与字符串项同一形状，多三道闸：本地先挡非整数，
+      // 挡不住的交后端（retentionDays 的范围 1–3650 由白名单把关），后端也拒了
+      // 就把草稿退回生效值。前两道退回时也不出声——那是本地的即时反馈；第三道
+      // 必须出声（put 会把原因写进 saveError），否则「框里的数字」与「在用的
+      // 保留天数」会分家，而人看不出来。
+      const commitNumber = (key) => {
+        const raw = (nums[key] ?? "").trim();
+        if (raw === String(eff[key] ?? "")) return;
+        if (!/^\d+$/.test(raw)) {
+          setNums((c) => ({ ...c, [key]: String(eff[key] ?? "") }));
+          return;
+        }
+        put({ [key]: Number(raw) }).then((ok) => {
+          if (!ok) setNums((c) => ({ ...c, [key]: String(eff[key] ?? "") }));
+        });
+      };
+
+      // 「默认 / 已改」的信号来源是 state.overrides：featureSnapshot 只把
+      // settings.getFeatureFlags() 里真实落库的键放进 overrides，键不在其中
+      // = 值仍来自 config schema 的默认值。面板自己判断，不加后端字段、
+      // 不动 config.js（#427 的验收红线之一）。
+      const ovr = (state && state.overrides) || {};
+      const flagTag = (k) => ({
+        kind: Object.prototype.hasOwnProperty.call(ovr, k) ? "mneme-badge--changed" : "mneme-badge--default",
+        text: t(Object.prototype.hasOwnProperty.call(ovr, k) ? "memory.features.tagChanged" : "memory.features.tagDefault"),
+        title: t(Object.prototype.hasOwnProperty.call(ovr, k) ? "memory.features.tagChanged.hint" : "memory.features.tagDefault.hint")
+      });
       const boolRow = (k, opts = {}) => h(FeatureRow, {
         key: k,
         name: t(`memory.features.${k}`),
@@ -2311,6 +2978,7 @@ window.__ModuleLoader__.load({
         on: !!eff[k],
         disabled: busy,
         sub: !!opts.sub,
+        tag: flagTag(k),
         onToggle: () => put({ [k]: !eff[k] })
       });
 
@@ -2328,9 +2996,11 @@ window.__ModuleLoader__.load({
       // 连通性测试：POST /test-model，空 provider/model = 按巩固路由解析
       // （agent 默认）。durationMs 优先后端值，缺失时客户端兜底计时；成功行
       // 附模型的实际回复（reply，后端截 100 字符）——「真的答了 ok」而非只报通。
-      // reasoningEffort 透传该路由配置的档位（issue #215）：sleep 无回退重试，
-      // 档位被拒时真实 run 直接失败，测试是事前唯一的暴露口；'none'/未配置
-      // 省略字段，与后端 src/api.js 的同口径。
+      // reasoningEffort 透传该路由配置的档位（issue #215），'none'/未配置省略
+      // 字段，与后端 src/api.js 的同口径。**档位被拒不再是失败**：后端与真实
+      // run 一样丢掉字段重试一次，回以 effortDropped:true，这里单独说明「连通
+      // 了、但不是用你配的档位」——否则用户会照着红色失败去换 Provider，而
+      // 后台其实一直在正常跑（这正是它此前给出误导性诊断的原因）。
       const runModelTest = async (provider, model, setTestState, reasoningEffort) => {
         setTestState({ running: true });
         const started = Date.now();
@@ -2356,6 +3026,8 @@ window.__ModuleLoader__.load({
           setTestState({
             ok: true,
             ms,
+            // 只有后端明确置位才算降级（旧后端无此字段 → 不显示，不误报）。
+            dropped: j.effortDropped === true,
             detail: [j.modelId, j.reply ? "「" + j.reply + "」" : ""].filter(Boolean).join(" · ")
           });
         } catch (err) {
@@ -2423,6 +3095,7 @@ window.__ModuleLoader__.load({
             (testState && !testState.running
               ? h("div", { className: "mneme-featsubhint" },
                   (testState.ok ? "✓ " + t("memory.features.modelTestOk") : "✗ " + t("memory.features.modelTestFail"))
+                  + (testState.ok && testState.dropped ? " · " + t("memory.features.modelTestDowngraded") : "")
                   + (typeof testState.ms === "number" ? " · " + (testState.ms / 1000).toFixed(1) + "s" : "")
                   + (testState.detail ? " · " + testState.detail : ""))
               : h("div", { className: "mneme-featsubhint" }, t("memory.features.modelTestHint"))))
@@ -2439,6 +3112,22 @@ window.__ModuleLoader__.load({
           onKeyDown: (e) => { if (e.key === "Enter") e.target.blur(); }
         }));
 
+      // type 刻意用 text + inputMode 而不是 number：number 输入框在部分内容被
+      // 判非法时 e.target.value 会变成空串，草稿与用户所见脱节；这里要自己拿
+      // 到原文才能挡下非整数并退回生效值。
+      const numRow = (key) => h("div", { className: "mneme-featnum", key },
+        h("span", { className: "mneme-featnumlabel" }, t(`memory.features.${key}`)),
+        h("input", {
+          className: "mneme-numinput",
+          type: "text",
+          inputMode: "numeric",
+          value: nums[key] ?? "",
+          "aria-label": t(`memory.features.${key}`),
+          onChange: (e) => setNums((c) => ({ ...c, [key]: e.target.value })),
+          onBlur: () => commitNumber(key),
+          onKeyDown: (e) => { if (e.key === "Enter") e.target.blur(); }
+        }));
+
       // 语义检索路线：provider 下拉即时提交；local/ollama 选中时展开各自
       // 的连接字段，openai 的连接信息由「向量搜索」卡片持有，只给指引。
       const embedSub = h("div", { className: "mneme-featsub" },
@@ -2520,6 +3209,14 @@ window.__ModuleLoader__.load({
         h("div", { className: "mneme-featsubhint" }, t("memory.features.summarizePeakHours.hint"))
       );
 
+      // #399 的留存开关紧跟在蒸馏总闸下：天数行只在留存开着时展开（关着一行
+      // 不写，改天数没有意义）。放在这而不是挂在 flagRow 上，是因为
+      // FEATURE_CHILDREN 只认布尔子项，而这里要的是一个整数输入行。
+      const distillSub = eff["distillRecords.enabled"] && h("div", { className: "mneme-featsub" },
+        numRow("distillRecords.retentionDays"),
+        h("div", { className: "mneme-featsubhint" }, t("memory.features.distillRecords.retentionDays.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));
@@ -2530,29 +3227,58 @@ window.__ModuleLoader__.load({
           savedTick && h("span", { className: "mneme-saved", style: { marginLeft: 8, fontWeight: 400 } }, t("memory.features.restartHint"))
         ),
         h("div", { className: "mneme-set-desc" }, t("memory.features.desc")),
+        // 见 saveError 的声明处：这条分支不能跟着加载失败那条走。
+        saveError && h("div", { className: "mneme-mainterr" }, saveError),
         h(RuntimeProvisionBlock, { t }),
         state === null && !error
           ? h("div", { className: "mneme-set-hint" }, "…")
-          : h(react.Fragment, null,
-              FEATURE_GROUPS.map((g) => h(react.Fragment, { key: g.key },
+          : (() => {
+              // Issue #427：分组按「实现」分改不动需求本身，改的是「折叠线划在
+              // 哪里」。renderGroup 是唯一的组渲染路径（含组尾子块），首屏层与
+              // 「全部设置」共用它，保证 g.items.map(flagRow) 只写一次、子项
+              // 只可能经 flagRow 渲染（test/inject-parent-gate.test.js 的门）。
+              const renderGroup = (g) => h(react.Fragment, { key: g.key },
                 h("div", { className: "mneme-featgroup" }, t(`memory.features.${g.key}`)),
                 g.items.map(flagRow),
-                g.key === "group.core" && h(react.Fragment, null, summarizeSub),
+                // 子块按组尾追加。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.dream" && h(react.Fragment, null, dreamSub, sleepSub)
-              )),
-              h("div", { className: "mneme-featgroup" },
-                h("button", {
-                  type: "button",
-                  className: "mneme-footbtn",
-                  "aria-expanded": String(showAdv),
-                  onClick: () => setShowAdv(!showAdv)
-                },
-                  h(Icon, { name: showAdv ? "chevronDown" : "chevronRight", size: 12 }),
-                  t("memory.features.advancedToggle"))
-              ),
-              showAdv && FEATURE_ADVANCED_BOOLS.map((k) => boolRow(k))
-            )
+              );
+              const firstScreen = FEATURE_GROUPS.filter((g) => FEATURE_FIRST_SCREEN.includes(g.key));
+              const restGroups = FEATURE_GROUPS.filter((g) => !FEATURE_FIRST_SCREEN.includes(g.key));
+              return h(react.Fragment, null,
+                firstScreen.map(renderGroup),
+                // 「全部设置」= 第一层折叠（默认收起，#427 建议 1）：里面的
+                // 30 余项对新手是噪音，对新用户可见的只有上面的总开关层。
+                h("div", { className: "mneme-featgroup" },
+                  h("button", {
+                    type: "button",
+                    className: "mneme-footbtn",
+                    "aria-expanded": String(showAll),
+                    onClick: () => setShowAll(!showAll)
+                  },
+                    h(Icon, { name: showAll ? "chevronDown" : "chevronRight", size: 12 }),
+                    t("memory.features.allToggle"))
+                ),
+                showAll && h(react.Fragment, null,
+                  restGroups.map(renderGroup),
+                  // 「高级」降为第二层，嵌在「全部设置」内部。
+                  h("div", { className: "mneme-featgroup" },
+                    h("button", {
+                      type: "button",
+                      className: "mneme-footbtn",
+                      "aria-expanded": String(showAdv),
+                      onClick: () => setShowAdv(!showAdv)
+                    },
+                      h(Icon, { name: showAdv ? "chevronDown" : "chevronRight", size: 12 }),
+                      t("memory.features.advancedToggle"))
+                  ),
+                  showAdv && FEATURE_ADVANCED_BOOLS.map((k) => boolRow(k))
+                )
+              );
+            })()
       );
     }
 
@@ -2982,7 +3708,7 @@ window.__ModuleLoader__.load({
             h("textarea", { className: "mneme-set-input mneme-set-input--area", style: { minHeight: 56 }, value: newCmd.instruction, placeholder: t("memory.settings.cmdInstruction"), onChange: (e) => setNewCmd({ ...newCmd, instruction: e.target.value }) }),
             h("div", { style: { display: "flex", alignItems: "center", gap: 8 } },
               h("button", { className: "mneme-btn", onClick: addCommand }, t("memory.settings.cmdAdd")),
-              cmdError && h("span", { style: { fontSize: 12, color: "var(--dsw-alias-state-error, #c33)" } }, cmdError)
+              cmdError && h("span", { style: { fontSize: 12, color: "var(--mneme-danger)" } }, cmdError)
             )
           )
         ),
@@ -2993,7 +3719,7 @@ window.__ModuleLoader__.load({
         h("section", { className: "mneme-set-card" },
           h("div", { className: "mneme-set-title" }, t("memory.settings.mode.title")),
           h("div", { className: "mneme-set-desc" }, t("memory.settings.mode.desc")),
-          modeError && h("div", { style: { fontSize: 12, color: "var(--dsw-alias-state-error,#c33)", marginBottom: 8 } }, modeError),
+          modeError && h("div", { style: { fontSize: 12, color: "var(--mneme-danger)", marginBottom: 8 } }, modeError),
           mode === null && !modeError
             ? h("div", { className: "mneme-set-hint" }, "…")
             : h(react.Fragment, null,
@@ -3044,7 +3770,7 @@ window.__ModuleLoader__.load({
         h("section", { className: "mneme-set-card" },
           h("div", { className: "mneme-set-title" }, t("memory.settings.extapi.title")),
           h("div", { className: "mneme-set-desc" }, t("memory.settings.extapi.desc")),
-          extapiError && h("div", { style: { fontSize: 12, color: "var(--dsw-alias-state-error,#c33)", marginBottom: 8 } }, extapiError),
+          extapiError && h("div", { style: { fontSize: 12, color: "var(--mneme-danger)", marginBottom: 8 } }, extapiError),
           extapi === null && !extapiError
             ? h("div", { className: "mneme-set-hint" }, "…")
             : h(react.Fragment, null,
@@ -3288,7 +4014,7 @@ window.__ModuleLoader__.load({
         loading
           ? h("div", { className: "mneme-statusnum" }, "…")
           : error
-            ? h("div", { className: "mneme-statuscap", style: { color: "var(--dsw-alias-state-error,#c33)" } }, t("memory.status.error"))
+            ? h("div", { className: "mneme-statuscap", style: { color: "var(--mneme-danger)" } }, t("memory.status.error"))
             : h(react.Fragment, null,
                 h("div", { className: "mneme-statusnum" }, num),
                 rows && rows.length
@@ -3546,6 +4272,250 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // 人读体积：回收报告里全是字节数（六到七位），不折成 KiB/MiB 就看不出「到底有没有
+    // 变小」——而那正是这张卡要回答的问题。
+    function formatBytes(n) {
+      const v = Number(n);
+      if (!Number.isFinite(v) || v < 0) return "—";
+      if (v < 1024) return `${v} B`;
+      const units = ["KiB", "MiB", "GiB", "TiB"];
+      let x = v / 1024;
+      let i = 0;
+      while (x >= 1024 && i < units.length - 1) { x /= 1024; i++; }
+      return `${x.toFixed(x >= 100 ? 0 : x >= 10 ? 1 : 2)} ${units[i]}`;
+    }
+
+    // 存储回收卡（issue #386 第 4 条，状态页「维护」区）。`dsh-mneme reclaim` 此前只有
+    // CLI 与 standalone 两张脸，面板侧一个字都没有——「不可逆的内容丢弃」这种能力要么
+    // 能被发现，要么等于不存在。
+    //
+    // 三条不变量，别在「顺手简化」时弄丢：
+    //   ① 执行是两步。第一次点只进确认态，把这次要动的数字摆到眼前；第二次点才真的发
+    //      POST。不用 window.confirm——宿主 webview 里它不一定可用，而且它挡不住「到底
+    //      要清多少行」这个问题。
+    //   ② VACUUM 失败 ≠ 成功。清理的两个 UPDATE 各自提交且不可逆，VACUUM 只负责把文件
+    //      缩回去，失败最常见的原因是锁被别的进程占着。所以失败时必须同时说清四件事：
+    //      清理已完成、不可逆、文件暂时不会变小、下一步重跑即可（清理是幂等的）。绝不
+    //      能渲染成一次干净的「成功」。
+    //   ③ 保留窗口只在点「重新估算」时发一次请求。键入即发 = 想输 30 却先敲出 3 的那一刻
+    //      就换了估算，数字会跳。而且估算一旦与输入框不一致，确认态里摆出来的就是另一个
+    //      动作的数字——所以那种状态下执行钮直接禁用（见下面的 stale）。
+    //
+    // 报告字段由 src/maintenance.js 的 reclaim() 决定，卡片只读不改。
+    function MaintenanceCard({ t }) {
+      // 与 src/maintenance.js 的 DEFAULT_INPUT_RETENTION_DAYS 同值：这里只用来初始化
+      // 输入框与首屏那次 GET，真正的默认值仍由服务端兜底。
+      const DEFAULT_WINDOW_DAYS = 7;
+      // 与后端 MAX_RECLAIM_WINDOW_DAYS 同值。超界窗口服务端会回 400，但本地先拦一道：
+      // 否则用户点「重新估算」只会看到一句服务端错误，还以为是网络问题。
+      const MAX_WINDOW_DAYS = 3650;
+      // 面板走 in-process 路由，与 CLI/standalone 底下是同一条 reclaim 实现。
+      const RECLAIM_PATH = "/api/dsh-mneme/maintenance/reclaim";
+      const [days, setDays] = useState(String(DEFAULT_WINDOW_DAYS));
+      const [vacuum, setVacuum] = useState(false);
+      const [report, setReport] = useState(null);
+      const [loading, setLoading] = useState(true);
+      const [estimating, setEstimating] = useState(false);
+      const [error, setError] = useState("");
+      // 确认态：true = 第一次点过了，此刻按钮换成实心红确认钮。
+      const [armed, setArmed] = useState(false);
+      const [running, setRunning] = useState(false);
+      // 成功与失败分开存：合成一个对象容易在「先失败后成功」时把上一次的残留显示出来。
+      const [result, setResult] = useState(null);
+      const [resultError, setResultError] = useState("");
+
+      // 挂载即预估：打开状态页就该看见「现在能收多少」，而不是先点一下才有数字。
+      useEffect(() => {
+        let cancelled = false;
+        apiFetch(`${RECLAIM_PATH}?olderThanDays=${DEFAULT_WINDOW_DAYS}`)
+          .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+          .then((j) => { if (!cancelled) { setReport(j); setLoading(false); } })
+          .catch(() => { if (!cancelled) { setError(t("memory.status.maint.failed")); setLoading(false); } });
+        return () => { cancelled = true; };
+      }, []);
+
+      // 只由「重新估算」按钮调用，不在 onChange 里调用（见上面 ③）。
+      const estimate = () => {
+        if (!/^\d+$/.test(days)) { setError(t("memory.status.maint.badWindow")); setArmed(false); return; }
+        // 上界也在这里拦：`1e20` 与 400 位数字都能过 /^\d+$/（后者化成 Infinity），
+        // 后端会回 400，但那样用户看到的是一句「回收失败」，不如直接说窗口不合法。
+        if (Number(days) > MAX_WINDOW_DAYS) { setError(t("memory.status.maint.badWindow")); setArmed(false); return; }
+        setEstimating(true);
+        setError("");
+        // 窗口一变，上一轮的确认态连同它显示的数字一起作废；上一次执行的回执也别再跟
+        // 新的估算混在一起。
+        setArmed(false);
+        setResult(null);
+        setResultError("");
+        apiFetch(`${RECLAIM_PATH}?olderThanDays=${days}`)
+          .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+          .then((j) => { setReport(j); setEstimating(false); })
+          .catch(() => { setError(t("memory.status.maint.failed")); setEstimating(false); });
+      };
+
+      // 第二次点击（确认态里）才走这里。dryRun:false 与 confirm:true 是后端那条不可逆
+      // 动作的确认门：缺 confirm 会回 400 confirm-required 并附一份 dry-run 报告。两个
+      // 字面量逐字保留——改名或省掉一个都等于把门拆了。
+      const execute = () => {
+        setRunning(true);
+        setResultError("");
+        apiFetch(RECLAIM_PATH, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ dryRun: false, confirm: true, olderThanDays: Number(days), vacuum })
+        })
+          .then((res) => res.json().catch(() => null).then((body) => ({ ok: res.ok, status: res.status, body })))
+          .then((r) => {
+            // 非 2xx 一律落到这条分支并带着服务端的 error 串返回：成功态只在守卫另一侧。
+            if (!r.ok) {
+              setResultError(`${t("memory.status.maint.failed")} · ${(r.body && r.body.error) || `HTTP ${r.status}`}`);
+              setRunning(false);
+              return;
+            }
+            setResult(r.body);
+            setArmed(false);
+            setRunning(false);
+          })
+          .catch(() => { setResultError(t("memory.status.maint.failed")); setRunning(false); });
+      };
+
+      const size = (report && report.size) || {};
+      const planned = (report && report.planned) || {};
+      const rv = (result && result.vacuum) || {};
+      const rsz = (result && result.size) || {};
+      const rcl = (result && result.cleared) || {};
+      // 估算数字与输入框不一致（刚改过窗口还没重新估算）时禁止执行：否则确认态里摆出来
+      // 的是另一个窗口的数字，而对不可逆操作来说这是最坏的一种错位。
+      const stale = !report || String(report.olderThanDays) !== days;
+      // vacuum.error 是 string|null；非 null 就是「清理成功但文件没缩」这种半成功态。
+      const vacuumError = rv.error == null ? null : String(rv.error);
+      const freed = Number(rsz.before_bytes ?? 0) - Number(rsz.after_bytes ?? 0);
+
+      return h("div", { className: "mneme-statuscard mneme-statuscard--wide" },
+        h("h3", { className: "mneme-xcolhead" }, t("memory.status.maint")),
+        loading
+          ? h("div", { className: "mneme-statusnum" }, "…")
+          : h("div", { className: "mneme-statusnum" }, formatBytes(size.before_bytes)),
+        report ? h("div", { className: "mneme-statrows" },
+          h("div", { className: "mneme-statrow" },
+            h("span", null, t("memory.status.maint.freelist")),
+            h("span", { className: "mneme-statrowval" }, `${formatBytes(size.freelist_bytes)} · ${size.freelist_pages ?? 0}`)),
+          h("div", { className: "mneme-statrow" },
+            h("span", null, t("memory.status.maint.plannedInputs")),
+            h("span", { className: "mneme-statrowval" }, String(planned.dream_run_inputs ?? 0))),
+          h("div", { className: "mneme-statrow" },
+            h("span", null, t("memory.status.maint.plannedEmbeddings")),
+            h("span", { className: "mneme-statrowval" }, String(planned.archived_embeddings ?? 0))),
+          h("div", { className: "mneme-statrow" },
+            h("span", null, t("memory.status.maint.window")),
+            h("span", { className: "mneme-statrowval" }, `${report.olderThanDays} ${t("memory.status.maint.windowUnit")}`))
+        ) : null,
+        // 控制区：窗口只在点按钮时重新估算；VACUUM 默认关，并明说它会短暂独占数据库。
+        h("div", { className: "mneme-maintrow" },
+          h("span", { className: "mneme-maintlbl" }, t("memory.status.maint.windowLabel")),
+          h("input", {
+            className: "mneme-set-input",
+            inputMode: "numeric",
+            value: days,
+            disabled: armed || running,
+            onChange: (e) => setDays(e.target.value)
+          }),
+          h("button", {
+            type: "button",
+            className: "mneme-btn",
+            disabled: armed || running || estimating,
+            onClick: estimate
+          }, estimating ? t("memory.status.maint.reestimating") : t("memory.status.maint.reestimate"))
+        ),
+        h("label", { className: "mneme-maintcheck" },
+          h("input", {
+            type: "checkbox",
+            checked: vacuum,
+            disabled: armed || running,
+            onChange: (e) => setVacuum(e.target.checked)
+          }),
+          h("span", null, t("memory.status.maint.vacuum"))
+        ),
+        h("div", { className: "mneme-statuscap" }, t("memory.status.maint.vacuumHint")),
+        stale && !loading && !estimating
+          ? h("div", { className: "mneme-statuscap" }, t("memory.status.maint.stale"))
+          : null,
+        // 两步确认。未武装时只有「执行回收」（点了只进确认态，不发请求）；武装后换成实心
+        // 红确认钮，并把窗口/VACUUM 在确认态里锁住——保证屏幕上的数字就是即将发出的动作。
+        armed
+          ? h(react.Fragment, null,
+              h("div", { className: "mneme-maintwarn" },
+                h("div", { className: "mneme-maintwarnhead" },
+                  t("memory.status.maint.confirmHint")
+                    .replace("{inputs}", String(planned.dream_run_inputs ?? 0))
+                    .replace("{embeddings}", String(planned.archived_embeddings ?? 0))),
+                h("div", { className: "mneme-statuscap" },
+                  `${t("memory.status.maint.window")} ${report.olderThanDays} ${t("memory.status.maint.windowUnit")} · `
+                  + (vacuum ? t("memory.status.maint.vacuum") : t("memory.status.maint.vacuumOff")))
+              ),
+              h("div", { className: "mneme-maintrow" },
+                h("button", {
+                  type: "button",
+                  className: "mneme-btn mneme-btndangerconfirm",
+                  disabled: running,
+                  onClick: execute
+                }, running ? t("memory.status.maint.running") : t("memory.status.maint.confirm")),
+                h("button", {
+                  type: "button",
+                  className: "mneme-btn",
+                  disabled: running,
+                  onClick: () => setArmed(false)
+                }, t("memory.status.maint.cancel"))
+              )
+            )
+          : h("div", { className: "mneme-maintrow" },
+              h("button", {
+                type: "button",
+                className: "mneme-btn mneme-btndanger",
+                disabled: running || loading || estimating || stale,
+                onClick: () => setArmed(true)
+              }, t("memory.status.maint.execute"))
+            ),
+        result ? h("div", { className: "mneme-maintresult" },
+          h("div", { className: "mneme-maintresulthead" },
+            vacuumError ? t("memory.status.maint.vacuumFailed") : t("memory.status.maint.done")),
+          h("div", { className: "mneme-statrows" },
+            h("div", { className: "mneme-statrow" },
+              h("span", null, t("memory.status.maint.clearedInputs")),
+              h("span", { className: "mneme-statrowval" }, String(rcl.dream_run_inputs ?? 0))),
+            h("div", { className: "mneme-statrow" },
+              h("span", null, t("memory.status.maint.clearedEmbeddings")),
+              h("span", { className: "mneme-statrowval" }, String(rcl.archived_embeddings ?? 0))),
+            h("div", { className: "mneme-statrow" },
+              h("span", null, t("memory.status.maint.size")),
+              h("span", { className: "mneme-statrowval" }, `${formatBytes(rsz.before_bytes)} → ${formatBytes(rsz.after_bytes)}`)),
+            h("div", { className: "mneme-statrow" },
+              h("span", null, t("memory.status.maint.reclaimed")),
+              h("span", { className: "mneme-statrowval" }, formatBytes(freed))),
+            h("div", { className: "mneme-statrow" },
+              h("span", null, t("memory.status.maint.receipt")),
+              h("span", { className: "mneme-statrowval" },
+                result.receipt == null ? t("memory.status.maint.receiptNone") : String(result.receipt))),
+            h("div", { className: "mneme-statrow" },
+              h("span", null, t("memory.status.maint.duration")),
+              h("span", { className: "mneme-statrowval" }, `${Number(result.duration_ms ?? 0)} ms`))
+          ),
+          // VACUUM 失败 ≠ 成功：清理已经落库且不可逆，失败的只是「把文件缩回去」这一步。
+          // 这里必须把「已完成 + 不可逆 + 暂时不会变小」和下一步（重跑即可，清理是幂等
+          // 的）一起说清，否则用户只看到「没变小」会以为白清了。
+          vacuumError
+            ? h("div", { className: "mneme-maintwarn" },
+                h("div", { className: "mneme-maintwarnhead" },
+                  `${t("memory.status.maint.vacuumFailed")} · ${vacuumError}`),
+                h("div", { className: "mneme-statuscap" }, t("memory.status.maint.vacuumFailedHint")))
+            : h("div", { className: "mneme-statuscap" },
+                rv.ran ? t("memory.status.maint.vacuumRan") : t("memory.status.maint.vacuumOff"))
+        ) : null,
+        resultError ? h("div", { className: "mneme-mainterr" }, resultError) : null,
+        error ? h("div", { className: "mneme-mainterr" }, error) : null
+      );
+    }
+
     // Markdown 镜像健康卡（issue #386 第 3 条）。后端 /health 对镜像读失败是
     // fail-closed（dirty=null → unknown）；面板侧同样 fail-closed：fetch 失败
     // 或任何非 ok/degraded 的 status 一律渲染成「未知」，绝不显示「正常」——
@@ -3585,34 +4555,256 @@ window.__ModuleLoader__.load({
       });
     }
 
-    // LLM 消耗 — calls + tokens over the trailing 7 days.
-    function LlmStatusCard({ t }) {
-      const [state, setState] = useState({ loading: true, error: false, calls: 0, tokens: 0 });
+    // --- Token 去向三屏（2026-10 可观测性改造）---
+    // 原 LlmStatusCard 只有一个「LLM 消耗」总数，且 by_source 把两个最大成本项
+    // dream_consolidate / dream_summarize 合并成 autoDream（2026-10 审计里巩固
+    // 单项就占 37%），「token 花在哪」不可见。这里换成三屏：KPI 带（总量/调用/
+    // 巩固占比/待确认冲突）、按组件 donut、按天柱状 + 8 周热力；原 9 张状态卡
+    // 降级到折叠区。数据走 getLlmAuditStats 新增的 by_operation / by_day 两个
+    // 聚合（后端已排好序，前端按 TOKEN_OPS 恒定顺序取用，不依赖 API 排序）。
+    const TOKEN_OPS = [
+      "dream_consolidate",
+      "summarize_compress",
+      "entity_extract",
+      "dream_summarize",
+      "sleep_pattern",
+      "write_admission"
+    ];
+    const tokenOpLabel = (t, op) => {
+      const key = `memory.status.token.op.${op}`;
+      const label = t(key);
+      return label !== key ? label : String(op);
+    };
+    const tokenCompact = (n) => {
+      if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+      if (n >= 1e3) return `${Math.round(n / 1e3)}K`;
+      return String(n);
+    };
+    const heatLevel = (n) => (n > 2500000 ? 4 : n > 1500000 ? 3 : n > 750000 ? 2 : n > 0 ? 1 : 0);
+
+    function TokenFlowSection({ t }) {
+      const [stats, setStats] = useState(null);
+      const [heatStats, setHeatStats] = useState(null);
+      const [statsError, setStatsError] = useState(false);
+      const [conf, setConf] = useState({ loading: true, error: false, pending: 0 });
+      const [focusOp, setFocusOp] = useState(null);
       useEffect(() => {
         let cancelled = false;
         apiFetch("/api/dsh-mneme/semantic/llm-audit/stats?days=7")
           .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
           .then((j) => {
             if (cancelled) return;
-            const s = j && typeof j === "object" ? (j.stats || j) : {};
-            setState({ loading: false, error: false, calls: Number(s.total_calls ?? 0), tokens: Number(s.total_tokens ?? 0) });
+            setStats(j && typeof j === "object" ? (j.stats || j) : {});
+            setStatsError(false);
           })
-          .catch(() => { if (!cancelled) setState({ loading: false, error: true, calls: 0, tokens: 0 }); });
-        return () => { cancelled = true; };
+          .catch(() => { if (!cancelled) setStatsError(true); });
+        // 8 周热力要 56 天窗口，而 days=7 的 by_day 最多只有 8 个 UTC 日期——
+        // 复用同一份响应会让 56 格里 48 格恒为 0（自动评审 #412 指出）。两个
+        // 窗口各取所需：7 天喂 KPI 与柱状，56 天只喂热力。
+        apiFetch("/api/dsh-mneme/semantic/llm-audit/stats?days=56")
+          .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+          .then((j) => {
+            if (cancelled) return;
+            setHeatStats(j && typeof j === "object" ? (j.stats || j) : {});
+          })
+          .catch(() => { if (!cancelled) setHeatStats({}); });
+        // KPI 第 4 格的待确认冲突与 DreamStatusCards 同源（/dream-status），
+        // 同样监听 mneme:conflicts-changed 重取（#295），两处计数永不漂移。
+        const loadConflicts = () => {
+          apiFetch("/api/dsh-mneme/dream-status")
+            .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+            .then((d) => {
+              if (cancelled) return;
+              setConf({ loading: false, error: false, pending: Number((d && d.pendingConflicts) ?? 0) });
+            })
+            .catch(() => { if (!cancelled) setConf({ loading: false, error: true, pending: 0 }); });
+        };
+        loadConflicts();
+        window.addEventListener("mneme:conflicts-changed", loadConflicts);
+        return () => { cancelled = true; window.removeEventListener("mneme:conflicts-changed", loadConflicts); };
       }, []);
-      return h(StatusCard, {
-        t,
-        title: t("memory.status.llm"),
-        loading: state.loading,
-        error: state.error,
-        num: state.tokens.toLocaleString(),
-        cap: t("memory.status.llmCalls").replace("{n}", state.calls.toLocaleString())
+
+      const loading = !stats && !statsError;
+      const byOp = stats && Array.isArray(stats.by_operation) ? stats.by_operation : [];
+      // 按恒定顺序取行：API 排序变化不影响图例次序；未知操作留到渲染时兜底。
+      const ops = TOKEN_OPS.map((op) => {
+        const row = byOp.find((r) => r.operation === op);
+        return { op, total: Number((row && row.total_tokens) ?? 0) };
       });
+      const unknownOps = byOp.filter((r) => !TOKEN_OPS.includes(r.operation));
+      const allOps = ops.concat(unknownOps.map((r) => ({ op: r.operation, total: Number(r.total_tokens ?? 0) })));
+      const grand = allOps.reduce((a, r) => a + r.total, 0);
+      const consolidate = ops[0].total;
+      // donut：r=15.9155 让周长≈100，dasharray 直接填百分比；段与段留缝（取
+      // 半个百分点与四分之一弧长的较小者），小弧不被缝吃掉。write_admission
+      // 的 token 恒 0 是设计（只计量不拦截），自然不画弧，图例仍保留一行。
+      let cursor = 0;
+      const segs = allOps
+        .map((r, i) => {
+          const len = grand > 0 ? (r.total / grand) * 100 : 0;
+          const gap = Math.min(0.25, len / 4);
+          const seg = Math.max(len - gap * 2, 0.4);
+          const off = -(cursor + gap);
+          cursor += len;
+          return { ...r, i, len, seg, off };
+        })
+        .filter((s) => s.len > 0);
+      const opIdx = (op) => {
+        const i = TOKEN_OPS.indexOf(op);
+        return i >= 0 ? i : Math.max(0, Math.min(allOps.findIndex((r) => r.op === op), 5));
+      };
+      // 7 天柱状：上限向上取整到整 M，四条网格线按 niceMax/4 等距。
+      // by_day 只返回有审计行的日期（SQL 是 GROUP BY，缺日无行），而 since=now-7d
+      // 的窗口横跨 8 个 UTC 日期——直接映射会让柱子缺列、横轴不是连续 7 天（自动
+      // 评审 #412 指出）。这里以「今天 UTC」为右端补成连续 7 天，缺日填 0；响应还
+      // 没到时保持空数组，否则加载态会先画 7 根零高柱子（stats 为 null 与 {} 分属
+      // 「未知」与「已知为空」，只有后者该补零）。
+      const rawDays = stats && Array.isArray(stats.by_day) ? stats.by_day : null;
+      const rawDayMap = new Map((rawDays ?? []).map((d) => [String((d && d.day) ?? ""), Number((d && d.total_tokens) ?? 0)]));
+      const endDay = new Date(`${new Date().toISOString().slice(0, 10)}T00:00:00Z`);
+      const days = rawDays
+        ? Array.from({ length: 7 }, (_, i) => {
+            const key = new Date(endDay.getTime() - (6 - i) * 86400000).toISOString().slice(0, 10);
+            return { day: key, total: rawDayMap.get(key) ?? 0 };
+          })
+        : [];
+      const dayMax = Math.max(1, ...days.map((d) => d.total));
+      const niceMax = Math.max(1e6, Math.ceil(dayMax / 1e6) * 1e6);
+      const gridVals = [niceMax, niceMax * 0.75, niceMax * 0.5, niceMax * 0.25];
+      // 8 周热力：数据必须来自 56 天窗口（heatStats），右缘对齐该窗口最后一天
+      // （UTC），左侧补齐到周一；数据窗口之外的格子隐藏留形。日期一律走 UTC——
+      // by_day 的 day 就是 UTC 日期。用 heatStats 而非 stats：否则 56 格里
+      // 48 格恒 0。
+      const heatDays = (heatStats && Array.isArray(heatStats.by_day) ? heatStats.by_day : []).map((d) => ({
+        day: String((d && d.day) ?? ""),
+        total: Number((d && d.total_tokens) ?? 0)
+      }));
+      const heatCells = [];
+      if (heatDays.length) {
+        const byDayMap = new Map(heatDays.map((d) => [d.day, d.total]));
+        const end = new Date(`${heatDays[heatDays.length - 1].day}T00:00:00Z`);
+        const start = new Date(end.getTime() - 55 * 86400000);
+        for (let i = 0; i < 56; i++) {
+          const d = new Date(start.getTime() + i * 86400000);
+          const key = d.toISOString().slice(0, 10);
+          heatCells.push({ key, total: byDayMap.get(key) ?? 0 });
+        }
+      }
+      const kpi = (title, num, cap) =>
+        h(StatusCard, { t, title, loading, error: statsError, num, cap });
+      const segClass = (s) =>
+        `mneme-seg mneme-seg--${opIdx(s.op) + 1}${focusOp === s.op ? " focused" : ""}`;
+      const rowProps = (op) => ({
+        className: focusOp && focusOp !== op ? "mneme-legendrow dim" : focusOp === op ? "mneme-legendrow focused" : "mneme-legendrow",
+        onMouseEnter: () => setFocusOp(op),
+        onMouseLeave: () => setFocusOp(null)
+      });
+
+      return h(react.Fragment, null,
+        h("div", { className: "mneme-statushead" }, t("memory.status.sec.token")),
+        h("div", { className: "mneme-kpiband" },
+          kpi(
+            t("memory.status.token.total"),
+            Number((stats && stats.total_tokens) ?? 0).toLocaleString(),
+            `${t("memory.status.token.in")} ${Number((stats && stats.input_tokens) ?? 0).toLocaleString()} · ${t("memory.status.token.out")} ${Number((stats && stats.output_tokens) ?? 0).toLocaleString()}`
+          ),
+          kpi(t("memory.status.token.calls"), Number((stats && stats.total_calls) ?? 0).toLocaleString(), t("memory.status.token.callsCap")),
+          kpi(
+            t("memory.status.token.share"),
+            grand > 0 ? `${((consolidate / grand) * 100).toFixed(1)}%` : "0.0%",
+            t("memory.status.token.shareFoot").replace("{n}", consolidate.toLocaleString())
+          ),
+          h(StatusCard, {
+            t,
+            title: t("memory.status.token.conflicts"),
+            loading: conf.loading,
+            error: conf.error,
+            num: conf.pending.toLocaleString(),
+            cap: t("memory.status.token.conflictsFoot")
+          })
+        ),
+        h("div", { className: "mneme-tokenflow" },
+          h("h3", { className: "mneme-xcolhead" }, t("memory.status.token.donut")),
+          statsError
+            ? h("div", { className: "mneme-statuscap", style: { color: "var(--mneme-danger)" } }, t("memory.status.error"))
+            : h("div", { className: "mneme-donutwrap" },
+                h("div", { className: "mneme-donutbox" },
+                  h("svg", {
+                    className: focusOp ? "mneme-donut has-focus" : "mneme-donut",
+                    viewBox: "0 0 42 42",
+                    "aria-hidden": "true"
+                  },
+                    h("g", { transform: "rotate(-90 21 21)" },
+                      segs.map((s) => h("circle", {
+                        key: s.op,
+                        className: segClass(s),
+                        cx: 21,
+                        cy: 21,
+                        r: 15.9155,
+                        "stroke-dasharray": `${s.seg.toFixed(2)} ${(100 - s.seg).toFixed(2)}`,
+                        "stroke-dashoffset": s.off.toFixed(2)
+                      }))
+                    )
+                  ),
+                  h("div", { className: "mneme-donut-center" },
+                    h("b", null, tokenCompact(grand)),
+                    h("span", null, t("memory.status.token.last7"))
+                  )
+                ),
+                h("div", { className: "mneme-legend" },
+                  allOps.map((r) => h("div", Object.assign({ key: r.op }, rowProps(r.op)),
+                    h("span", { className: `mneme-legenddot mneme-dot--${opIdx(r.op) + 1}` }),
+                    h("span", { className: "mneme-legendname" }, tokenOpLabel(t, r.op)),
+                    r.op === "write_admission"
+                      ? h("span", { className: "mneme-legendsub" }, t("memory.status.token.meterOnly"))
+                      : null,
+                    h("span", { className: "mneme-legendval" }, r.total.toLocaleString()),
+                    h("span", { className: "mneme-legendpct" },
+                      grand > 0 ? `${((r.total / grand) * 100).toFixed(1)}%` : "0.0%")
+                  ))
+                )
+              ),
+          h("h3", { className: "mneme-xcolhead" }, t("memory.status.token.days")),
+          h("div", { className: "mneme-bars" },
+            gridVals.map((v, i) => h("div", { key: v, className: "mneme-gridline", style: { top: `${i * 25}%` } },
+              h("span", { className: "mneme-gridlabel" }, `${(v / 1e6).toFixed(0)}M`)
+            )),
+            h("div", { className: "mneme-barcols" },
+              days.map((d) => h("div", { className: "mneme-barcol", key: d.day },
+                h("div", {
+                  className: "mneme-bar",
+                  style: { height: `${Math.max((d.total / niceMax) * 100, 0.4)}%` },
+                  title: `${d.day} · ${d.total.toLocaleString()}`
+                })
+              ))
+            )
+          ),
+          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")),
+          h("div", { className: "mneme-heatgrid" },
+            heatCells.map((c) => h("div", {
+              key: c.key,
+              className: heatLevel(c.total) ? `mneme-heatcell l${heatLevel(c.total)}` : "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"))
+          )
+        )
+      );
     }
 
     // 巩固状态卡（×2）：最近一次 autoDream 运行 + 待确认冲突计数。数据来自
     // /dream-status，一次取回两张卡共用；失败只影响这两张卡自身。
-    function DreamStatusCards({ t, onGotoQueue }) {
+    // showConflicts=false 用于 2026-10 改造后的降级折叠区：待确认冲突已升入
+    // KPI 带，这里不再重复渲染冲突卡，只留最近运行卡。
+    function DreamStatusCards({ t, onGotoQueue, showConflicts = true }) {
       const [state, setState] = useState({ loading: true, error: false, lastRun: null, pending: 0 });
       useEffect(() => {
         let cancelled = false;
@@ -3647,24 +4839,26 @@ window.__ModuleLoader__.load({
       const gotoQueue = () => { if (pending && onGotoQueue) onGotoQueue(); };
       return h(react.Fragment, null,
         h(StatusCard, { t, title: t("memory.status.dream"), loading: state.loading, error: state.error, num, cap }),
-        h("div", {
-          role: pending ? "button" : undefined,
-          tabIndex: pending ? 0 : undefined,
-          "aria-label": pending ? t("memory.status.conflictQueue.goto") : undefined,
-          className: pending ? "mneme-conflict-jump" : undefined,
-          style: pending ? { cursor: "pointer" } : undefined,
-          onClick: pending ? gotoQueue : undefined,
-          onKeyDown: pending ? (e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); gotoQueue(); } } : undefined
-        },
-          h(StatusCard, {
-            t,
-            title: t("memory.status.conflicts"),
-            loading: state.loading,
-            error: state.error,
-            num: state.pending.toLocaleString(),
-            cap: t("memory.status.conflictsHint")
-          })
-        )
+        showConflicts
+          ? h("div", {
+              role: pending ? "button" : undefined,
+              tabIndex: pending ? 0 : undefined,
+              "aria-label": pending ? t("memory.status.conflictQueue.goto") : undefined,
+              className: pending ? "mneme-conflict-jump" : undefined,
+              style: pending ? { cursor: "pointer" } : undefined,
+              onClick: pending ? gotoQueue : undefined,
+              onKeyDown: pending ? (e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); gotoQueue(); } } : undefined
+            },
+              h(StatusCard, {
+                t,
+                title: t("memory.status.conflicts"),
+                loading: state.loading,
+                error: state.error,
+                num: state.pending.toLocaleString(),
+                cap: t("memory.status.conflictsHint")
+              })
+            )
+          : null
       );
     }
 
@@ -3682,7 +4876,7 @@ window.__ModuleLoader__.load({
         return () => { cancelled = true; };
       }, []);
       if (state.loading || !state.suppressed) return null;
-      return h("div", { className: "mneme-statuscard", style: { borderColor: "var(--dsw-alias-state-warning,#e6a23c)" } },
+      return h("div", { className: "mneme-statuscard", style: { borderColor: "var(--mneme-warn)" } },
         h("div", { className: "mneme-statusnum", style: { fontSize: "16px", lineHeight: "24px" } }, t("memory.status.injectSuppressed")),
         h("div", { className: "mneme-statuscap" }, t("memory.status.injectSuppressedHint"))
       );
@@ -3757,6 +4951,17 @@ window.__ModuleLoader__.load({
       const [items, setItems] = useState(null);
       const [loadError, setLoadError] = useState(false);
       const [busy, setBusy] = useState(false);
+      // 展开态按冲突条目记（一对两侧同时展开，便于逐行对照）；复制态按
+      // 「条目:侧别」记，避免一次复制把别的按钮也点亮。
+      const [openItems, setOpenItems] = useState({});
+      const [copiedKey, setCopiedKey] = useState(null);
+      const toggleItem = (id) => setOpenItems((prev) => ({ ...prev, [id]: !prev[id] }));
+      const copySide = (key, content) => {
+        navigator.clipboard?.writeText(String(content || "")).then(
+          () => { setCopiedKey(key); announce(t("memory.status.conflictQueue.copiedSide")); setTimeout(() => setCopiedKey((k) => (k === key ? null : k)), 1500); },
+          () => {}
+        );
+      };
       const load = (silent) => {
         apiFetch("/api/dsh-mneme/conflicts")
           .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
@@ -3791,18 +4996,39 @@ window.__ModuleLoader__.load({
           .catch(() => {})
           .finally(() => setBusy(false));
       };
-      const side = (s, label, sideClass, ops, diffSide) => h("div", { className: `mneme-conflict-side ${sideClass}` },
+      const side = (s, label, sideClass, ops, diffSide, open, itemKey) => h("div", { className: `mneme-conflict-side ${sideClass}` },
         h("div", { className: "mneme-conflict-sidelabel" }, label),
         s.missing
           ? h("div", { className: "mneme-conflict-missing" }, t("memory.status.conflictQueue.missing"))
           : h(react.Fragment, null,
               h("div", { className: "mneme-conflict-sidetitle", title: s.title }, s.title || "…"),
+              // 判读依据行：类型 / 重要度 / 字数 / 新旧 + 单侧全文复制。报障者
+              // 「只好两个都删或胡乱选」的直接原因是这一行了无信息——只有
+              // A 方/B 方两个标签，看不出哪条更新、哪条更长、哪条更重要。
+              h("div", { className: "mneme-conflict-meta" },
+                h("span", { className: "mneme-conflict-metaval" }, typeLabel(t, s.type)),
+                s.importance !== null && s.importance !== undefined
+                  ? h("span", null, t("memory.status.conflictQueue.importance").replace("{n}", String(s.importance)))
+                  : null,
+                h("span", null, t("memory.status.conflictQueue.chars").replace("{n}", String((s.content || "").length))),
+                h("span", null, (s.updated_at ? t("memory.status.conflictQueue.updated") : t("memory.status.conflictQueue.created"))
+                  .replace("{time}", formatRelativeTime(s.updated_at || s.created_at, t))),
+                h("button", {
+                  className: "mneme-footbtn",
+                  onClick: () => copySide(`${itemKey}:${diffSide}`, s.content)
+                }, copiedKey === `${itemKey}:${diffSide}`
+                  ? t("memory.status.conflictQueue.copiedSide")
+                  : t("memory.status.conflictQueue.copySide"))),
               // #177：词级 diff 可用（LCS 无损对齐成功）时用高亮视图替代纯文本。
               // 侧别过滤（#295 评审修正）：A 侧渲染 same+del（它被删的部分高亮），
               // B 侧渲染 same+ins（它新增的部分高亮）——每列忠实于自己的原文。
               // title 提示颜色语义；diff 不可用时保留原 snippet。
+              // 展开态：diff 去掉 4 行钳制、纯文本不再截 140 字（改走 pre-wrap 滚动区）。
               ops
-                ? h("div", { className: "mneme-conflict-diff", title: t("memory.status.conflictQueue.diffTitle") },
+                ? h("div", {
+                    className: open ? "mneme-conflict-diff mneme-conflict-diff--full" : "mneme-conflict-diff",
+                    title: t("memory.status.conflictQueue.diffTitle")
+                  },
                     ops.map((o, k) => {
                       if (o.kind === "same") return o.text;
                       if (o.kind === "del" && diffSide === "a") {
@@ -3813,7 +5039,8 @@ window.__ModuleLoader__.load({
                       }
                       return null; // 对侧的编辑片段不出现在本列
                     }))
-                : h("div", { className: "mneme-conflict-snippet" }, (s.content || "").slice(0, 140)),
+                : h("div", { className: open ? "mneme-conflict-text" : "mneme-conflict-snippet" },
+                    open ? (s.content || "") : (s.content || "").slice(0, 140)),
               // #177：预裁决阶段两侧都还活着——「已归档」徽章换成「冻结中」，
               // 原注销记说明（applyHint）挪进 tooltip，不再整段占一行动态区。
               h("span", {
@@ -3846,6 +5073,7 @@ window.__ModuleLoader__.load({
               h("div", { className: "mneme-conflict-empty-body" }, t("memory.status.conflictQueue.emptyBody")))),
         items.map((it) => {
           const sim = similarityOf(it.reason);
+          const open = openItems[it.id] === true;
           const aText = (it.memory_a && it.memory_a.content) || "";
           const bText = (it.memory_b && it.memory_b.content) || "";
           // diff 与相似度条互补：reason 给不出数字时才跑 LCS（两者表达同一信息）。
@@ -3860,11 +5088,16 @@ window.__ModuleLoader__.load({
               h("span", { className: "mneme-conflict-simfill", style: { width: `${Math.round(sim * 100)}%` } })),
             h("span", null, `${Math.round(sim * 100)}%`)),
           h("div", { className: "mneme-conflict-pair" },
-            side(it.memory_a, t("memory.status.conflictQueue.sideA"), "mneme-conflict-side--a", diff, "a"),
-            side(it.memory_b, t("memory.status.conflictQueue.sideB"), "mneme-conflict-side--b", diff, "b")),
+            side(it.memory_a, t("memory.status.conflictQueue.sideA"), "mneme-conflict-side--a", diff, "a", open, it.id),
+            side(it.memory_b, t("memory.status.conflictQueue.sideB"), "mneme-conflict-side--b", diff, "b", open, it.id)),
           h("div", { className: "mneme-conflict-actions" },
             h("span", { className: "mneme-conflict-hint", title: t("memory.status.conflictQueue.applyHintTitle") },
               t("memory.status.conflictQueue.applyHint")),
+            h("button", {
+              className: "mneme-footbtn",
+              "aria-expanded": open,
+              onClick: () => toggleItem(it.id)
+            }, t(open ? "memory.status.conflictQueue.collapse" : "memory.status.conflictQueue.expand")),
             h("button", { className: "mneme-conflict-primary", disabled: busy, "aria-label": `${t("memory.status.conflictQueue.keepA")}: ${(it.memory_a && it.memory_a.title) || ""}`, onClick: () => resolve(it.id, "a") }, t("memory.status.conflictQueue.keepA")),
             h("button", { className: "mneme-conflict-primary", disabled: busy, "aria-label": `${t("memory.status.conflictQueue.keepB")}: ${(it.memory_b && it.memory_b.title) || ""}`, onClick: () => resolve(it.id, "b") }, t("memory.status.conflictQueue.keepB")),
             h("button", { className: "mneme-footbtn", disabled: busy, onClick: () => resolve(it.id, null) }, t("memory.status.conflictQueue.markReviewed"))));
@@ -4152,24 +5385,41 @@ window.__ModuleLoader__.load({
         queueRef.current.focus({ preventScroll: true });
         if (queueRef.current.scrollIntoView) queueRef.current.scrollIntoView({ block: "start", behavior: "smooth" });
       };
+      // 折叠区受控开合：收起时不挂载子卡，10 张卡各自的请求一次都不发——
+      // 展开才是「我要看后台细节」的明确信号，首屏只承担 Token 三屏的开销。
+      const [legacyOpen, setLegacyOpen] = useState(false);
       return h("div", { className: "mneme-status" },
-        // 两个分组标题把九张卡拆成「库内一览 / 后台运转」两段扫读单元
-        h("div", { className: "mneme-statushead" }, t("memory.status.sec.overview")),
-        h("div", { className: "mneme-statusgrid mneme-statusgrid--overview" },
-          h(MemoriesStatusCard, { t }),
-          h(EntitiesStatusCard, { t }),
-          h(VectorStatusCard, { t }),
-          h(MirrorHealthCard, { t })
-        ),
-        h("div", { className: "mneme-statushead" }, t("memory.status.sec.engine")),
-        h("div", { className: "mneme-statusgrid" },
-          h(DreamStatusCards, { t, onGotoQueue: gotoQueue }),
-          h(LlmStatusCard, { t }),
-          h(HeatStatusCard, { t }),
-          h(RecallStatsCard, { t }),
-          h(InjectStatusCard, { t }),
-          h(InjectPreviewCard, { t })
+        h(TokenFlowSection, { t }),
+        h("details", {
+          className: "mneme-legacy",
+          open: legacyOpen
+        },
+          // 开合挂在 summary 上而非 details：details 上的 onClick 会连折叠区里
+          // 子卡片的点击一起吃掉（preventDefault 拦掉冒泡上来的激活事件），
+          // 而 summary 是浏览器原生的开合把手，点它以外的地方不该切换（自动
+          // 评审 #412 指出）。
+          h("summary", { onClick: (e) => { e.preventDefault(); setLegacyOpen(!legacyOpen); } }, t("memory.status.token.detail")),
+          legacyOpen ? h(react.Fragment, null,
+            // 分组标题把九张卡拆成「库内一览 / 后台运转」两段扫读单元
+            h("div", { className: "mneme-statushead" }, t("memory.status.sec.overview")),
+            h("div", { className: "mneme-statusgrid mneme-statusgrid--overview" },
+              h(MemoriesStatusCard, { t }),
+              h(EntitiesStatusCard, { t }),
+              h(VectorStatusCard, { t }),
+              h(MirrorHealthCard, { t })
+            ),
+            h("div", { className: "mneme-statushead" }, t("memory.status.sec.engine")),
+            h("div", { className: "mneme-statusgrid" },
+              h(DreamStatusCards, { t, showConflicts: false }),
+              h(HeatStatusCard, { t }),
+              h(RecallStatsCard, { t }),
+              h(InjectStatusCard, { t }),
+              h(InjectPreviewCard, { t })
+            )
+          ) : null
         ),
+        h("div", { className: "mneme-statushead" }, t("memory.status.sec.maintenance")),
+        h("div", { className: "mneme-statusgrid" }, h(MaintenanceCard, { t })),
         h("div", { ref: queueRef }, h(ConflictsQueue, { t })),
         h(WorkbenchSection, { t, onBrowse })
       );
@@ -4377,7 +5627,7 @@ window.__ModuleLoader__.load({
             ? h(react.Fragment, null,
                 confirmWiden
                   ? h(react.Fragment, null,
-                      h("span", { style: { fontSize: 12, color: "var(--dsw-alias-state-warn,#b8860b)" } },
+                      h("span", { style: { fontSize: 12, color: "var(--mneme-warn)" } },
                         t("memory.explorer.detail.scopeWidenHint")),
                       h("button", { type: "button", className: "mneme-btn mneme-btndangerconfirm", disabled: busy, onClick: save },
                         t("memory.explorer.detail.scopeWidenConfirm")),
@@ -4400,7 +5650,7 @@ window.__ModuleLoader__.load({
                   }
                 }, t("memory.explorer.detail.cancel")),
                 savedTick && h("span", { className: "mneme-saved" }, t("memory.explorer.detail.saved")),
-                saveError && h("span", { style: { fontSize: 12, color: "var(--dsw-alias-state-error,#c33)" } }, t("memory.explorer.detail.archiveFailed"))
+                saveError && h("span", { style: { fontSize: 12, color: "var(--mneme-danger)" } }, t("memory.explorer.detail.archiveFailed"))
               )
             : h(react.Fragment, null,
                 h("button", { type: "button", className: "mneme-btn", onClick: () => setEditing(true) }, t("memory.explorer.detail.edit")),
@@ -4428,7 +5678,7 @@ window.__ModuleLoader__.load({
                     )
                   : h("button", { type: "button", className: "mneme-btn mneme-btndanger", onClick: () => setConfirmDelete(true) },
                       t("memory.explorer.delete")),
-                deleteError && h("span", { style: { fontSize: 12, color: "var(--dsw-alias-state-error,#c33)" } },
+                deleteError && h("span", { style: { fontSize: 12, color: "var(--mneme-danger)" } },
                   t("memory.explorer.deleteFailed"))
               )
         )
@@ -4483,7 +5733,7 @@ window.__ModuleLoader__.load({
             onChange: (e) => { setFile((e.target.files && e.target.files[0]) || null); setErr(""); }
           })
         ),
-        err && h("div", { className: "mneme-featsubhint", style: { color: "var(--dsw-alias-state-error,#c33)", marginTop: 8 } }, err),
+        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")),
@@ -4493,6 +5743,117 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // #386 第 5 条：面板手动新增一条记忆。字段与 memory_save 工具对齐
+    //（type/title/content/importance/tags），但**不放 scope/sensitivity**：归属的
+    // 显式声明走详情抽屉那条路，它带「放宽可见性」二次确认；在新建表单里顺手盖
+    // 章会绕开那道确认。后端的去重键仍是 (type, title, scope, sensitivity)，所以
+    // 同类型同标题会并入既有行——服务端回的 action 决定提示语说「已新建」还是
+    // 「已并入」，两者对用户是不同的事实，不能都报「已保存」。
+    function CreateDialog({ t, onClose, onCreated }) {
+      const [type, setType] = useState("preference");
+      const [title, setTitle] = useState("");
+      const [content, setContent] = useState("");
+      const [importance, setImportance] = useState(3);
+      const [tags, setTags] = useState("");
+      const [busy, setBusy] = useState(false);
+      const [msg, setMsg] = useState("");
+      const [err, setErr] = useState("");
+      const submit = () => {
+        // 前端先拦一次空标题/空正文：后端也会 400，但往返一趟只为报「标题不能
+        // 为空」不值当。服务端校验仍是权威——它同时管着类型白名单与去重。
+        if (!title.trim()) { setErr(t("memory.explorer.newNoTitle")); return; }
+        if (!content.trim()) { setErr(t("memory.explorer.newNoContent")); return; }
+        setBusy(true);
+        setErr("");
+        apiFetch("/api/dsh-mneme/create", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            type,
+            title: title.trim(),
+            content: content.trim(),
+            importance,
+            tags: tags.split(",").map((s) => s.trim()).filter(Boolean)
+          })
+        })
+          .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+          .then((d) => {
+            setMsg(d && d.action === "merged" ? t("memory.explorer.newMerged") : t("memory.explorer.newCreated"));
+            // 成功后**不**重置 busy。这 900ms 是留给提示的阅读时间，而「新建」按钮此刻
+            // 若重新可点，第二次同 type+title 会落进同一行，service 走 appendContent 把
+            // 正文再追加一遍，提示还会从「已新建」翻成「已并入」——一次误触就写坏一条
+            // 记忆。保持 busy 直到关窗，按钮全程 disabled（成功路径组件随即卸载，没有
+            // 需要复原的状态）。
+            // 停 900ms 让提示可读，再关窗并把新建的行选中（见 onCreated）。
+            setTimeout(() => { onCreated(d); onClose(); }, 900);
+          })
+          .catch(() => { setBusy(false); setErr(t("memory.explorer.newFailed")); });
+      };
+      return h("div", { className: "mneme-impdialog", role: "region", "aria-label": t("memory.explorer.newTitle") },
+        h("div", { className: "mneme-set-title" }, t("memory.explorer.newTitle")),
+        h("div", { className: "mneme-featsubhint", style: { marginTop: 4 } }, t("memory.explorer.newHint")),
+        h("div", { className: "mneme-improw" },
+          h("span", { className: "mneme-featnumlabel" }, t("memory.explorer.newType")),
+          h("select", { className: "mneme-select", value: type, onChange: (e) => setType(e.target.value) },
+            // document 刻意不在列：它是 agent 注册长文档的指针行，铸造口唯一
+            //（registerDocument，#230），后端路由也会 400。列出来只会让人点了
+            // 才被拒。
+            ["preference", "project", "decision", "history", "rejected_solution", "pitfall", "constraint"].map((k) =>
+              h("option", { key: k, value: k }, typeLabel(t, k))))
+        ),
+        h("div", { className: "mneme-improw" },
+          h("input", {
+            type: "text",
+            className: "mneme-set-input",
+            value: title,
+            placeholder: t("memory.explorer.newTitlePlaceholder"),
+            "aria-label": t("memory.explorer.newTitlePlaceholder"),
+            onChange: (e) => { setTitle(e.target.value); setErr(""); }
+          })
+        ),
+        h("div", { className: "mneme-improw" },
+          h("textarea", {
+            className: "mneme-set-input mneme-set-input--area",
+            value: content,
+            placeholder: t("memory.explorer.newContentPlaceholder"),
+            "aria-label": t("memory.explorer.newContentPlaceholder"),
+            rows: 4,
+            onChange: (e) => { setContent(e.target.value); setErr(""); }
+          })
+        ),
+        h("div", { className: "mneme-improw" },
+          h("input", {
+            type: "text",
+            className: "mneme-set-input",
+            value: tags,
+            placeholder: t("memory.explorer.newTagsPlaceholder"),
+            "aria-label": t("memory.explorer.newTagsPlaceholder"),
+            onChange: (e) => setTags(e.target.value)
+          })
+        ),
+        h("div", { className: "mneme-improw" },
+          h("span", { className: "mneme-featnumlabel" }, t("memory.explorer.importance")),
+          h("div", { className: "mneme-staredit", role: "radiogroup", "aria-label": t("memory.explorer.detail.editImportance") },
+            [1, 2, 3, 4, 5].map((n) => h("button", {
+              key: n,
+              type: "button",
+              role: "radio",
+              "aria-checked": String(importance === n),
+              "aria-label": t("memory.explorer.detail.starLabel").replace("{n}", String(n)),
+              className: importance >= n ? "mneme-starbtn mneme-starbtn--on" : "mneme-starbtn",
+              onClick: () => setImportance(n)
+            }, h(StarGlyph, { size: 15, filled: importance >= n }))))
+        ),
+        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 && !msg ? t("memory.explorer.newSaving") : t("memory.explorer.newConfirm"))
+        )
+      );
+    }
+
     function MemoryExplorer({ t }) {
       const [view, setView] = useState("memory"); // memory | entity | status | settings
       const [items, setItems] = useState([]); // loaded browse pages, chrono desc
@@ -4528,6 +5889,7 @@ window.__ModuleLoader__.load({
       const [pendingIds, setPendingIds] = useState(() => new Set());
       const [menuOpen, setMenuOpen] = useState(false);
       const [importOpen, setImportOpen] = useState(false);
+      const [createOpen, setCreateOpen] = useState(false);
       const itemRefs = useRef(new Map());
       const moreRef = useRef(null);
 
@@ -4877,9 +6239,11 @@ window.__ModuleLoader__.load({
                 "aria-label": t("memory.explorer.more"),
                 "aria-expanded": String(menuOpen),
                 title: t("memory.explorer.more"),
-                onClick: () => { setMenuOpen(!menuOpen); setImportOpen(false); }
+                onClick: () => { setMenuOpen(!menuOpen); setImportOpen(false); setCreateOpen(false); }
               }, "⋯"),
               menuOpen && h("div", { className: "mneme-menu", role: "menu" },
+                h("button", { type: "button", role: "menuitem", 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"); } },
@@ -4891,6 +6255,13 @@ window.__ModuleLoader__.load({
                 t,
                 onClose: () => setImportOpen(false),
                 onImported: () => setReloadKey((k) => k + 1)
+              }),
+              createOpen && h(CreateDialog, {
+                t,
+                onClose: () => setCreateOpen(false),
+                // 新建后既刷新列表也选中新行：并入既有条目时 action 是 merged，
+                // 返回的 id 就是被并入那一行——两种情况都该把它滚进视野。
+                onCreated: (d) => { setReloadKey((k) => k + 1); if (d && d.id) setSelectedId(d.id); }
               })
             )
           ),
@@ -5365,6 +6736,1045 @@ window.__ModuleLoader__.load({
         ), host);
     }
 
+    // ---------------------------------------------------------------------
+    // v0.9.0 M.O.（beta，只读）
+    // 定性：trace viewer 不是编辑画布——节点=步骤、边=依赖、一次运行=一条
+    // 被高亮走过的路径。本版数据全部是 §4 mneme.pipeline/v1 形状的假数据，
+    // 服务端管线落地前先验证形态与交互。
+    // ---------------------------------------------------------------------
+    const PIPELINE_ACTIONS_TAB_ID = "dsh-mneme:actions";
+    const PIPELINE_ACTIONS_TAB_KIND = "mneme-actions";
+
+    // 节点状态四值，refuted 是全篇核心信号（最扎眼）。
+    const PIPELINE_STATES = ["candidate", "trusted", "stale", "refuted"];
+
+    // 数据面 = **项目里**的工作流（服务端 /api/dsh-mneme/pipeline 投影成 mneme.pipeline/v1）。
+    // 项目从哪来：只有客户端拿得到会话的工作目录，所以这里解析出 cwd、当 ?project= 带上；
+    // 服务端没有「当前项目」这个概念，也不许替谁猜一个。
+    // 为什么四个座位共用缓存、且缓存**按项目 + 按工作流**分桶：四个座位读的必须是同一份
+    // ——「会话头说有 3 条、右栏说有 5 条」这种分家没人查得出来；同理，同一个进程里开着
+    // 两个不同项目的会话时，不分桶就会把 A 项目的清单端给 B 项目看，而画面看不出错。
+    const pipelineDocs = new Map();
+    const pipelinePendingByKey = new Map();
+    function pipelineKey(project, id) { return (project || "") + "\u0000" + (id || ""); }
+    function loadPipeline(project, id) {
+      const key = pipelineKey(project, id);
+      if (!pipelinePendingByKey.has(key)) {
+        const params = [];
+        if (project) params.push("project=" + encodeURIComponent(project));
+        if (id) params.push("id=" + encodeURIComponent(id));
+        const url = "/api/dsh-mneme/pipeline" + (params.length ? "?" + params.join("&") : "");
+        pipelinePendingByKey.set(key, apiFetch(url)
+          .then((res) => (res.ok ? res.json() : null))
+          .catch(() => null)
+          .then((doc) => { pipelineDocs.set(key, doc); return doc; }));
+      }
+      return pipelinePendingByKey.get(key);
+    }
+    // undefined = 还在读；null = 读不出来；对象 = 拿到了（其中 pipeline 为 null 表示
+    // 这个项目里还没有工作流——那是空态，不是错误，别把两者画成同一张脸）。
+    // id 为空 = 取清单（服务端会顺带给出第一条的完整投影，够结算卡用）。
+    function usePipeline(project, id) {
+      const key = pipelineKey(project, id);
+      const [doc, setDoc] = useState(pipelineDocs.has(key) ? pipelineDocs.get(key) : undefined);
+      useEffect(() => {
+        let alive = true;
+        loadPipeline(project, id).then((d) => { if (alive) setDoc(d); });
+        return () => { alive = false; };
+      }, [key]);
+      return doc;
+    }
+    // 会话工作目录。两条来源依次试，各自兜自己的异常——一条抛了不能把另一条也带走；
+    // 两处都试不到就**返回 null**（面板退到全局层，并如实标「项目未知」），绝不退回进程
+    // 目录之类的东西——那会把「读不到」变成「读到别处」，而后者在界面上看不出来，是最难
+    // 查的一类错。
+    // 首选会话列表快照：byId[sessionId].cwd 是宿主给客户端的公开形状（dsh-context 用的
+    // 就是这条）；sessions.get() 是宿主侧写法，客户端不一定有，所以放第二位。
+    function sessionProject(ctx, sessionId) {
+      if (!sessionId || !ctx || typeof ctx.get !== "function") return null;
+      const warn = (err) => console.warn("[dsh-mneme] session cwd lookup failed:", err);
+      const pick = (row) => {
+        if (!row) return null;
+        const cwd = (row.header && row.header.cwd) || row.cwd;
+        return typeof cwd === "string" && cwd ? cwd : null;
+      };
+      let sessions = null;
+      try { sessions = ctx.get("sessions"); } catch (err) { warn(err); }
+      if (sessions) {
+        try {
+          const snap = sessions.list && typeof sessions.list.getSnapshot === "function"
+            ? sessions.list.getSnapshot()
+            : null;
+          const hit = pick(snap && snap.byId ? snap.byId[sessionId] : null);
+          if (hit) return hit;
+        } catch (err) { warn(err); }
+        try {
+          if (typeof sessions.get === "function") {
+            const hit = pick(sessions.get(sessionId));
+            if (hit) return hit;
+          }
+        } catch (err) { warn(err); }
+      }
+      return null;
+    }
+
+    // DAG 分层布局：Kahn 最长路分层（层数 = 到该节点最长边数），
+    // 防环——正常分层算完后如果还有节点没落位（说明有环），
+    // 按输入顺序塞进最后一层，绝不死循环。节点数少，几十行够用。
+    function layoutDag(nodes, edges) {
+      const byId = {};
+      for (const n of nodes) byId[n.id] = n;
+      const indeg = {};
+      const out = {};
+      for (const n of nodes) { indeg[n.id] = 0; out[n.id] = []; }
+      for (const e of edges) {
+        if (!byId[e.from] || !byId[e.to] || e.from === e.to) continue;
+        out[e.from].push(e.to);
+        indeg[e.to] += 1;
+      }
+      const layer = {};
+      const queue = nodes.filter((n) => indeg[n.id] === 0).map((n) => n.id);
+      const remaining = {};
+      for (const n of nodes) remaining[n.id] = indeg[n.id];
+      while (queue.length) {
+        const id = queue.shift();
+        for (const to of out[id]) {
+          layer[to] = Math.max(layer[to] || 0, (layer[id] || 0) + 1);
+          remaining[to] -= 1;
+          if (remaining[to] === 0) queue.push(to);
+        }
+      }
+      const maxLayer = nodes.reduce((m, n) => Math.max(m, layer[n.id] || 0), 0);
+      const leftovers = nodes.filter((n) => remaining[n.id] > 0);
+      for (const n of leftovers) layer[n.id] = maxLayer + 1; // 环兜底
+      const layers = [];
+      for (const n of nodes) {
+        const L = layer[n.id] || 0;
+        (layers[L] = layers[L] || []).push(n.id);
+      }
+      return { layer, layers: layers.map((l) => l || []) };
+    }
+
+    // 阶段带布局（2026-10-16）：layoutDag 只按 DAG 深度分层、不读 phase，把 5 段
+    // 19 步排成 18 层的单列长链（固有 354×1902px），第一屏既看不出「分几段」也
+    // 读不出「谁在做」。这里按 step.phase 分组（保持作者书写顺序——phase 是人手
+    // 写的分类词，不能按字母重排）、段内左到右每行两列换行：画布固有宽度落回
+    // 354px（右栏 400px 不缩放就能读），高度从 1902 腰斩到 ~836。
+    // 纯函数、不碰 DOM：探针 .scratch/mo-ux-probe-layout.mjs 会把它抠出来真跑，
+    // 改签名或引用外部变量都会让那条可重跑核算失明。
+    function layoutPipelineBands(nodes, edges, C) {
+      const NW = (C && C.NW) || 150;
+      const NH = (C && C.NH) || 54;
+      const GX = (C && C.GX) || 30;
+      const PAD = (C && C.PAD) || 12;
+      const COLS = 2, ROW_GAP = 14, BAND_HEAD = 26, BAND_GAP = 18;
+      const order = [];
+      const byPhase = {};
+      for (const n of nodes) {
+        const ph = n.phase || "";
+        if (!byPhase[ph]) { byPhase[ph] = []; order.push(ph); }
+        byPhase[ph].push(n.id);
+      }
+      const pos = {};
+      const bands = [];
+      const bandRects = [];
+      const W = PAD * 2 + COLS * NW + (COLS - 1) * GX;
+      let y = PAD;
+      for (const ph of order) {
+        const ids = byPhase[ph];
+        const rows = Math.ceil(ids.length / COLS);
+        const top = y;
+        y += BAND_HEAD;
+        ids.forEach((id, i) => {
+          const r = Math.floor(i / COLS), c = i % COLS;
+          pos[id] = { x: PAD + c * (NW + GX), y: y + r * (NH + ROW_GAP) };
+        });
+        y += rows * NH + (rows - 1) * ROW_GAP;
+        bands.push({ name: ph, count: ids.length, top, bottom: y });
+        bandRects.push({ name: ph, count: ids.length, x: PAD - 6, y: top, w: W - 2 * (PAD - 6), h: y - top });
+        y += BAND_GAP;
+      }
+      const H = y - BAND_GAP + PAD;
+      return { pos, W, H, bands, bandRects };
+    }
+
+    // 标题两行拆分：pipeClip 一刀截 11 字把「定版本号与发布范围」截成「…发布范…」。
+    // 节点加高到 54px 后装得下两行——标本 19 个标题里 7 个超 11 字、最长 22 字，
+    // 恰好两行放全；超长兜底仍留省略号。
+    function pipeTitleLines(s, n) {
+      const str = String(s || "");
+      if (str.length <= n) return [str];
+      const head = str.slice(0, n);
+      const rest = str.slice(n);
+      return [head, rest.length > n ? rest.slice(0, n - 1) + "…" : rest];
+    }
+
+    function pipeFmtWhen(iso) {
+      if (!iso) return "";
+      const d = new Date(iso);
+      if (isNaN(d.getTime())) return "";
+      const p = (x) => String(x).padStart(2, "0");
+      return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+    }
+    function pipeClip(s, n) {
+      const str = String(s || "");
+      return str.length > n ? str.slice(0, n - 1) + "…" : str;
+    }
+    function pipeDaysAgo(iso) {
+      if (!iso) return null;
+      const d = new Date(iso);
+      if (isNaN(d.getTime())) return null;
+      return Math.max(0, Math.floor((Date.now() - d.getTime()) / 86400000));
+    }
+
+    // 运行档位：一次运行一个芯片；失败/被推翻的运行照常列出（留痕）。
+    function PipelineRunChips(props) {
+      const { t, runs, selectedRunId, onSelectRun } = props;
+      return h("div", { className: "mneme-pipe-runs", role: "group", "aria-label": t("memory.actions.runs") },
+        h("span", { className: "mneme-pipe-scope" }, t("memory.actions.runs")),
+        (runs || []).map((r, i) => h("button", {
+          key: r.id || i,
+          type: "button",
+          className: "mneme-pipe-run" + (r.id === selectedRunId ? " mneme-on" : ""),
+          onClick: () => onSelectRun && onSelectRun(r.id),
+          title: t("memory.actions.run." + (r.outcome || "ok"))
+        },
+          h("span", { className: "mneme-pipe-runDot mneme-pipe-runDot--" + (r.outcome || "ok"), "aria-hidden": "true" }),
+          t("memory.actions.runOf").replace("{n}", String(i + 1)) + " · " + pipeFmtWhen(r.at)
+        ))
+      );
+    }
+
+    // 宽态 DAG：按 phase 分阶段带的 SVG，一次运行 = 一条高亮路径（trace viewer 读法）。
+    // 分组与几何来自 layoutPipelineBands（纯函数，探针真跑它），这里只管画。
+    function PipelineGraphSvg(props) {
+      const { t, data, run, selectedNodeId, onSelectNode } = props;
+      const nodes = data.nodes || [];
+      const edges = data.edges || [];
+      const pathSet = {};
+      const edgeState = {};
+      if (run && Array.isArray(run.path)) {
+        for (const id of run.path) pathSet[id] = true;
+        for (let i = 0; i + 1 < run.path.length; i++) {
+          const a = run.path[i];
+          const b = run.path[i + 1];
+          const isLast = i + 2 === run.path.length;
+          edgeState[a + ">" + b] = run.outcome === "failed" && isLast ? "fail" : "on";
+        }
+      }
+      const usedSet = {};
+      if (run && Array.isArray(run.usedNodeIds)) {
+        for (const id of run.usedNodeIds) usedSet[id] = true;
+      }
+      const NW = 150, NH = 54, GX = 30, GY = 66, PAD = 12;
+      const laid = layoutPipelineBands(nodes, edges, { NW, NH, GX, GY, PAD });
+      const pos = laid.pos;
+      const W = laid.W;
+      const Hh = laid.H;
+      const KIND_RX = { step: 8, gate: 4, branch: 16, artifact: 21 };
+      return h("svg", {
+        className: "mneme-pipe-svg",
+        viewBox: `0 0 ${W} ${Hh}`,
+        width: W,
+        height: Hh,
+        role: "img",
+        "aria-label": t("memory.actions.title")
+      },
+        // 阶段带：段底 + 段名与该段步数。分段信息画在节点之下、边之下——
+        // 它是背景不是主角，但必须先上屏，第一屏才读得出「分几段」。
+        laid.bandRects.map((b, i) => h("g", { key: "band" + i },
+          h("rect", {
+            className: "mneme-pipe-bandbg",
+            x: b.x, y: b.y, width: b.w, height: b.h, rx: 10
+          }),
+          i > 0 ? h("line", {
+            className: "mneme-pipe-bandline",
+            x1: PAD, x2: W - PAD, y1: b.y - 9, y2: b.y - 9
+          }) : null,
+          h("text", {
+            className: "mneme-pipe-bandT",
+            x: PAD + 4, y: b.y + 17
+          }, (b.name || "") + " · " + t("memory.actions.band.count").replace("{n}", String(b.count)))
+        )),
+        edges.map((e) => {
+          const a = pos[e.from];
+          const b = pos[e.to];
+          if (!a || !b) return null;
+          const st = edgeState[e.from + ">" + e.to];
+          const cls = st === "fail" ? "mneme-pipe-edgeFail" : st === "on" ? "mneme-pipe-edgeOn" : "mneme-pipe-edge";
+          // 同行相邻（蛇形读法）：右缘出、左缘进，短水平贝塞尔；
+          // 跨行/跨段仍走「底出顶进」的竖向贝塞尔。同行旧画法会把线甩出段外
+          // （真机截图验出），横连读起来就是「往下一段走」。
+          let d;
+          if (b.y === a.y && b.x > a.x) {
+            const ym = a.y + NH / 2;
+            d = `M ${a.x + NW} ${ym} C ${a.x + NW + GX / 2} ${ym}, ${b.x - GX / 2} ${ym}, ${b.x} ${ym}`;
+          } else {
+            const x1 = a.x + NW / 2, y1 = a.y + NH, x2 = b.x + NW / 2, y2 = b.y;
+            d = `M ${x1} ${y1} C ${x1} ${y1 + 26}, ${x2} ${y2 - 26}, ${x2} ${y2}`;
+          }
+          return h("path", {
+            key: e.id || (e.from + ">" + e.to),
+            className: cls,
+            d
+          }, e.label ? h("title", null, e.label) : null);
+        }),
+        nodes.map((n) => {
+          const p = pos[n.id];
+          if (!p) return null;
+          const rx = KIND_RX[n.kind] != null ? KIND_RX[n.kind] : 8;
+          const on = !!(run && pathSet[n.id]);
+          const gate = n.kind === "gate";
+          const cls = "mneme-pipe-node mneme-pipe-node--" + (n.state || "candidate")
+            + (usedSet[n.id] ? " mneme-pipe-node--onpath" : "")
+            + (gate ? " mneme-pipe-node--gate" : "");
+          const lines = pipeTitleLines(n.title, 10);
+          // meta 行三段：状态（四态）· who（主/人/CI）· risk（R0-R3）。
+          // who/risk 都是投影自带字段，此前一个都没上屏；risk 缺失按 R0 兜底。
+          const meta = [
+            t("memory.actions.state." + (n.state || "candidate")),
+            n.who ? t("memory.actions.who." + n.who) : null,
+            n.risk || "R0"
+          ].filter(Boolean).join(" · ");
+          return h("g", {
+            key: n.id,
+            onClick: () => onSelectNode && onSelectNode(n.id),
+            style: { cursor: "pointer" }
+          },
+            h("rect", {
+              className: cls,
+              x: p.x, y: p.y, width: NW, height: NH, rx
+            }),
+            // 风险色条：左缘一条竖线做冗余编码，信息本体在 meta 行的 R 文本里。
+            h("line", {
+              className: "mneme-pipe-risk--" + String(n.risk || "R0").toLowerCase(),
+              x1: p.x + 3, y1: p.y + 8, x2: p.x + 3, y2: p.y + NH - 8,
+              "stroke-width": 3, "stroke-linecap": "round"
+            }),
+            // 闸门角标：gate 步会「停下等批准」，与反事实圈同列放右上、圈在其上方——
+            // 左上角压 risk 色条（真机截图验出的布局冲突）。
+            gate ? h("text", {
+              className: "mneme-pipe-gatetag",
+              x: p.x + NW - 12, y: p.y + 24, textAnchor: "middle"
+            }, t("memory.actions.gate.tag")) : null,
+            // 反事实标记：空心圈 = 还没闸门（counterfactual 为 null），
+            // 实心圈 = 有对照证据。做在右上角，一眼区分。
+            h("circle", {
+              cx: p.x + NW - 12, cy: p.y + 11, r: 4,
+              fill: n.counterfactual ? "var(--mneme-ok)" : "none",
+              stroke: n.counterfactual ? "var(--mneme-ok)" : "var(--mneme-graphic-dim)",
+              "stroke-width": 1.5
+            }, h("title", null, n.counterfactual ? t("memory.actions.gate.has") : t("memory.actions.gate.none"))),
+            lines.length === 1
+              ? h("text", {
+                  className: "mneme-pipe-nodeT",
+                  x: p.x + NW / 2, y: p.y + 24, textAnchor: "middle"
+                }, lines[0])
+              : [
+                  h("text", {
+                    key: "t1", className: "mneme-pipe-nodeT",
+                    x: p.x + NW / 2, y: p.y + 18, textAnchor: "middle"
+                  }, lines[0]),
+                  h("text", {
+                    key: "t2", className: "mneme-pipe-nodeT",
+                    x: p.x + NW / 2, y: p.y + 31, textAnchor: "middle"
+                  }, lines[1])
+                ],
+            h("text", {
+              className: "mneme-pipe-nodeS",
+              x: p.x + NW / 2, y: p.y + 46, textAnchor: "middle"
+            }, meta),
+            h("title", null, n.situation || n.title)
+          );
+        })
+      );
+    }
+
+    // 图例：四个状态一眼分清 + 闸门有无。「被推翻」最扎眼是全篇核心信号。
+    function PipelineLegend(props) {
+      const { t } = props;
+      return h("div", { className: "mneme-pipe-legend" },
+        t("memory.actions.legend.states"),
+        PIPELINE_STATES.map((s) => h("span", { key: s, className: "mneme-pipe-pill mneme-pipe-pill--" + s }, t("memory.actions.state." + s))),
+        h("span", { className: "mneme-pipe-gate", "aria-hidden": "true" }),
+        t("memory.actions.gate.none"),
+        h("span", { className: "mneme-pipe-gate mneme-pipe-gate--has", "aria-hidden": "true" }),
+        t("memory.actions.gate.has")
+      );
+    }
+
+    // 节点详情：情形 / 动作 / 为什么 / 反事实（有无两种形态）/ 复用 / 来源。
+    function PipelineNodeDetail(props) {
+      const { t, node } = props;
+      if (!node) return null;
+      const credit = node.credit || {};
+      const days = pipeDaysAgo(credit.lastUsedAt);
+      const rows = [
+        ["memory.actions.detail.situation", node.situation],
+        ["memory.actions.detail.action", node.action],
+        ["memory.actions.detail.why", node.why]
+      ].filter(([, v]) => v);
+      return h("div", { className: "mneme-pipe-detail", role: "region", "aria-label": node.title },
+        h("div", { className: "mneme-pipe-detailTitle" },
+          h("span", { className: "mneme-pipe-pill mneme-pipe-pill--" + (node.state || "candidate") }, t("memory.actions.state." + (node.state || "candidate"))),
+          " " + node.title
+        ),
+        rows.map(([k, v]) => h("div", { key: k },
+          h("span", { className: "mneme-pipe-dt" }, t(k) + "："), v
+        )),
+        node.counterfactual
+          ? h("div", { className: "mneme-pipe-cf" },
+              h("span", { className: "mneme-pipe-dt" }, t("memory.actions.detail.cf") + "："),
+              node.counterfactual.contrast || "")
+          : h("div", { className: "mneme-pipe-cf mneme-pipe-cf--none" }, t("memory.actions.detail.noCf")),
+        h("div", null,
+          h("span", { className: "mneme-pipe-dt" }, t("memory.actions.credit") + "："),
+          t("memory.actions.creditValue")
+            .replace("{n}", String(credit.uses != null ? credit.uses : 0))
+            .replace("{d}", days == null ? "—" : String(days))
+        ),
+        node.source && (node.source.memoryIds || []).length
+          ? h("div", null,
+              h("span", { className: "mneme-pipe-dt" }, t("memory.actions.detail.source") + "："),
+              (node.source.memoryIds || []).join("、"))
+          : null
+      );
+    }
+
+    // 窄态（浮层 / better-sidebar ~500px）：竖排列表——换布局，不是缩放。
+    // 边收成左侧轨道线 + 「依赖」芯片；details 手风琴承载详情。
+    function PipelineList(props) {
+      const { t, data, run, selectedNodeId, onSelectNode } = props;
+      const nodes = data.nodes || [];
+      const edges = data.edges || [];
+      const usedSet = {};
+      if (run && Array.isArray(run.usedNodeIds)) for (const id of run.usedNodeIds) usedSet[id] = true;
+      const onPath = {};
+      if (run && Array.isArray(run.path)) for (const id of run.path) onPath[id] = true;
+      const deps = {};
+      for (const e of edges) (deps[e.to] = deps[e.to] || []).push(e.from);
+      const { layers } = layoutDag(nodes, edges);
+      const flat = [];
+      layers.forEach((col) => col.forEach((id) => {
+        const n = nodes.find((x) => x.id === id);
+        if (n) flat.push(n);
+      }));
+      return h("div", { className: "mneme-pipe-list" },
+        flat.map((n) => h("details", {
+          key: n.id,
+          className: "mneme-pipe-item",
+          open: selectedNodeId === n.id || undefined,
+          onToggle: (ev) => { if (ev.target && ev.target.open) onSelectNode && onSelectNode(n.id); }
+        },
+          h("summary", null,
+            h("span", {
+              className: "mneme-pipe-itemDot mneme-pipe-itemDot--" + (n.state || "candidate") +
+                (onPath[n.id] ? " mneme-pipe-itemDot--onpath" : ""),
+              "aria-hidden": "true"
+            }),
+            h("span", { className: "mneme-pipe-itemName" + (n.state === "refuted" ? " mneme-pipe-itemName--refuted" : "") }, n.title),
+            h("span", { className: "mneme-pipe-itemMeta" },
+              h("span", { className: "mneme-pipe-pill mneme-pipe-pill--" + (n.state || "candidate") }, t("memory.actions.state." + (n.state || "candidate"))),
+              (deps[n.id] || []).length ? h("span", { className: "mneme-pipe-dep" }, t("memory.actions.dep") + " " + deps[n.id].join(" ")) : null,
+              n.counterfactual ? null : h("span", { className: "mneme-pipe-dep" }, t("memory.actions.gate.none"))
+            )
+          ),
+          h("div", { className: "mneme-pipe-itemBody" },
+            n.situation ? h("div", null, h("span", { className: "mneme-pipe-dt" }, t("memory.actions.detail.situation") + "："), n.situation) : null,
+            n.action ? h("div", null, h("span", { className: "mneme-pipe-dt" }, t("memory.actions.detail.action") + "："), n.action) : null,
+            n.why ? h("div", null, h("span", { className: "mneme-pipe-dt" }, t("memory.actions.detail.why") + "："), n.why) : null,
+            n.counterfactual
+              ? h("div", { className: "mneme-pipe-cf" }, h("span", { className: "mneme-pipe-dt" }, t("memory.actions.detail.cf") + "："), n.counterfactual.contrast || "")
+              : h("div", { className: "mneme-pipe-cf mneme-pipe-cf--none" }, t("memory.actions.detail.noCf"))
+          )
+        ))
+      );
+    }
+
+    // 条目清单（名字 + 规模 + 作用域）：图上方的**选择器**。
+    // 它解决的是「这是哪条工作流」——一进来就是一张图时这个问题没有落点，多条之间也没得选。
+    // 但它不占整屏：图和它同屏，见下面的 PipelineBrowser。
+    function PipelineWorkflowList(props) {
+      const { t, data, activeId, onOpen } = props;
+      const list = (data && data.available) || [];
+      const scopeOf = (row) => (row.scope === "global"
+        ? t("memory.actions.scope.global")
+        : t("memory.actions.scope.project").replace("{name}", row.scopeLabel || row.scope));
+      return h("div", { className: "mneme-pipe-wflist" },
+        h("div", { className: "mneme-pipe-wfhead" },
+          h("span", null, t("memory.actions.list.heading")),
+          h("span", null, t("memory.actions.list.count").replace("{n}", String(list.length)))
+        ),
+        list.length
+          ? list.map((row) => h("button", {
+              key: row.id,
+              type: "button",
+              className: "mneme-pipe-wf" + (row.id === activeId ? " mneme-on" : ""),
+              "aria-current": row.id === activeId ? "true" : undefined,
+              onClick: () => onOpen(row.id)
+            },
+              h("span", { className: "mneme-pipe-wfTop" },
+                h("span", { className: "mneme-pipe-wfName" }, row.title || row.id),
+                h("span", { className: "mneme-pipe-wfScope" }, scopeOf(row))
+              ),
+              h("span", { className: "mneme-pipe-wfMeta" }, t("memory.actions.list.meta")
+                .replace("{steps}", String(row.steps || 0))
+                .replace("{gates}", String(row.gates || 0))
+                .replace("{cf}", String(row.contrast || 0))),
+              h("span", { className: "mneme-pipe-wfId" }, row.id)
+            ))
+          // 「读得出来但一份都没有」与「读不出来」是两回事，别画成同一张脸：
+          // 前者要告诉人文件该放哪，后者只有 loadPipeline 返回 null 时才是。
+          : h("div", { className: "mneme-pipe-empty" },
+              h("div", { className: "mneme-pipe-emptyTitle" }, t("memory.actions.empty.title")),
+              t("memory.actions.empty.body")
+            ),
+        data && data.unreadable && data.unreadable.length
+          ? h("div", { className: "mneme-pipe-broken" },
+              t("memory.actions.broken") + " " + data.unreadable.map((u) => u.detail || u.dir).join("；"))
+          : null
+      );
+    }
+
+    // 清单与图**同屏**：上面清单（选择器），下面画布（主语），默认展开第一条。
+    // 形状换过两次，两次的教训都留在这里，免得再翻回去：
+    //   一进来就是图 —— 没有名字、没有落点，用户要的是「像 Hermes 那样一串条目」；
+    //   清单 ⟷ 图两屏来回切 —— 条目有了，但画布藏在一次点击后面、界面上没有任何提示，
+    //   反馈连着两次说「看不到画布和节点」。
+    // 两个 usePipeline 都是无条件调用：hook 不能条件调用，而「默认选第一条」这件事
+    // 恰好可以放在两个读取之间，不必为此拆组件。
+    function PipelineBrowser(props) {
+      const { t, project } = props;
+      const [picked, setPicked] = useState(null);
+      const listDoc = usePipeline(project, null);
+      const rows = (listDoc && listDoc.available) || [];
+      // 没手选过就跟第一条；手选之后清单再刷新也不跳回去（否则一刷新就把人的选择抹掉）。
+      const activeId = picked || (rows.length ? rows[0].id : null);
+      const detailDoc = usePipeline(project, activeId);
+      return h("div", {
+        className: "mneme-pipe",
+        style: { height: "100%", display: "flex", flexDirection: "column", minHeight: "0" }
+      },
+        h(PipelineWorkflowList, { t, data: listDoc, activeId, onOpen: setPicked }),
+        h(PipelineView, { t, data: detailDoc })
+      );
+    }
+
+    // 画布缩放。为什么要有：重排前 19 步是一条 18 层竖链（固有 354×1902），被 width:100%
+    // 拉到栏宽之后高度上万——只能上下滚；重排成阶段带后（固有 354×836）仍有
+    // 「凑近看某一段」的需求。按钮管精确、滚轮管顺手。
+    const PIPELINE_ZOOM_MIN = 0.3;
+    const PIPELINE_ZOOM_MAX = 4;
+    const clampZoom = (z) => Math.min(PIPELINE_ZOOM_MAX, Math.max(PIPELINE_ZOOM_MIN, z));
+
+    function PipelineZoomBar(props) {
+      const { t, zoom, onZoom } = props;
+      return h("div", { className: "mneme-pipe-zoombar" },
+        h("button", {
+          type: "button", className: "mneme-pipe-zoombtn",
+          title: t("memory.actions.zoom.out"), "aria-label": t("memory.actions.zoom.out"),
+          onClick: () => onZoom(zoom / 1.25)
+        }, "−"),
+        h("span", { className: "mneme-pipe-zoomval" },
+          t("memory.actions.zoom.value").replace("{n}", String(Math.round(zoom * 100)))),
+        h("button", {
+          type: "button", className: "mneme-pipe-zoombtn",
+          title: t("memory.actions.zoom.in"), "aria-label": t("memory.actions.zoom.in"),
+          onClick: () => onZoom(zoom * 1.25)
+        }, "+"),
+        h("button", {
+          type: "button", className: "mneme-pipe-zoombtn",
+          title: t("memory.actions.zoom.hint"),
+          onClick: () => onZoom(1)
+        }, t("memory.actions.zoom.fit"))
+      );
+    }
+
+    // 主视图：宽态 SVG 图 ↔ 窄态列表按容器宽切换（640px 阈值，ResizeObserver）。
+    // 根挂 .mneme-pipeview 拿语义色变量层。
+    function PipelineView(props) {
+      const { t, data } = props;
+      const nodes = (data && data.nodes) || [];
+      const runs = (data && data.runs) || [];
+      const [selectedRunId, setSelectedRunId] = react.useState(runs.length ? runs[0].id : null);
+      const [selectedNodeId, setSelectedNodeId] = react.useState(null);
+      const rootRef = react.useRef(null);
+      const graphRef = react.useRef(null);
+      const [narrow, setNarrow] = react.useState(false);
+      const [zoom, setZoom] = react.useState(1);
+      react.useEffect(() => {
+        const el = rootRef.current;
+        if (!el || typeof ResizeObserver !== "function") return;
+        const ro = new ResizeObserver((entries) => {
+          const w = entries && entries[0] ? entries[0].contentRect.width : 0;
+          // 阈值从 640 降到 320：竖链与阶段带的固有宽度都是 354px——栏窄一点反而更该画图。
+          // 640 那档是按当年那张摊得很开的假数据定的，真数据下它只会把右栏（通常 400~600px）
+          // 全部推给「一列节点卡片」那一支，于是「看不到图谱」。
+          setNarrow(w > 0 && w < 320);
+        });
+        ro.observe(el);
+        return () => ro.disconnect();
+      }, []);
+      // 滚轮缩放必须**自己挂非被动监听**：React 的 onWheel 是挂在 root 上的被动监听，
+      // preventDefault 会被浏览器忽略（控制台里那句 "Unable to preventDefault inside passive
+      // event listener"），结果是 Ctrl+滚轮既缩放画布、又缩放整页，谁也没拦住。
+      // 只认 Ctrl/⌘：普通滚轮仍旧是滚动画布——劫持它会让人滚不到下面的图例。
+      react.useEffect(() => {
+        const el = graphRef.current;
+        if (!el || typeof el.addEventListener !== "function") return undefined;
+        const onWheel = (ev) => {
+          if (!ev.ctrlKey && !ev.metaKey) return;
+          ev.preventDefault();
+          setZoom((z) => clampZoom(z * (ev.deltaY < 0 ? 1.15 : 1 / 1.15)));
+        };
+        el.addEventListener("wheel", onWheel, { passive: false });
+        return () => el.removeEventListener("wheel", onWheel);
+      }, [narrow]);
+
+      const run = runs.find((r) => r.id === selectedRunId) || null;
+      const selectedNode = selectedNodeId ? nodes.find((n) => n.id === selectedNodeId) : null;
+      if (!nodes.length) {
+        return h("div", { className: "mneme-pipeview" },
+          h("div", { className: "mneme-pipe-empty" },
+            h("div", { className: "mneme-pipe-emptyTitle" }, t("memory.actions.empty.title")),
+            t("memory.actions.empty.body")
+          ),
+          h("div", { className: "mneme-pipe-notice" }, t("memory.actions.notice"))
+        );
+      }
+      return h("div", { className: "mneme-pipeview", ref: rootRef, style: { display: "flex", flexDirection: "column", flex: "1", minHeight: "0" } },
+        h(PipelineRunChips, { t, runs, selectedRunId, onSelectRun: setSelectedRunId }),
+        // 流程概览带：投影里 pipeline.done / trigger 此前一个都没渲染——第一屏
+        // 说不出「这条流程要达成什么、什么时候起跑」。放画布上方、做成 HTML
+        // 块而非 SVG 文本：125 字的完成判据要能换行。数据由投影保证存在。
+        (data && data.pipeline) ? h("div", { className: "mneme-pipe-overview" },
+          h("div", null,
+            h("span", { className: "mneme-pipe-dt" }, t("memory.actions.ov.done") + "："),
+            data.pipeline.done
+          ),
+          h("div", null,
+            h("span", { className: "mneme-pipe-dt" }, t("memory.actions.ov.trigger") + "："),
+            (data.pipeline.trigger || []).map((x) => x && x.value).filter(Boolean).join("、") || null
+          )
+        ) : null,
+        // 一条运行记录都没有 = 全部候选。这句话得说出来：卡片上「候选」两个字本身
+        // 不解释任何东西，而用户在这一屏最容易问的就是「为什么全是候选」。
+        runs.length ? null : h("div", { className: "mneme-hint" }, t("memory.actions.noRuns")),
+        // 缩放条放在分支**外面**：不论宽窄都在，既是控制，也是「新代码到没到」的肉眼标记。
+        h(PipelineZoomBar, { t, zoom, onZoom: (z) => setZoom(clampZoom(z)) }),
+        narrow
+          ? h(PipelineList, { t, data, run, selectedNodeId, onSelectNode: setSelectedNodeId })
+          : h("div", { className: "mneme-pipe-graph", ref: graphRef },
+              // 宽度用百分比而不是 transform：百分比改的是**布局尺寸**，容器照常出滚动条，
+              // 于是顺带就有了平移；transform 只改绘制，放大出去的那一半永远滚不到。
+              h("div", { className: "mneme-pipe-zoomwrap", style: { width: (zoom * 100) + "%" } },
+                h(PipelineGraphSvg, { t, data, run, selectedNodeId, onSelectNode: setSelectedNodeId })
+              )
+            ),
+        h(PipelineLegend, { t }),
+        selectedNode ? h(PipelineNodeDetail, { t, node: selectedNode }) : null,
+        h("div", { className: "mneme-pipe-notice" }, t("memory.actions.notice"))
+      );
+    }
+
+    // 右栏 tab 的正文。单独包一层组件、而不是把 hook 塞进 slots.register 的回调里：
+    // 那个回调是不是当组件渲染由宿主决定，hook 放在名字明确的组件里才不必赌这件事。
+    function PipelinePane(props) {
+      const { t, project } = props;
+      return h(PipelineBrowser, { t, project });
+    }
+
+    // 流水线标记：两个步骤块 + 依赖连线 + 状态点；开合状态用右上角
+    // 实心/空心点区分（会话头图标要反映浮层开合）。
+    function PipelineMark(props) {
+      const { size = 16, open } = props || {};
+      return h("svg", { width: size, height: size, viewBox: "0 0 16 16", "aria-hidden": "true", focusable: "false" },
+        h("path", { d: "M2.5 3h4.2v4.2H2.5z M9.3 8.8h4.2V13H9.3z", fill: "none", stroke: "currentColor", "stroke-width": 1.4 }),
+        h("path", { d: "M6.7 5.1h4v3.7", fill: "none", stroke: "currentColor", "stroke-width": 1.2 }),
+        h("circle", {
+          cx: 13.2, cy: 2.8, r: 1.9,
+          fill: open ? "currentColor" : "none",
+          stroke: "currentColor", "stroke-width": 1.2
+        })
+      );
+    }
+
+    // 会话头入口：悬停 150ms 开 / 移开 120ms 关 / 点击固定 / Escape 关 /
+    // 点击外部关（交互规格与 Agent Teams 浮层一致）。浮层锚 trigger、
+    // portal 到 body。老宿主没有右栏服务时补一个「完整视图」按钮退回
+    // 居中 sheet（形态沿用记忆库 overlay 的背板 + 居中面板）。
+    function PipelineHeaderEntry(props) {
+      const { t, hasPane, openPane, project } = props;
+      const [open, setOpen] = useState(false);
+      const [sheetOpen, setSheetOpen] = useState(false);
+      const openRef = useRef(false);
+      const pinnedRef = useRef(false);
+      const hoverTimer = useRef(null);
+      const rootRef = useRef(null);
+      const anchorRef = useRef(null);
+      const panelRef = useRef(null);
+      const labelRef = useRef(null);
+      const sheetRef = useRef(null);
+
+      const changeOpen = (next) => {
+        const was = openRef.current;
+        const wasPinned = pinnedRef.current;
+        openRef.current = next;
+        setOpen(next);
+        if (!next) pinnedRef.current = false;
+        // announce 只挂「用户明确动作」的开合（点击固定 / Esc / 点外关）；
+        // 悬停开合是瞬态，播报反而刷屏——与 §5 无障碍约束对齐。
+        if (next && !was && wasPinned) announce(t("memory.actions.announce.open"));
+        if (!next && was && wasPinned) announce(t("memory.actions.announce.close"));
+      };
+      const cancelHoverChange = () => {
+        if (hoverTimer.current) { clearTimeout(hoverTimer.current); hoverTimer.current = null; }
+      };
+      const scheduleHoverOpen = () => {
+        if (pinnedRef.current || openRef.current) return;
+        // 窄容器下文字标签被 @container 隐藏（图标态）→ 不弹浮层，点击才开。
+        if (labelRef.current && labelRef.current.offsetWidth === 0) return;
+        cancelHoverChange();
+        hoverTimer.current = setTimeout(() => {
+          hoverTimer.current = null;
+          openRef.current = true;
+          setOpen(true);
+        }, 150);
+      };
+      const scheduleHoverClose = () => {
+        if (pinnedRef.current) return;
+        cancelHoverChange();
+        hoverTimer.current = setTimeout(() => {
+          hoverTimer.current = null;
+          openRef.current = false;
+          setOpen(false);
+        }, 120);
+      };
+
+      // 钩子顺序稳定：useAnchoredPosition 的存在性是模块常量条件，两次
+      // 判断在所有渲染中走同一分支，不违反 hook 规则。
+      const positioned = primitives && typeof primitives.useAnchoredPosition === "function"
+        ? primitives.useAnchoredPosition({ open, anchorRef, panelRef, gap: 5, margin: 16 })
+        : null;
+      const panelStyle = positioned
+        ? { ...positioned }
+        : { position: "fixed", left: 0, top: 0, visibility: "hidden" };
+
+      if (primitives && typeof primitives.useDismissOnOutsidePointer === "function") {
+        primitives.useDismissOnOutsidePointer(rootRef, open, changeOpen, panelRef);
+      }
+      useEffect(() => {
+        if (primitives && typeof primitives.useDismissOnOutsidePointer === "function") return;
+        if (!open) return;
+        const onDown = (ev) => {
+          const panel = panelRef.current;
+          const root = rootRef.current;
+          if (panel && panel.contains(ev.target)) return;
+          if (root && root.contains(ev.target)) return;
+          changeOpen(false);
+        };
+        document.addEventListener("pointerdown", onDown, true);
+        return () => document.removeEventListener("pointerdown", onDown, true);
+      }, [open]);
+      useEffect(() => () => cancelHoverChange(), []);
+
+      // 居中 sheet 是「宿主没有右栏服务」时的唯一完整入口，键盘用户必须能进能出。
+      // 它 portal 到 body，焦点默认留在原 trigger 上，而挂在 sheet 元素上的
+      // onKeyDown 既因没有 tabIndex 不被聚焦、也收不到外部键盘事件——Escape 于是
+      // 不生效，只剩 Tab 摸到关闭按钮一条路。做法与 MemoryOverlay 一致：打开时把
+      // 焦点移进 sheet，Escape 在 window 上收，关掉再把焦点还给 trigger。
+      useEffect(() => {
+        if (!sheetOpen) return undefined;
+        if (sheetRef.current) sheetRef.current.focus();
+        const onKey = (ev) => {
+          if (ev.key !== "Escape") return;
+          ev.preventDefault();
+          ev.stopPropagation();
+          setSheetOpen(false);
+          if (anchorRef.current) anchorRef.current.focus();
+        };
+        window.addEventListener("keydown", onKey);
+        return () => window.removeEventListener("keydown", onKey);
+      }, [sheetOpen]);
+
+      const closeAll = () => {
+        changeOpen(false);
+        if (anchorRef.current) anchorRef.current.focus();
+      };
+      const onTriggerClick = () => {
+        if (!openRef.current) {
+          pinnedRef.current = true;
+          changeOpen(true);
+          setTimeout(() => { if (panelRef.current) panelRef.current.focus(); }, 0);
+        } else if (pinnedRef.current) {
+          changeOpen(false);
+        } else {
+          pinnedRef.current = true;
+          if (panelRef.current) panelRef.current.focus();
+        }
+      };
+      const doc = usePipeline(project, null);
+      // 头部这一格标的是**这份清单读的是哪个项目**（某条工作流归谁，标在清单每一行上）：
+      // 只取目录名，绝对路径不上界面——面板是会被截图的那一面。认不出项目时如实说，
+      // 而不是编一个「全局」顶上：认不出和全局是两件事。
+      const projectSource = ((doc && doc.sources) || []).find((s) => s.scope === "project");
+      const scopeLabel = projectSource && projectSource.label
+        ? t("memory.actions.scope.project").replace("{name}", projectSource.label)
+        : t("memory.actions.scope.none");
+      // 数的是这个项目里读出几条工作流；没拿到数据时是 0，不是随便挑一个数。
+      const workflowCount = doc && doc.available ? doc.available.length : 0;
+
+      const panel = (open && reactDom && typeof document !== "undefined")
+        ? reactDom.createPortal(
+            h("div", {
+              ref: panelRef,
+              // 注意：client.test.js 锁死全文件不得出现 role:"dialog"
+              // （v0.7.15 清退 dialog 面的纪律），浮层只带 aria-label。
+              "aria-label": t("memory.actions.title"),
+              tabIndex: -1,
+              className: "mneme-pipe mneme-pipe-panel",
+              style: panelStyle,
+              onMouseEnter: cancelHoverChange,
+              onMouseLeave: scheduleHoverClose,
+              onKeyDown: (ev) => { if (ev.key === "Escape") { ev.preventDefault(); ev.stopPropagation(); closeAll(); } }
+            },
+              h("div", { className: "mneme-pipe-head" },
+                h("span", { className: "mneme-pipe-title" }, t("memory.actions.title")),
+                h("span", { className: "mneme-pipe-beta" }, t("memory.actions.beta")),
+                h("span", { className: "mneme-pipe-scope" }, scopeLabel),
+                h("button", {
+                  type: "button",
+                  className: "mneme-pipe-run",
+                  // 有右栏服务：openTab(kind) 打开原生右栏 tab（页面类型无
+                  // patterns，按 kind 打开）并收起浮层；打不开或老宿主
+                  // （无 sidebarRight）退回本插件的居中 sheet——形态沿用
+                  // 记忆库 overlay 的背板 + 居中面板。
+                  onClick: () => {
+                    if (openPane && openPane()) { changeOpen(false); return; }
+                    changeOpen(false);
+                    setSheetOpen(true);
+                  }
+                }, hasPane && openPane ? t("memory.actions.openPane") : t("memory.actions.viewFull"))
+              ),
+              h("div", { className: "mneme-pipe-notice" }, t("memory.actions.notice")),
+              h(PipelineBrowser, { t, project })
+            ),
+            document.body
+          )
+        : null;
+
+      const sheet = (sheetOpen && reactDom && typeof document !== "undefined")
+        ? reactDom.createPortal(
+            h("div", {
+              className: "mneme-backdrop",
+              onClick: (ev) => { if (ev.target === ev.currentTarget) setSheetOpen(false); }
+            },
+              h("div", {
+                ref: sheetRef,
+                tabIndex: -1,
+                className: "mneme-pipe mneme-pipe-sheet",
+                "aria-label": t("memory.actions.title"),
+                onKeyDown: (ev) => { if (ev.key === "Escape") { ev.stopPropagation(); setSheetOpen(false); } }
+              },
+                h("div", { className: "mneme-pipe-sheetbar" },
+                  h("span", { className: "mneme-pipe-title" }, t("memory.actions.title")),
+                  h("span", { className: "mneme-pipe-beta" }, t("memory.actions.beta")),
+                  h("span", { className: "mneme-pipe-scope" }, scopeLabel),
+                  h("button", { type: "button", className: "mneme-pipe-run", onClick: () => setSheetOpen(false) }, t("memory.actions.close"))
+                ),
+                h("div", { className: "mneme-pipe-sheetbody" }, h(PipelineBrowser, { t, project }))
+              )
+            ),
+            document.body
+          )
+        : null;
+
+      return h("div", {
+        className: "mneme-pipe-root",
+        ref: rootRef,
+        onMouseEnter: scheduleHoverOpen,
+        onMouseLeave: scheduleHoverClose
+      },
+        h("button", {
+          type: "button",
+          ref: anchorRef,
+          className: "mneme-pipe-trigger",
+          "aria-haspopup": "true",
+          "aria-expanded": open ? "true" : "false",
+          title: t("memory.actions.open"),
+          onClick: onTriggerClick,
+          onKeyDown: (ev) => { if (ev.key === "Escape" && open) { ev.preventDefault(); ev.stopPropagation(); closeAll(); } }
+        },
+          h(PipelineMark, { open }),
+          h("span", { ref: labelRef, className: "mneme-pipe-triggerLabel" }, t("memory.actions.title")),
+          workflowCount > 0 ? h("span", {
+            className: "mneme-pipe-dot",
+            title: t("memory.actions.list.count").replace("{n}", String(workflowCount))
+          }, String(workflowCount)) : null
+        ),
+        panel,
+        sheet
+      );
+    }
+
+    // 对话行结算卡（turnTail）：死的落款——「这次跑哪条被用上了」。
+    // 与会话头浮层读同一份数据；卡上勾选 = usedNodeIds（真正被复用），
+    // 其余 path 节点只是被走过。没有运行记录时整张卡不出现——发一条「本次没用上任何
+    // 做法」的空卡比不发更吵：它每一轮都会来一次。
+    function TurnRunCard(props) {
+      const { t, project } = props;
+      const doc = usePipeline(project, null);
+      const data = doc || {};
+      const run = (data.runs || []).find((r) => r.id === "r1") || (data.runs || [])[0];
+      if (!run) return null;
+      const used = run.usedNodeIds || [];
+      const refutedUsed = used.some((id) => {
+        const n = (data.nodes || []).find((x) => x.id === id);
+        return n && n.state === "refuted";
+      });
+      return h("div", { className: "mneme-pipe mneme-pipe-settle" },
+        h("div", { className: "mneme-pipe-settleHead" },
+          h("span", { className: "mneme-pipe-settleTitle" },
+            h(PipelineMark, { size: 13 }),
+            t("memory.actions.settle.title")
+          ),
+          h("span", { className: "mneme-pipe-beta" }, t("memory.actions.beta")),
+          h("span", { className: "mneme-pipe-scope" },
+            t("memory.actions.settle.line").replace("{title}", data.pipeline.title) + " · " + pipeFmtWhen(run.at))
+        ),
+        h("div", { className: "mneme-pipe-steps" },
+          (run.path || []).map((id, i) => {
+            const n = (data.nodes || []).find((x) => x.id === id);
+            if (!n) return null;
+            const isUsed = used.includes(id);
+            return h(react.Fragment, { key: id + ":" + i },
+              i > 0 ? h("span", { className: "mneme-pipe-stepArrow", "aria-hidden": "true" }, "→") : null,
+              h("span", {
+                className: "mneme-pipe-stepChip" + (isUsed ? " mneme-pipe-stepChip--used" : ""),
+                title: n.title
+              },
+                (isUsed ? "✓ " : "") + pipeClip(n.title, 12)
+              )
+            );
+          })
+        ),
+        h("div", { className: "mneme-pipe-scope" },
+          t("memory.actions.settle.used").replace("{n}", String(used.length))
+        ),
+        refutedUsed ? h("div", { className: "mneme-pipe-scope" }, t("memory.actions.settle.refutedWarn")) : null
+      );
+    }
+
+    // 座位注册（仅在旗标开启后被调用）：会话头入口、对话行结算卡、
+    // 右栏类型与正文。⚠️ 服务名 sidebarRight 与注册服务名 sidebarRightTabs
+    // 是两个不同的名字——类型/引导挂 sidebarRightTabs，打开走
+    // ctx.get("sidebarRight").openTab。无右栏服务时不注册 pane（浮层 +
+    // 居中 sheet 退化已在 PipelineHeaderEntry 内）。
+    function registerPipelineSeats(ctx, t) {
+      let hasPane = false;
+      try {
+        const sb = typeof ctx.get === "function" ? ctx.get("sidebarRight") : null;
+        hasPane = !!(sb && typeof sb.openTab === "function");
+      } catch { hasPane = false; }
+      // 右栏打开：页面类型（无 patterns）按 kind 打开——openTab(kind)。
+      // 服务半可用 / kind 未注册抛错时返回 false，调用方退化到居中 sheet。
+      const openPane = () => {
+        try {
+          const sb = typeof ctx.get === "function" ? ctx.get("sidebarRight") : null;
+          if (sb && typeof sb.openTab === "function") {
+            sb.openTab(PIPELINE_ACTIONS_TAB_KIND);
+            return true;
+          }
+        } catch (err) {
+          console.warn("[dsh-mneme] sidebarRight.openTab failed, falling back to sheet:", err);
+        }
+        return false;
+      };
+
+      // 会话头入口：.actions 座位（.corner 被原生侧栏展开键占用，别用）。
+      // 会话工作目录只有客户端拿得到，而「当前是哪个会话」只在座位注入里给——所以
+      // 每个座位都要 inject: (sessionId) => ({ sessionId })，否则读到的永远是全局层。
+      // 宿主若不吃这个选项，project 就是 null，面板如实说「项目未知」，不假装成功。
+      ctx.slots.inject("conversation.session.header.actions", () => {
+        return ctx.slots.register({
+          name: "conversation.session.header.actions",
+          id: "dsh-mneme:pipeline",
+          order: 30,
+          inject: (sessionId) => ({ sessionId })
+        }, (props) => h(PipelineHeaderEntry, {
+          t, hasPane, openPane, project: sessionProject(ctx, props && props.sessionId)
+        }));
+      });
+
+      // 对话行结算卡：回答「这次跑哪条被用上了」。
+      ctx.slots.inject("conversation.chat.turnTail", () => {
+        return ctx.slots.register({
+          name: "conversation.chat.turnTail",
+          id: "dsh-mneme:pipeline:settle",
+          // kind/scope 是**声明方**（宿主）在 children 上写的，注册方不重复声明——
+          // 座位本身已经声明成 { kind: "list", scope: "session" }，多写一份只是噪音，
+          // 万一注册侧按 schema 严校就是一次启动期抛错。
+          inject: (sessionId) => ({ sessionId })
+        }, (props) => h(TurnRunCard, { t, project: sessionProject(ctx, props && props.sessionId) }));
+      });
+
+      // tab 的**类型**与它的**正文**必须各自兜自己的异常，而且类型注册要幂等。
+      // 为什么：宿主对重复的类型 id 会抛（`sidebarRight: tab type id "…" is already registered`），
+      // 而这两件事的生命周期不一样——类型注册挂在宿主服务 `sidebarRightTabs` 上、插件重挂（刷新 /
+      // 热重载 / 会话重建）时**留着**；正文座位是挂插件 scope 的，会随插件回收、重挂时要重来。
+      // 原来两件事写在同一个 try 里，于是第二次挂载时类型那一抛就把正文一起带走了：界面上
+      // 只剩宿主的 fallback「这类内容还没有可用的查看方式」，而错误只落在浏览器控制台里
+      // ——看不见、也搜不到，是最费时间的一类。
+      try {
+        const tabs = typeof ctx.get === "function" ? ctx.get("sidebarRightTabs") : null;
+        if (tabs && typeof tabs.register === "function") {
+          const already = typeof tabs.get === "function" ? tabs.get(PIPELINE_ACTIONS_TAB_ID) : null;
+          if (!already) {
+            tabs.register({
+              id: PIPELINE_ACTIONS_TAB_ID,
+              kind: PIPELINE_ACTIONS_TAB_KIND,
+              title: () => t("memory.actions.title"),
+              guide: [{
+                id: "dsh-mneme:pipeline:guide",
+                order: 10,
+                title: () => t("memory.actions.title"),
+                description: () => t("memory.actions.notice"),
+                icon: (size) => h(PipelineMark, { size, open: false })
+              }]
+            });
+          }
+        }
+      } catch (err) {
+        console.warn("[dsh-mneme] action pipeline tab type registration failed:", err);
+      }
+
+      try {
+        const tabs = typeof ctx.get === "function" ? ctx.get("sidebarRightTabs") : null;
+        if (tabs && typeof tabs.register === "function") {
+          // 正文/标题都是按键座位：key = 类型 id，宿主按当前 tab 取。
+          ctx.slots.inject("sidebar.right.pane.tab", () => {
+            return ctx.slots.register({
+              name: "sidebar.right.pane.tab",
+              key: PIPELINE_ACTIONS_TAB_ID,
+              inject: (sessionId) => ({ sessionId })
+            }, (props) => h(PipelinePane, { t, project: sessionProject(ctx, props && props.sessionId) }));
+          });
+          ctx.slots.inject("sidebar.right.pane.tab.title", () => {
+            return ctx.slots.register({
+              name: "sidebar.right.pane.tab.title",
+              key: PIPELINE_ACTIONS_TAB_ID
+            }, () => t("memory.actions.title"));
+          });
+        }
+      } catch (err) {
+        console.warn("[dsh-mneme] action pipeline pane body registration failed:", err);
+      }
+
+      if (!hasPane) {
+        console.info("[dsh-mneme] action pipeline: no sidebarRight service, pane tab skipped (floating panel + sheet fallback active)");
+      }
+    }
+
     function apply(ctx) {
       const t = ctx.locale.bind(NS);
       ctx.effect(() => ctx.locale.register(NS, dictionaries), "dsh-mneme: dictionaries");
@@ -5436,10 +7846,30 @@ window.__ModuleLoader__.load({
         }
         return () => { dead = true; };
       }, "dsh-mneme: better-sidebar mount");
+
+      // --- v0.9.0 M.O.（beta）：旗标门控 ---
+      // actionPipelineEnabled 关闭（默认）时一个座位都不注册——座位闸门
+      // 在注册层而不是样式层（不是 display:none）。features 拉取失败时
+      // 保持关闭（fail-closed），不猜。
+      ctx.effect(() => {
+        let dead = false;
+        apiFetch("/api/dsh-mneme/features")
+          .then((res) => { if (!res.ok) throw new Error("HTTP " + res.status); return res.json(); })
+          .then((j) => {
+            if (dead) return;
+            const eff = (j && j.effective) || {};
+            if (!eff.actionPipelineEnabled) return;
+            registerPipelineSeats(ctx, t);
+          })
+          .catch((err) => {
+            console.warn("[dsh-mneme] features fetch failed, action pipeline stays off:", err);
+          });
+        return () => { dead = true; };
+      }, "dsh-mneme: action-pipeline gate");
     }
 
     exports.apply = apply;
     exports.inject = inject;
     return module.exports;
   }
-});
+});