@modusensus/dsh-mneme 0.8.16 → 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": "卡片",
@@ -968,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",
@@ -1007,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",
@@ -1096,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",
@@ -1668,6 +1836,11 @@ window.__ModuleLoader__.load({
       ".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}",
@@ -1898,7 +2071,159 @@ window.__ModuleLoader__.load({
       ".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)}"
+      ".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");
@@ -2454,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"] }
     ];
@@ -2468,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"];
@@ -2475,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", {
@@ -2496,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);
@@ -2519,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; };
@@ -2536,6 +2896,7 @@ window.__ModuleLoader__.load({
 
       const eff = (state && state.effective) || {};
 
+      // 返回值 = 这次写入有没有落库。调用方要据此决定草稿的去留。
       const put = async (patch) => {
         setBusy(true);
         try {
@@ -2544,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);
         }
@@ -2558,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}`),
@@ -2575,6 +2978,7 @@ window.__ModuleLoader__.load({
         on: !!eff[k],
         disabled: busy,
         sub: !!opts.sub,
+        tag: flagTag(k),
         onToggle: () => put({ [k]: !eff[k] })
       });
 
@@ -2592,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();
@@ -2620,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) {
@@ -2687,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"))))
@@ -2703,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" },
@@ -2784,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));
@@ -2794,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))
+                )
+              );
+            })()
       );
     }
 
@@ -6274,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");
@@ -6345,6 +7846,26 @@ 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;