@modusensus/dsh-mneme 0.8.16 → 0.9.1

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);
@@ -150,7 +147,11 @@ window.__ModuleLoader__.load({
       flame: [["path", { d: "M8.5 14.5A2.5 2.5 0 0 0 11 12c0-1.38-.5-2-1-3-1.072-2.143-.224-4.054 2-6 .5 2.5 2 4.9 4 6.5 2 1.6 3 3.5 3 5.5a7 7 0 1 1-14 0c0-1.153.433-2.294 1-3a2.5 2.5 0 0 0 2.5 2.5z" }]],
       // 意见与反馈入口的行首图标（Lucide 数据，同上 ISC 惯例内联）
       bug: [["path", { d: "m8 2 1.88 1.88" }], ["path", { d: "M14.12 3.88 16 2" }], ["path", { d: "M9 7.13v-1a3.003 3.003 0 1 1 6 0v1" }], ["path", { d: "M12 20c-3.3 0-6-2.7-6-6v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 4v3c0 3.3-2.7 6-6 6" }], ["path", { d: "M12 20v-9" }], ["path", { d: "M6.53 9C4.6 8.8 3 7.1 3 5" }], ["path", { d: "M6 13H2" }], ["path", { d: "M3 21c0-2.1 1.7-3.9 3.8-4" }], ["path", { d: "M20.97 5c0 2.1-1.6 3.8-3.5 4" }], ["path", { d: "M22 13h-4" }], ["path", { d: "M17.2 17c2.1.1 3.8 1.9 3.8 4" }]],
-      mail: [["rect", { width: "20", height: "16", x: "2", y: "4", rx: "2" }], ["path", { d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" }]]
+      mail: [["rect", { width: "20", height: "16", x: "2", y: "4", rx: "2" }], ["path", { d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7" }]],
+      // star 是设置页鼓励入口的行首图标（Lucide 数据，同上 ISC 惯例内联）。
+      // Icon 对未注册的名字静默 return null——漏了它就是一行缺图标、闸门全绿，
+      // 所以这条表与用法必须同处出现（见 test/client.test.js 的图标名锁）。
+      star: [["polygon", { points: "12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2" }]]
     };
     const Icon = ({ name, size = 16, className }) => {
       const parts = ICON_PATHS[name];
@@ -280,6 +281,31 @@ window.__ModuleLoader__.load({
         "memory.settings.profileHint": "写一段自我介绍（角色、背景、偏好），Agent 每轮对话都会自动带上。",
         "memory.settings.profileSave": "保存画像",
         "memory.settings.profileSaved": "画像已保存",
+        "memory.settings.persona": "人格定义（beta）",
+        "memory.settings.personaHint": "给这位 Agent 一张角色卡：名字、性格、回复要求。开关打开且下方「人格定义」总闸开启时，每轮对话都会注入。",
+        "memory.settings.personaName": "名字",
+        "memory.settings.personaNamePlaceholder": "例如：Nyx",
+        "memory.settings.personaPersonality": "性格设定",
+        "memory.settings.personaPersonalityPlaceholder": "例如：轻松幽默，讲难题时用类比帮用户快速理解",
+        "memory.settings.personaReplyStyle": "回复要求",
+        "memory.settings.personaReplyStylePlaceholder": "例如：先给结论再解释；用人在用的词，不用机制名",
+        "memory.settings.personaSave": "保存人格",
+        "memory.settings.personaSaved": "人格已保存",
+        "memory.settings.personaSaveFailed": "保存失败",
+        "memory.settings.personaEnabledToggle": "启用这张卡",
+        "memory.settings.personaEnabledOn": "已启用——身份命中的会话会注入这张卡",
+        "memory.settings.personaEnabledOff": "未启用——这个身份的会话将使用默认卡",
+        "memory.settings.personaDefaultCard": "默认卡（兜底）",
+        "memory.settings.personaAdd": "添加卡",
+        "memory.settings.personaAddPlaceholder": "输入 agent 身份名（如 nyx），按它寻址注入",
+        "memory.settings.personaEditingDefault": "正在编辑：默认卡——没有命中任何身份卡的会话用它",
+        "memory.settings.personaEditingFor": "正在编辑身份卡：",
+        "memory.settings.personaDeleteCard": "删除这张卡",
+        "memory.settings.personaView": "Agent 眼中的你（注入生效文本）",
+        "memory.settings.personaViewHint": "以下是每一轮实际注入的用户画像与规则，只读。",
+        "memory.settings.personaViewEmpty": "画像与规则均为空——Agent 每轮只会看到记忆库。",
+        "memory.features.personaEnabled": "人格定义（beta）",
+        "memory.features.personaEnabled.hint": "把「设置 → 个性化」里的人格卡注入到每轮对话。默认关（beta）；总闸与人格卡内的开关同时打开才生效。",
         "memory.settings.rules": "规则",
         "memory.settings.rulesHint": "给 Agent 立下必须遵守的规矩，随时增删，下一轮即生效。",
         "memory.settings.ruleAdd": "添加规则",
@@ -302,12 +328,14 @@ window.__ModuleLoader__.load({
         "memory.explorer.tabStatus": "状态",
         "memory.entities.count": "{n} 个实体",
         "memory.entities.pick": "从左侧选择一个实体，查看它的属性与关系",
+        // 搜索框有字但一条没筛出来时用它；与 entities.none（库里真没实体）分开，
+        // 否则「暂无实体」会把打错一个字误导成「你还没开抽取」。
+        "memory.entities.noMatch": "没有匹配的实体，换个词试试",
         "memory.entities.none": "暂无实体：开启实体抽取后，记忆里的人物 / 项目 / 概念会自动沉淀到这里",
         "memory.entities.attrs": "属性",
         "memory.entities.relations": "关系",
         "memory.entities.mentions": "{n} 次提及",
         "memory.entities.lastSeen": "最近出现",
-        "memory.entities.graph": "关系图谱",
         "memory.entity.person": "人物",
         "memory.entity.project": "项目",
         "memory.entity.concept": "概念",
@@ -332,8 +360,6 @@ window.__ModuleLoader__.load({
         "memory.explorer.tags": "标签",
         "memory.explorer.importance": "重要性",
         "memory.explorer.heat": "热度",
-        "memory.explorer.sourceFilter": "来源",
-        "memory.explorer.sort": "排序",
         "memory.explorer.heatSort": "热度优先",
         "memory.explorer.heatSortHint": "对已加载条目按热度降序（页内排序，非全局序；时间树保持时间序）",
         "memory.explorer.filterDeposited": "沉淀",
@@ -354,7 +380,6 @@ window.__ModuleLoader__.load({
         "memory.graph.depth": "跳数",
         "memory.graph.empty": "图谱待积累：随对话记忆的沉淀，实体与关系会自动进入图谱",
         "memory.graph.notFound": "未找到该实体",
-        "memory.graph.attrs": "属性",
         "memory.graph.related": "关联记忆",
         "memory.graph.relation": "关系",
         "memory.graph.sourceMemory": "查看来源记忆",
@@ -376,8 +401,8 @@ window.__ModuleLoader__.load({
         "memory.settings.vectorReindexing": "索引中…",
         "memory.settings.vectorReindexDone": "已索引 {n} 条",
         "memory.settings.apiTokenTitle": "API Token（可选）",
-        "memory.settings.apiTokenHint": "给面板的写操作加一道锁：设置后，修改记忆或配置需要携带 Token，纯浏览不受影响。清空并保存可关闭。",
-        "memory.settings.apiTokenPlaceholder": "留空 = 不鉴权（默认）",
+        "memory.settings.apiTokenHint": "这里只把 Token 存在当前浏览器（localStorage），供面板请求携带；服务端的锁是插件配置里的 apiToken，两边填同一个值才真正上锁。只填这里不改服务端 = 没上锁。",
+        "memory.settings.apiTokenPlaceholder": "与插件配置的 apiToken 保持一致",
         "memory.settings.apiTokenSave": "保存 Token",
         "memory.settings.apiTokenSaved": "Token 已保存",
         "memory.settings.feedback.title": "意见与反馈",
@@ -389,8 +414,16 @@ window.__ModuleLoader__.load({
         "memory.settings.feedback.browse": "浏览已知问题",
         "memory.settings.feedback.browse.sub": "先搜搜，省一份重复 issue",
         "memory.settings.feedback.hint": "反馈前先搜搜是否已有相同问题，能省一份重复的 issue～",
-        "memory.settings.version.outdated": "🆕 有新版本 {v}（当前运行 {c}）",
+        "memory.settings.update.check": "检测更新",
+        "memory.settings.update.latest": "已是最新版本 ✓",
+        "memory.settings.update.ahead": "当前版本比 registry 还新（本地开发版）",
+        "memory.settings.update.error": "检测失败：稍后再试",
+        // 检测更新点出的第三种结果（发现新版本）；横幅形态已删，它现在只是
+        // 按需那一行的文案，占位 {v}/{c} 由 checkResultText 填。
+        "memory.settings.version.outdated": "有新版本 {v}（当前运行 {c}）",
         "memory.settings.version.outdatedHint": "若安装时指定过版本号，常规升级不会跨大/小版本（pnpm 钉子）——请重新安装或在升级命令加 --latest；npm 已发布而市场暂未收录属正常（约 1 天延迟）。",
+        "memory.settings.star": "给项目点个 Star",
+        "memory.settings.star.sub": "它对你是好用的，就鼓励一下作者吧 (●'◡'●)",
         "memory.settings.mode.title": "运行模式",
         "memory.settings.mode.desc": "轻量模式只保留核心能力：记忆读写、自动注入、热记忆；巩固、实体抽取、语义搜索等全部关闭，适合低配机器或只想「记住偏好」的场景。标准模式开启全部功能。",
         "memory.settings.mode.light": "轻量",
@@ -425,30 +458,51 @@ 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": "它会记住什么",
+        // group.mo 是 v0.9.0 新增的独立分组（座位闸门，不是行为开关）；渲染
+        // 走 t(`memory.features.${g.key}`)，缺这行会把键名直接写上屏。
+        "memory.features.group.mo": "它的工作流（M.O.）",
+        "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 +518,143 @@ 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.value": "缩放 {n}%",
+        "memory.actions.zoom.in": "放大",
+        "memory.actions.zoom.out": "缩小",
+        "memory.actions.zoom.fit": "适应宽度",
+        "memory.actions.zoom.hint": "Ctrl/⌘ + 滚轮也能缩放",
+        // 缩放百分比指示（{n} 由画布工具条填）；基线 4568614 起就缺这两行，
+        // 工具条上会直接显示键名。
+        "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 +682,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": "卡片",
@@ -823,6 +953,31 @@ window.__ModuleLoader__.load({
         "memory.settings.profileHint": "Describe yourself once — the agent reads it every turn.",
         "memory.settings.profileSave": "Save Profile",
         "memory.settings.profileSaved": "Profile saved",
+        "memory.settings.persona": "Persona (beta)",
+        "memory.settings.personaHint": "Give this agent a character card: name, personality, reply style. Injected every turn when the toggle below and the \"Persona\" master switch are both on.",
+        "memory.settings.personaName": "Name",
+        "memory.settings.personaNamePlaceholder": "e.g. Nyx",
+        "memory.settings.personaPersonality": "Personality",
+        "memory.settings.personaPersonalityPlaceholder": "e.g. relaxed and humorous; use analogies for hard topics",
+        "memory.settings.personaReplyStyle": "Reply style",
+        "memory.settings.personaReplyStylePlaceholder": "e.g. conclusion first; plain words over jargon",
+        "memory.settings.personaSave": "Save Persona",
+        "memory.settings.personaSaved": "Persona saved",
+        "memory.settings.personaSaveFailed": "Save failed",
+        "memory.settings.personaEnabledToggle": "Enable this card",
+        "memory.settings.personaEnabledOn": "On — sessions matching this identity get this card",
+        "memory.settings.personaEnabledOff": "Off — sessions with this identity fall back to the default card",
+        "memory.settings.personaDefaultCard": "Default (fallback)",
+        "memory.settings.personaAdd": "Add card",
+        "memory.settings.personaAddPlaceholder": "Agent identity (e.g. nyx) used to address injection",
+        "memory.settings.personaEditingDefault": "Editing: default card — used by sessions matching no identity card",
+        "memory.settings.personaEditingFor": "Editing identity card:",
+        "memory.settings.personaDeleteCard": "Delete this card",
+        "memory.settings.personaView": "You, as the agent sees you (injected text)",
+        "memory.settings.personaViewHint": "The profile and rules actually injected every turn. Read-only.",
+        "memory.settings.personaViewEmpty": "Profile and rules are both empty — the agent only sees the memory store.",
+        "memory.features.personaEnabled": "Persona (beta)",
+        "memory.features.personaEnabled.hint": "Inject the persona card (Settings → Personalization) into every turn. Off by default (beta); both this switch and the card's own toggle must be on.",
         "memory.settings.rules": "Rules",
         "memory.settings.rulesHint": "Rules the agent must follow — add or remove anytime, effective next turn.",
         "memory.settings.ruleAdd": "Add Rule",
@@ -845,12 +1000,12 @@ window.__ModuleLoader__.load({
         "memory.explorer.tabStatus": "Status",
         "memory.entities.count": "{n} entities",
         "memory.entities.pick": "Select an entity to see its attributes and relations",
+        "memory.entities.noMatch": "No entities match that search — try another word",
         "memory.entities.none": "No entities yet — turn on entity extraction and people / projects / concepts will accumulate here",
         "memory.entities.attrs": "Attributes",
         "memory.entities.relations": "Relations",
         "memory.entities.mentions": "{n} mentions",
         "memory.entities.lastSeen": "Last seen",
-        "memory.entities.graph": "Relation graph",
         "memory.entity.person": "People",
         "memory.entity.project": "Projects",
         "memory.entity.concept": "Concepts",
@@ -875,8 +1030,6 @@ window.__ModuleLoader__.load({
         "memory.explorer.tags": "Tags",
         "memory.explorer.importance": "Importance",
         "memory.explorer.heat": "Heat",
-        "memory.explorer.sourceFilter": "Source",
-        "memory.explorer.sort": "Sort",
         "memory.explorer.heatSort": "By heat",
         "memory.explorer.heatSortHint": "Sort loaded items by heat, in-page (not global; the month tree keeps chronological order)",
         "memory.explorer.filterDeposited": "Deposited",
@@ -897,7 +1050,6 @@ window.__ModuleLoader__.load({
         "memory.graph.depth": "hops",
         "memory.graph.empty": "The graph is waiting for data: entities and relations accumulate as memories are extracted",
         "memory.graph.notFound": "Entity not found",
-        "memory.graph.attrs": "Attributes",
         "memory.graph.related": "Related memories",
         "memory.graph.relation": "Relation",
         "memory.graph.sourceMemory": "View source memory",
@@ -919,8 +1071,8 @@ window.__ModuleLoader__.load({
         "memory.settings.vectorReindexing": "Indexing…",
         "memory.settings.vectorReindexDone": "Indexed {n} items",
         "memory.settings.apiTokenTitle": "API Token (optional)",
-        "memory.settings.apiTokenHint": "Lock write operations behind a token — browsing stays open. Clear and save to disable.",
-        "memory.settings.apiTokenPlaceholder": "Empty = no auth (default)",
+        "memory.settings.apiTokenHint": "This field only stores the token in this browser (localStorage) for the panel requests. The server-side lock is the plugin\u0027s apiToken config — set both to the same value; this field alone locks nothing.",
+        "memory.settings.apiTokenPlaceholder": "Must match the plugin\u0027s apiToken",
         "memory.settings.apiTokenSave": "Save Token",
         "memory.settings.apiTokenSaved": "Token saved",
         "memory.settings.feedback.title": "Feedback",
@@ -932,8 +1084,14 @@ window.__ModuleLoader__.load({
         "memory.settings.feedback.browse": "Browse known issues",
         "memory.settings.feedback.browse.sub": "Check if it's already reported",
         "memory.settings.feedback.hint": "Search for an existing issue first — it saves a duplicate.",
-        "memory.settings.version.outdated": "🆕 New version {v} available (running {c})",
+        "memory.settings.update.check": "Check for updates",
+        "memory.settings.update.latest": "Up to date ✓",
+        "memory.settings.update.ahead": "Newer than the registry (local build)",
+        "memory.settings.update.error": "Check failed: try again later",
+        "memory.settings.version.outdated": "New version {v} available (running {c})",
         "memory.settings.version.outdatedHint": "If the plugin was installed with a pinned version, regular upgrades never cross minor/major lines — reinstall or pass --latest. A fresh npm release may take about a day to appear in the market.",
+        "memory.settings.star": "Star the project",
+        "memory.settings.star.sub": "If it serves you well, cheer the author on (●'◡'●)",
         "memory.settings.mode.title": "Runtime mode",
         "memory.settings.mode.desc": "Light mode keeps the core loop only: memory read/write, auto-injection and hot memory — consolidation, entity extraction and semantic search are all off. For modest machines or when you just want preferences remembered. Standard mode enables everything.",
         "memory.settings.mode.light": "Light",
@@ -968,30 +1126,44 @@ 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.mo": "Its workflow (M.O.)",
+        "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 +1179,135 @@ 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.value": "Zoom {n}%",
+        "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 +1335,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",
@@ -1467,17 +1707,26 @@ window.__ModuleLoader__.load({
       ".mneme-xcount{flex:none;font-size:12px;line-height:16px;color:var(--mneme-fg-dim);white-space:nowrap}",
       // --- three-column browse layout: hairline separators, no outer box ---
       ".mneme-xmain{flex:1;min-height:0;display:flex;flex-direction:row;overflow:hidden}",
-      ".mneme-xside{flex:none;width:236px;min-width:0;min-height:0;overflow-y:auto;padding:16px 14px;border-right:1px solid var(--dsw-alias-border-l2);box-sizing:border-box;display:flex;flex-direction:column;gap:8px}",
-      ".mneme-xside--filter{width:214px}",
+      ".mneme-xside{flex:none;width:264px;min-width:0;min-height:0;overflow-y:auto;overflow-x:hidden;padding:16px 14px;border-right:1px solid var(--dsw-alias-border-l2);box-sizing:border-box;display:flex;flex-direction:column;gap:8px}",
+      // 左栏下段=重要性+来源+热度：紧跟检索段之后（复验修订：不再钉底），
+      // 顶部细线保留分段感；栏宽 264px 让 4 枚星级 chip 单行排布。
+      ".mneme-xside-imp{flex:none;margin-top:10px;padding-top:12px;border-top:1px solid var(--dsw-alias-border-l1);display:flex;flex-direction:column;gap:8px}",
+      // 内容区列容器 + 顶部工具条：类型 chips 横排 + 计数/刷新靠右；窄容器靠 wrap 换行。
+      ".mneme-xcontent{flex:1;min-width:0;min-height:0;display:flex;flex-direction:column;overflow:hidden}",
+      ".mneme-xbrowsebar{flex:none;display:flex;align-items:center;gap:6px;flex-wrap:wrap;padding:8px 16px;border-bottom:1px solid var(--dsw-alias-border-l2)}",
+      // 窄容器（better-sidebar 工作台 ~500px）：左栏收窄保内容区可用宽度。
+      "@container (max-width: 640px){.mneme-xside{width:216px}}",
+      // 类型筛选原为第二侧栏的竖排列表（三栏布局遗留，#面板两栏改版）：
+      // 两栏化后收进内容区工具条，改为自适应横排 chips，彩点与计数保留。
+      ".mneme-xtype{display:inline-flex;justify-content:flex-start;align-items:center;gap:7px;padding:4px 9px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;line-height:18px;text-align:left}",
       ".mneme-xbrowse{flex:1;min-width:0;min-height:0;display:flex;flex-direction:column;overflow:hidden}",
       ".mneme-xrow{display:flex;align-items:center;gap:8px;flex-wrap:wrap}",
       ".mneme-xsearch{width:100%}",
       ".mneme-xselect{flex:1;min-width:0}",
       ".mneme-xcolhead{flex:none;font-size:12px;font-weight:500;margin:0;color:var(--mneme-fg-dim);padding:2px 8px 8px}",
-      ".mneme-xtype{display:flex;justify-content:flex-start;align-items:center;gap:8px;width:100%;padding:5px 8px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;line-height:18px;text-align:left}",
       ".mneme-xtype:hover{background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-xtype.mneme-active{background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary);font-weight:500}",
-      ".mneme-xcount2{flex:none;margin-left:auto;font-size:12px;color:var(--mneme-fg-dim)}",
+      ".mneme-xcount2{flex:none;font-size:12px;color:var(--mneme-fg-dim)}",
       ".mneme-xmonth{display:flex;align-items:center;gap:4px;width:100%;padding:6px 8px 4px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-primary);cursor:pointer;font-family:inherit;font-size:13px;font-weight:500;line-height:18px;text-align:left}",
       ".mneme-xmonth:first-child{margin-top:0}",
       ".mneme-xmonth:hover{background:var(--dsw-alias-interactive-bg-hover)}",
@@ -1519,20 +1768,26 @@ window.__ModuleLoader__.load({
       // 虚线态靠 dash 图案区分，不再叠 opacity：50% 的描边再乘 .7 后浅色画布上
       // 只剩 2.28，低于图形要求的 3:1（图案已经承担了「没有 memory_id」这个语义）。
       ".mneme-gedge-dashed{stroke-dasharray:5 4}",
-      ".mneme-graphhint{flex:none;color:var(--mneme-fg-dim);font-size:13px;text-align:center;padding:6px 0 2px}",
-      ".mneme-graphside{flex:none;max-height:220px;overflow-y:auto;border-top:1px solid var(--dsw-alias-border-l1);margin-top:10px;padding-top:10px}",
+      // 图谱与图内侧卡的共同父容器：侧卡改浮层（#面板实体页去冗余）后需要
+      // relative 锚点，否则 absolute 会逃逸到 .mneme-ent 根。
+      ".mneme-entgraphwrap{position:relative;min-width:0}",
+      // 侧卡从「SVG 下方文档流堆叠」（把图挤成邮票）改为图内左下浮层：
+      // 反应面板与点击焦点同位，SVG 不再被推挤；背景用不透明 bg-layer-1，
+      // 浮层下透出的图形不参与文字对比度计算。
+      ".mneme-graphside{position:absolute;left:12px;bottom:12px;width:min(300px,60%);max-height:60%;overflow-y:auto;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background:var(--dsw-alias-bg-layer-1);padding:10px 12px;z-index:2}",
       ".mneme-gs-title{font-size:14px;font-weight:600;color:var(--dsw-alias-label-primary);margin-bottom:4px;display:flex;justify-content:space-between;align-items:baseline;gap:8px}",
       ".mneme-gs-meta{font-size:13px;color:var(--mneme-fg-dim);margin-bottom:6px}",
-      ".mneme-gs-attr{display:flex;gap:6px;font-size:13px;padding:2px 0}",
-      ".mneme-gs-attrkey{flex:none;color:var(--mneme-fg-dim);font-size:13px}",
-      ".mneme-gs-attrval{color:var(--dsw-alias-label-secondary);word-break:break-word;font-size:13px}",
       ".mneme-gs-link{display:block;width:100%;text-align:left;border:none;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;padding:3px 6px;border-radius:6px;word-break:break-word}",
       ".mneme-gs-link:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
       // --- entity explorer: rail + layered detail (entities → attrs → relations → graph) ---
       ".mneme-ent{flex:1;min-height:0;display:flex;overflow:hidden}",
-      ".mneme-entrail{flex:none;width:224px;min-height:0;overflow-y:auto;padding:12px;border-right:1px solid var(--dsw-alias-border-l2);box-sizing:border-box;display:flex;flex-direction:column;gap:4px}",
-      ".mneme-enttype{display:flex;align-items:center;gap:6px;width:100%;padding:8px 8px 2px;border:none;background:none;color:var(--mneme-fg-dim);cursor:pointer;font-family:inherit;font-size:11px;font-weight:600;line-height:16px;text-align:left;letter-spacing:.02em}",
-      ".mneme-entitem{display:flex;align-items:center;gap:8px;width:100%;padding:5px 8px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;line-height:18px;text-align:left}",
+      ".mneme-entrail{flex:none;width:224px;min-height:0;overflow:hidden;padding:12px 0 0;border-right:1px solid var(--dsw-alias-border-l2);box-sizing:border-box;display:flex;flex-direction:column}",
+      // 复验修订：搜索与计数固定在顶部不随列表滚动，列表独立滚动；
+      // 类型分组头 sticky——长列表滚动时分组归属始终可见。
+      ".mneme-entrailhead{flex:none;padding:0 12px 10px;display:flex;flex-direction:column;gap:4px;border-bottom:1px solid var(--dsw-alias-border-l1)}",
+      ".mneme-entrailbody{flex:1;min-height:0;overflow-y:auto;overflow-x:hidden;padding:4px 12px 12px;display:flex;flex-direction:column;gap:4px}",
+      ".mneme-enttype{position:sticky;top:0;z-index:1;background:var(--dsw-alias-bg-layer-1);display:flex;align-items:center;gap:6px;width:100%;box-sizing:border-box;padding:8px 8px 2px;border:none;color:var(--mneme-fg-dim);cursor:pointer;font-family:inherit;font-size:11px;font-weight:600;line-height:16px;text-align:left;letter-spacing:.02em}",
+      ".mneme-entitem{display:flex;align-items:center;gap:8px;width:100%;box-sizing:border-box;padding:5px 8px;border:none;border-radius:8px;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:13px;line-height:18px;text-align:left}",
       ".mneme-entitem:hover{background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-entitem.mneme-active{background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary)}",
       ".mneme-entname{min-width:0;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}",
@@ -1668,6 +1923,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}",
@@ -1832,8 +2092,14 @@ window.__ModuleLoader__.load({
       ".mneme-barcol:hover .mneme-bar{opacity:.8}",
       ".mneme-barlabels{display:flex;gap:8px;padding:6px 2px 0}",
       ".mneme-barlabels span{flex:1;min-width:0;text-align:center;font-size:10.5px;color:var(--mneme-fg-dim);font-variant-numeric:tabular-nums}",
-      ".mneme-heatgrid{display:grid;grid-auto-flow:column;grid-template-rows:repeat(7,12px);gap:3px;margin-top:12px}",
-      ".mneme-heatcell{width:12px;height:12px;border-radius:3px;background:var(--dsw-alias-interactive-bg-hover)}",
+      // GitHub 贡献图式紧凑网格（复验第三轮「间距太大」）：11px 格 + 2px 缝；
+      // heatrows 是左侧星期标签列（一/三/五），heatmonths 是顶部月份标签行
+      // （列主序网格下月份行须与格子列对齐，所以同用 auto-flow:column）。
+      ".mneme-heatgrid{display:grid;grid-auto-flow:column;grid-template-rows:repeat(7,11px);gap:2px;margin-top:12px}",
+      ".mneme-heatcell{width:11px;height:11px;border-radius:2px;background:var(--dsw-alias-interactive-bg-hover)}",
+      ".mneme-heatwrap{display:flex;gap:4px}",
+      ".mneme-heatrows{display:grid;grid-template-rows:repeat(7,11px);gap:2px;margin-top:12px;font-size:9.5px;line-height:11px;color:var(--mneme-fg-dim);text-align:right}",
+      ".mneme-heatmonths{display:grid;grid-auto-flow:column;grid-auto-columns:11px;gap:2px;margin-top:0;font-size:9.5px;line-height:14px;color:var(--mneme-fg-dim)}",
       // 类名编号=视觉档位（l1 最浅…l4 最深），变量编号=business 占比降序，故交叉引用。
       ".mneme-heatcell.l1{background:var(--mneme-heat-4)}",
       ".mneme-heatcell.l2{background:var(--mneme-heat-3)}",
@@ -1898,7 +2164,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");
@@ -2238,31 +2656,39 @@ window.__ModuleLoader__.load({
       const graphStatus = status === "ready" && data && data.nodes.length <= 1 ? "empty" : status;
 
       const rail = h("div", { className: "mneme-entrail" },
-        h("div", { className: "mneme-xcolhead" }, t("memory.view.label")),
-        h("input", {
-          className: "mneme-search mneme-xsearch",
-          placeholder: t("memory.graph.placeholder"),
-          value: railQuery,
-          onChange: (e) => setRailQuery(e.target.value)
-        }),
-        entities === null && h("div", { className: "mneme-xempty" }, "…"),
-        entities !== null && entities.length === 0 && h("div", { className: "mneme-xempty" }, t("memory.entities.none")),
-        entities !== null && entities.length > 0 && h("div", { className: "mneme-xcount" },
-          t("memory.entities.count").replace("{n}", String(entities.length))),
-        groups.map((g) => h("div", { key: g.key },
-          h("div", { className: "mneme-enttype" },
-            h("span", { className: "mneme-xdot", style: { color: typeColor(g.key === "other" ? null : g.key) }, "aria-hidden": "true" }),
-            entityTypeLabel(t, g.key)
-          ),
-          g.items.map((e) => h("button", {
-            key: e.id,
-            className: e.name === entityName ? "mneme-entitem mneme-active" : "mneme-entitem",
-            onClick: () => setEntityName(e.name)
-          },
-            h("span", { className: "mneme-entname" }, e.name),
-            h("span", { className: "mneme-entmentions" }, `×${e.mention_count ?? 1}`)
+        // 头部固定段：表头（本页名「实体」——原误用全局页签名「记忆库」，而
+        // memory.view.label 仍被顶部 nav aria-label 使用，字典不动只换这里）
+        // + 搜索 + 计数，不随列表滚动。
+        h("div", { className: "mneme-entrailhead" },
+          h("div", { className: "mneme-xcolhead" }, t("memory.explorer.tabEntities")),
+          h("input", {
+            className: "mneme-search mneme-xsearch",
+            placeholder: t("memory.graph.placeholder"),
+            value: railQuery,
+            onChange: (e) => setRailQuery(e.target.value)
+          }),
+          entities !== null && entities.length > 0 && h("div", { className: "mneme-xcount" },
+            t("memory.entities.count").replace("{n}", String(entities.length)))
+        ),
+        h("div", { className: "mneme-entrailbody" },
+          entities === null && h("div", { className: "mneme-xempty" }, "…"),
+          entities !== null && entities.length === 0 && h("div", { className: "mneme-xempty" }, t("memory.entities.none")),
+          entities !== null && entities.length > 0 && visibleEntities.length === 0 && h("div", { className: "mneme-xempty" }, t("memory.entities.noMatch")),
+          groups.map((g) => h("div", { key: g.key },
+            h("div", { className: "mneme-enttype" },
+              h("span", { className: "mneme-xdot", style: { color: typeColor(g.key === "other" ? null : g.key) }, "aria-hidden": "true" }),
+              entityTypeLabel(t, g.key)
+            ),
+            g.items.map((e) => h("button", {
+              key: e.id,
+              className: e.name === entityName ? "mneme-entitem mneme-active" : "mneme-entitem",
+              onClick: () => setEntityName(e.name)
+            },
+              h("span", { className: "mneme-entname" }, e.name),
+              h("span", { className: "mneme-entmentions" }, `×${e.mention_count ?? 1}`)
+            ))
           ))
-        ))
+        )
       );
 
       // side card for a clicked (non-root) node or edge inside the graph layer
@@ -2278,14 +2704,7 @@ window.__ModuleLoader__.load({
             selected.node.name !== entityName && h("button", {
               className: "mneme-footbtn",
               onClick: () => setEntityName(selected.node.name)
-            }, t("memory.graph.viewInGraph")),
-            attrs.length > 0 && h("div", null,
-              h("div", { className: "mneme-gs-meta" }, t("memory.graph.attrs")),
-              attrs.map((a, i) => h("div", { key: i, className: "mneme-gs-attr" },
-                h("span", { className: "mneme-gs-attrkey" }, `${a.key}:`),
-                h("span", { className: "mneme-gs-attrval" }, a.value)
-              ))
-            )
+            }, t("memory.graph.viewInGraph"))
           )
         : selected?.kind === "edge"
           ? h("div", { className: "mneme-graphside" },
@@ -2319,46 +2738,104 @@ window.__ModuleLoader__.load({
               h("span", { title: formatDate(entity.last_seen) },
                 `${t("memory.entities.lastSeen")}: ${formatRelativeTime(entity.last_seen, t)}`)
             ),
-            // ① 属性 — current snapshot (valid_until IS NULL)
+            // ① 关系图谱（前置）：图形在属性/列表之前，是实体页的第一眼；
+            // 深度/复位 chips 从层头移进图谱工具行（动作靠近作用对象），操作
+            // 提示收进行尾小字不再独占一行；关系列表（跳来源记忆的唯一入口）
+            // 保留为图谱的文本镜像、与图谱同层共享层头，消除信息双轨的分段感。
             h("div", { className: "mneme-layer" },
               h("div", { className: "mneme-layerhead" },
-                t("memory.entities.attrs"),
-                h("span", { className: "mneme-layercount" }, String(attrs.length))
+                t("memory.entities.relations"),
+                h("span", { className: "mneme-layercount" }, String(rootEdges.length))
               ),
-              attrs.length === 0
-                ? h("div", { className: "mneme-xempty" }, t("memory.settings.empty"))
-                : h("div", { className: "mneme-attrgrid" },
-                    attrs.map((a, i) => h("div", { key: i, className: "mneme-attrcard", title: a.value },
-                      h("div", { className: "mneme-attrkey" }, a.key),
-                      h("div", { className: "mneme-attrval" }, a.value)
-                    ))
+              rootEdges.length === 0 && graphStatus === "empty"
+                ? h("div", { className: "mneme-hint" }, t("memory.graph.empty"))
+                : h(react.Fragment, null,
+                    graphStatus !== "empty" && h("div", { className: "mneme-graphbar" },
+                      h("button", {
+                        className: depth === 2 ? "mneme-chip mneme-active" : "mneme-chip",
+                        title: t("memory.graph.depth"),
+                        onClick: () => setDepth(depth === 1 ? 2 : 1)
+                      }, `${depth} ${t("memory.graph.depth")}`),
+                      h("button", {
+                        className: "mneme-chip",
+                        title: t("memory.graph.resetView"),
+                        onClick: resetView
+                      }, t("memory.graph.resetView")),
+                      h("span", { style: { marginLeft: "auto", fontSize: 12, color: "var(--mneme-fg-dim)" } }, t("memory.graph.hint"))
+                    ),
+                    graphStatus !== "empty" && h("div", { className: "mneme-entgraphwrap" },
+                      h("svg", {
+                        ref: svgRef,
+                        className: "mneme-graphsvg",
+                        viewBox: `0 0 ${VIEW_W} ${VIEW_H}`,
+                        style: { height: 440 },
+                        role: "img",
+                        "aria-label": t("memory.graph.summary")
+                          .replace("{entity}", (data.root && (data.root.label || data.root.name)) || "")
+                          .replace("{nodes}", String(data.nodes.length))
+                          .replace("{edges}", String(data.edges.length)),
+                        onMouseDown: onSurfaceMouseDown
+                      },
+                        h("g", {
+                          transform: `translate(${viewRef.current.x},${viewRef.current.y}) scale(${viewRef.current.k})`
+                        },
+                          data.edges.map((e) => {
+                            const a = nodeById.get(e.from), b = nodeById.get(e.to);
+                            if (!a || !b) return null;
+                            return h("line", {
+                              key: e.id,
+                              x1: a.x, y1: a.y, x2: b.x, y2: b.y,
+                              className: e.memory_id ? "mneme-gedge" : "mneme-gedge mneme-gedge-dashed",
+                              onClick: () => onEdgeClick(e)
+                            });
+                          }),
+                          nodes.map((n) => h("g", {
+                            key: n.id,
+                            className: n.id === data.root.id ? "mneme-gnode mneme-groot" : "mneme-gnode",
+                            transform: `translate(${n.x},${n.y})`,
+                            onMouseDown: (e) => onNodeMouseDown(e, n),
+                            onClick: () => onNodeClick(n),
+                            "data-node": n.name
+                          },
+                            h("circle", { r: nodeRadius(n), fill: typeColor(n.type), fillOpacity: nodeOpacity(n) }),
+                            h("text", { className: "mneme-glabel", y: nodeRadius(n) + 13 }, n.name)
+                          ))
+                        )
+                      ),
+                      side
+                    ),
+                    rootEdges.length > 0 && rootEdges.map((e) => {
+                      const out = e.from === data.root.id;
+                      const other = nodeById.get(out ? e.to : e.from);
+                      const otherName = other?.name ?? (out ? e.to : e.from);
+                      return h("button", {
+                        key: e.id,
+                        className: "mneme-relrow",
+                        title: e.memory_id ? t("memory.graph.sourceMemory") : undefined,
+                        onClick: () => { if (e.memory_id && onJumpMemory) onJumpMemory({ id: e.memory_id }); }
+                      },
+                        h("span", { className: "mneme-relname", style: { textAlign: "right", flex: 1 } }, entity.name),
+                        h("span", { className: "mneme-reltype" }, e.relation_type),
+                        h("span", { className: "mneme-relname", style: { flex: 1 } }, otherName)
+                      );
+                    })
                   )
             ),
-            // ② 关系 — both directions from the 1-hop ego walk
-            h("div", { className: "mneme-layer" },
+            // ② 属性 — current snapshot (valid_until IS NULL)；空层整层隐藏
+            // （原先渲染一行「暂无内容」占住高度，是零信息的堆积）
+            attrs.length > 0 && h("div", { className: "mneme-layer" },
               h("div", { className: "mneme-layerhead" },
-                t("memory.entities.relations"),
-                h("span", { className: "mneme-layercount" }, String(rootEdges.length))
+                t("memory.entities.attrs"),
+                h("span", { className: "mneme-layercount" }, String(attrs.length))
               ),
-              rootEdges.length === 0
-                ? h("div", { className: "mneme-xempty" }, t("memory.settings.empty"))
-                : rootEdges.map((e) => {
-                    const out = e.from === data.root.id;
-                    const other = nodeById.get(out ? e.to : e.from);
-                    const otherName = other?.name ?? (out ? e.to : e.from);
-                    return h("button", {
-                      key: e.id,
-                      className: "mneme-relrow",
-                      title: e.memory_id ? t("memory.graph.sourceMemory") : undefined,
-                      onClick: () => { if (e.memory_id && onJumpMemory) onJumpMemory({ id: e.memory_id }); }
-                    },
-                      h("span", { className: "mneme-relname", style: { textAlign: "right", flex: 1 } }, entity.name),
-                      h("span", { className: "mneme-reltype" }, e.relation_type),
-                      h("span", { className: "mneme-relname", style: { flex: 1 } }, otherName)
-                    );
-                  })
+              h("div", { className: "mneme-attrgrid" },
+                attrs.map((a, i) => h("div", { key: i, className: "mneme-attrcard", title: a.value },
+                  h("div", { className: "mneme-attrkey" }, a.key),
+                  h("div", { className: "mneme-attrval" }, a.value)
+                ))
+              )
             ),
-            // ③ 关联记忆 — entity: prefix recall
+            // ③ 关联记忆 — entity: prefix recall（entity: 之外的唯一记忆回链入口）
             related.length > 0 && h("div", { className: "mneme-layer" },
               h("div", { className: "mneme-layerhead" },
                 t("memory.graph.related"),
@@ -2371,68 +2848,6 @@ window.__ModuleLoader__.load({
                 title: t("memory.card.open"),
                 onClick: () => onJumpMemory && onJumpMemory(m)
               }, m.title || m.content?.slice(0, 60)))
-            ),
-            // ④ 关系图谱 — the ego graph
-            h("div", { className: "mneme-layer" },
-              h("div", { className: "mneme-layerhead" },
-                t("memory.entities.graph"),
-                h("span", { className: "mneme-layercount" },
-                  h("button", {
-                    className: depth === 2 ? "mneme-chip mneme-active" : "mneme-chip",
-                    title: t("memory.graph.depth"),
-                    onClick: () => setDepth(depth === 1 ? 2 : 1)
-                  }, `${depth} ${t("memory.graph.depth")}`)),
-                h("span", { className: "mneme-layercount" },
-                  h("button", {
-                    className: "mneme-chip",
-                    title: t("memory.graph.resetView"),
-                    onClick: resetView
-                  }, t("memory.graph.resetView")))
-              ),
-              graphStatus === "empty"
-                ? h("div", { className: "mneme-hint" }, t("memory.graph.empty"))
-                : h(react.Fragment, null,
-                    h("svg", {
-                      ref: svgRef,
-                      className: "mneme-graphsvg",
-                      viewBox: `0 0 ${VIEW_W} ${VIEW_H}`,
-                      style: { height: 320 },
-                      role: "img",
-                      "aria-label": t("memory.graph.summary")
-                        .replace("{entity}", (data.root && (data.root.label || data.root.name)) || "")
-                        .replace("{nodes}", String(data.nodes.length))
-                        .replace("{edges}", String(data.edges.length)),
-                      onMouseDown: onSurfaceMouseDown
-                    },
-                      h("g", {
-                        transform: `translate(${viewRef.current.x},${viewRef.current.y}) scale(${viewRef.current.k})`
-                      },
-                        data.edges.map((e) => {
-                          const a = nodeById.get(e.from), b = nodeById.get(e.to);
-                          if (!a || !b) return null;
-                          return h("line", {
-                            key: e.id,
-                            x1: a.x, y1: a.y, x2: b.x, y2: b.y,
-                            className: e.memory_id ? "mneme-gedge" : "mneme-gedge mneme-gedge-dashed",
-                            onClick: () => onEdgeClick(e)
-                          });
-                        }),
-                        nodes.map((n) => h("g", {
-                          key: n.id,
-                          className: n.id === data.root.id ? "mneme-gnode mneme-groot" : "mneme-gnode",
-                          transform: `translate(${n.x},${n.y})`,
-                          onMouseDown: (e) => onNodeMouseDown(e, n),
-                          onClick: () => onNodeClick(n),
-                          "data-node": n.name
-                        },
-                          h("circle", { r: nodeRadius(n), fill: typeColor(n.type), fillOpacity: nodeOpacity(n) }),
-                          h("text", { className: "mneme-glabel", y: nodeRadius(n) + 13 }, n.name)
-                        ))
-                      )
-                    ),
-                    h("div", { className: "mneme-graphhint" }, t("memory.graph.hint"))
-                  ),
-              side
             )
           )
         )
@@ -2454,10 +2869,32 @@ 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 个子开关 + M.O. 1 开关 +
+    // scope 2 开关 + 「全部设置」按钮 = 9。复验修订：产品主人点名 M.O.
+    // 「别藏在里面」，独立成组但仍折在「全部设置」后等于换个地方藏；
+    // ≤8 是本仓库 #427 自设的软预算，owner 点名豁免一项，锁随注释同步改。
+    // RuntimeProvisionBlock 配好即消失，常态首屏更少。
+    const FEATURE_FIRST_SCREEN = ["group.basic", "group.mo", "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）复验修订：独立分组行——它不是行为开关而是座位闸门
+      // （关=一个座位都不注册，见 apply 内的 M.O. 块）。独立成组只解决「混在
+      // enhance 末位」；可见层由 FEATURE_FIRST_SCREEN 决定（见其注释），
+      // 本轮已把组名提进首屏——组成员资格不决定可见性。
+      { key: "group.mo", items: ["actionPipelineEnabled"] },
+      { key: "group.enhance", items: ["entityExtractionEnabled", "codingRetrospect", "rerankEnabled", "resilientModelDownload", "searchSemanticDedup", "bm25SearchEnabled", "heatEnabled", "documentMemoryEnabled",
+        // 人格定义页（beta）：注入总闸。分组随 enhance（行为开关，非座位闸门）；
+        // 人格内容在设置页「个性化」区的人格卡。
+        "personaEnabled"] },
+      { key: "group.dream", items: ["sleepModeEnabled"] },
       // v0.8.0 A4（issue #17）：作用域隔离组——标注总开关 + 严格硬过滤。
       { key: "group.scope", items: ["scopeEnabled", "strictScope"] }
     ];
@@ -2468,6 +2905,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 +2918,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 +2943,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 +2974,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 +2994,7 @@ window.__ModuleLoader__.load({
 
       const eff = (state && state.effective) || {};
 
+      // 返回值 = 这次写入有没有落库。调用方要据此决定草稿的去留。
       const put = async (patch) => {
         setBusy(true);
         try {
@@ -2544,13 +3003,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 +3029,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 +3076,7 @@ window.__ModuleLoader__.load({
         on: !!eff[k],
         disabled: busy,
         sub: !!opts.sub,
+        tag: flagTag(k),
         onToggle: () => put({ [k]: !eff[k] })
       });
 
@@ -2592,9 +3094,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 +3124,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 +3193,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 +3210,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 +3307,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 +3325,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))
+                )
+              );
+            })()
       );
     }
 
@@ -2848,6 +3408,14 @@ window.__ModuleLoader__.load({
       const [newCmd, setNewCmd] = react.useState({ name: "", description: "", instruction: "" });
       const [saved, setSaved] = react.useState(false);
       const [cmdError, setCmdError] = react.useState("");
+      // 人格卡（beta，v1.2 多卡）：default 卡草稿 + byAgent 卡列表 + 当前编辑位；
+      // provenance 是 v1.5 协作式人格的预留位，v1 只透传不编辑。
+      const [personaDefault, setPersonaDefault] = react.useState({ name: "", personality: "", replyStyle: "", enabled: false });
+      const [personaByAgent, setPersonaByAgent] = react.useState({});
+      const [personaEditing, setPersonaEditing] = react.useState("default");
+      const [personaNewName, setPersonaNewName] = react.useState("");
+      const [personaSaved, setPersonaSaved] = react.useState(false);
+      const [personaError, setPersonaError] = react.useState("");
       const [vector, setVector] = react.useState({ enabled: false, baseUrl: "", apiKey: "", model: "" });
       const [vectorSaved, setVectorSaved] = react.useState(false);
       const [reindexing, setReindexing] = react.useState(false);
@@ -2858,9 +3426,39 @@ window.__ModuleLoader__.load({
       const [apiTokenSaved, setApiTokenSaved] = react.useState(false);
       // 反馈入口的插件版本（GET /info）。失败保持 "unknown"，链接仍可用。
       const [pkgVersion, setPkgVersion] = react.useState("unknown");
-      // 版本自检（#174 后续）：运行版本 vs registry latest。仅 outdated 渲染
-      // 横幅，其余状态（up-to-date / ahead / unknown / 查询失败）零渲染零打扰。
+      // 版本自检（复验修订：原为进入设置页自动请求 + 顶部横幅，现改为底部
+      // 「支持与鼓励」卡里的「检测更新」按钮手动触发，结果内联显示——自动
+      // 请求与横幅常驻都是打扰面）。status 共四种：outdated / latest / error / null（未检测）。
       const [updateInfo, setUpdateInfo] = react.useState(null);
+      const [updateChecking, setUpdateChecking] = react.useState(false);
+      function checkForUpdate() {
+        if (updateChecking) return;
+        setUpdateChecking(true);
+        apiFetch("/api/dsh-mneme/version-check")
+          .then((res) => (res.ok ? res.json() : null))
+          .then((j) => {
+            setUpdateInfo(j && typeof j.latest === "string" && typeof j.version === "string"
+              ? { status: j.status, latest: j.latest, current: j.version }
+              : { status: "error" });
+            setUpdateChecking(false);
+          })
+          .catch(() => { setUpdateInfo({ status: "error" }); setUpdateChecking(false); });
+      }
+      // 检测结果一行文案：按 status 取既有或新增的 i18n key。
+      function checkResultText() {
+        if (!updateInfo) return "";
+        if (updateInfo.status === "outdated") {
+          return t("memory.settings.version.outdated")
+            .replace("{v}", updateInfo.latest)
+            .replace("{c}", updateInfo.current);
+        }
+        // 后端 classify（src/version-check.js）返回的是 "up-to-date"（连字符）。
+        // 前端状态名必须与它逐字对齐：此前误写 "latest"/"up_to_date" 两个后端
+        // 从未返回过的名字，检测成功也掉进 error 兜底（复验实测踩中）。
+        if (updateInfo.status === "up-to-date") return t("memory.settings.update.latest");
+        if (updateInfo.status === "ahead") return t("memory.settings.update.ahead");
+        return t("memory.settings.update.error");
+      }
       // 运行模式 — light vs standard; null = still loading. The card keeps
       // its own busy/saved/error state so it never blocks the others.
       const [mode, setMode] = react.useState(null);
@@ -2881,16 +3479,33 @@ window.__ModuleLoader__.load({
 
       const load = react.useCallback(async () => {
         try {
-          const [p, r, c, v] = await Promise.all([
+          const [p, r, c, v, ps] = await Promise.all([
             apiFetch("/api/dsh-mneme/profile").then((res) => res.json()),
             apiFetch("/api/dsh-mneme/rules").then((res) => res.json()),
             apiFetch("/api/dsh-mneme/commands").then((res) => res.json()),
-            apiFetch("/api/dsh-mneme/vector-config").then((res) => res.json())
+            apiFetch("/api/dsh-mneme/vector-config").then((res) => res.json()),
+            apiFetch("/api/dsh-mneme/persona").then((res) => res.json()).catch(() => null)
           ]);
           setProfile(p.profile || "");
           setRules(Array.isArray(r.rules) ? r.rules : []);
           setCommands(Array.isArray(c.commands) ? c.commands : []);
           setVector(v.config || { enabled: false, baseUrl: "", apiKey: "", model: "" });
+          // 人格卡：旧后端无 /persona（404）时保持默认空卡，不阻塞其它卡片。
+          // v1.2 多卡形 {default, byAgent}；旧单对象形读作 default（后端已兼容，
+          // 这里双保险再判一次形状）。
+          const pj = ps && ps.persona && typeof ps.persona === "object" ? ps.persona : {};
+          const isMulti = "default" in pj || "byAgent" in pj;
+          const dRaw = isMulti ? (pj.default ?? {}) : pj;
+          const bRaw = isMulti && pj.byAgent && typeof pj.byAgent === "object" ? pj.byAgent : {};
+          const norm = (c) => ({
+            name: typeof c?.name === "string" ? c.name : "",
+            personality: typeof c?.personality === "string" ? c.personality : "",
+            replyStyle: typeof c?.replyStyle === "string" ? c.replyStyle : "",
+            enabled: c?.enabled === true
+          });
+          setPersonaDefault(norm(dRaw));
+          setPersonaByAgent(Object.fromEntries(Object.entries(bRaw).map(([k, c]) => [k, norm(c)])));
+          setPersonaEditing("default");
         } catch { /* ignore */ }
       }, []);
 
@@ -2906,21 +3521,6 @@ window.__ModuleLoader__.load({
         return () => { cancelled = true; };
       }, []);
 
-      // 版本自检：只读 /version-check（宿主围栏鉴权）。非 outdated 一律归
-      // null——横幅不出现即是「无需处理」；接口失败也静默，不新增故障面。
-      react.useEffect(() => {
-        let cancelled = false;
-        apiFetch("/api/dsh-mneme/version-check")
-          .then((res) => (res.ok ? res.json() : null))
-          .then((j) => {
-            if (!cancelled && j && j.status === "outdated" && typeof j.latest === "string" && typeof j.version === "string") {
-              setUpdateInfo({ latest: j.latest, current: j.version });
-            }
-          })
-          .catch(() => {});
-        return () => { cancelled = true; };
-      }, []);
-
       // 反馈链接预填：环境信息（插件版本 + 平台）+ 问题描述骨架。邮件主题带
       // 版本/平台方便归档，正文同款模板；纯链接零后端成本。
       const feedbackEnv = `**插件版本**: ${pkgVersion}\n**平台**: ${platformLabel()}\n`;
@@ -2981,6 +3581,65 @@ window.__ModuleLoader__.load({
         } catch { /* ignore */ }
       }
 
+      // 人格卡保存（v1.2 多卡）：全量多卡形 PUT（{default, byAgent}，后端全量
+      // 替换语义）。保存失败必须冒提示——v1 的静默 catch 曾把 404 吞成「看起来
+      // 保存了」（后端未重装配时 PUT 打 404），桉桉实测踩中，此处不再静默。
+      async function savePersonaCards(nextDefault, nextByAgent) {
+        try {
+          const res = await apiFetch("/api/dsh-mneme/persona", {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ persona: { default: nextDefault, byAgent: nextByAgent } })
+          });
+          if (!res.ok) throw new Error("HTTP " + res.status);
+          setPersonaSaved(true);
+          setPersonaError("");
+          announce(t("memory.settings.personaSaved"));
+          setTimeout(() => setPersonaSaved(false), 1500);
+        } catch (err) {
+          setPersonaError((err && err.message) || "failed");
+          setTimeout(() => setPersonaError(""), 4000);
+        }
+      }
+      // 当前编辑位的卡：default 或 byAgent[editing]；草稿即编辑位状态本身。
+      const personaEditingCard = personaEditing === "default"
+        ? personaDefault
+        : personaByAgent[personaEditing] || { name: "", personality: "", replyStyle: "", enabled: false };
+      const updatePersonaCard = (key, value) => {
+        if (personaEditing === "default") setPersonaDefault((c) => ({ ...c, [key]: value }));
+        else setPersonaByAgent((c) => ({ ...c, [personaEditing]: { ...(c[personaEditing] || { name: "", personality: "", replyStyle: "", enabled: false }), [key]: value } }));
+      };
+      const saveEditingPersona = () => savePersonaCards(personaDefault, personaByAgent);
+      const toggleEditingPersona = (checked) => {
+        if (personaEditing === "default") {
+          const next = { ...personaDefault, enabled: checked };
+          setPersonaDefault(next);
+          savePersonaCards(next, personaByAgent);
+        } else {
+          const next = { ...(personaByAgent[personaEditing] || { name: "", personality: "", replyStyle: "", enabled: false }), enabled: checked };
+          setPersonaByAgent((c) => ({ ...c, [personaEditing]: next }));
+          savePersonaCards(personaDefault, { ...personaByAgent, [personaEditing]: next });
+        }
+      };
+      const addPersonaCard = () => {
+        const id = personaNewName.trim();
+        if (!id || id === "default" || personaByAgent[id]) return;
+        const fresh = { name: id, personality: "", replyStyle: "", enabled: false };
+        const next = { ...personaByAgent, [id]: fresh };
+        setPersonaByAgent(next);
+        setPersonaNewName("");
+        setPersonaEditing(id);
+        savePersonaCards(personaDefault, next);
+      };
+      const removePersonaCard = (id) => {
+        if (id === "default" || !personaByAgent[id]) return;
+        const next = { ...personaByAgent };
+        delete next[id];
+        setPersonaByAgent(next);
+        if (personaEditing === id) setPersonaEditing("default");
+        savePersonaCards(personaDefault, next);
+      };
+
       async function putRules(next) {
         await apiFetch("/api/dsh-mneme/rules", {
           method: "PUT",
@@ -3162,18 +3821,7 @@ window.__ModuleLoader__.load({
       }
 
       return h("div", null,
-        // 版本自检横幅 — 仅 outdated 时渲染（up-to-date/ahead/unknown/失败
-        // 全部零渲染）。钉子警示：安装时指定过版本号的 profile 会被 pnpm
-        // 挡住常规升级（#174 报障者的实际成因）；市场收录新发布约有 1 天延迟。
-        updateInfo && h("section", { className: "mneme-set-card" },
-          h("div", { className: "mneme-set-title" },
-            t("memory.settings.version.outdated")
-              .replace("{v}", updateInfo.latest)
-              .replace("{c}", updateInfo.current)
-          ),
-          h("div", { className: "mneme-featsubhint" }, t("memory.settings.version.outdatedHint"))
-        ),
-        // —— 个性化：画像 / 规则 / 自定义指令（Agent 怎么对你） ——
+        // —— 个性化：画像 / 人格 / 规则 / 自定义指令（Agent 怎么对你） ——
         h("div", { className: "mneme-set-grouphead" }, t("memory.settings.group.personal")),
         // 用户画像 — who the agent is talking to
         h("section", { className: "mneme-set-card" },
@@ -3190,6 +3838,103 @@ window.__ModuleLoader__.load({
             saved && h("span", { className: "mneme-saved" }, t("memory.settings.profileSaved"))
           )
         ),
+        // 人格卡（beta，v1.2 多卡）— who the agent is：多张角色卡按会话身份注入。
+        // 卡内开关只是该卡 enabled 半边；总闸 personaEnabled 在功能开关组，双闸同真。
+        h("section", { className: "mneme-set-card" },
+          h("div", { className: "mneme-set-title" }, t("memory.settings.persona")),
+          h("div", { className: "mneme-set-desc" }, t("memory.settings.personaHint")),
+          // 卡列表：default + 各 byAgent 卡，点选切换编辑位；default 标注兜底位
+          h("div", { style: { display: "flex", flexWrap: "wrap", gap: 6 } },
+            h("button", {
+              type: "button",
+              className: "mneme-btn" + (personaEditing === "default" ? " mneme-btn--active" : ""),
+              onClick: () => setPersonaEditing("default")
+            }, t("memory.settings.personaDefaultCard")),
+            Object.keys(personaByAgent).map((id) =>
+              h("span", { key: id, style: { display: "inline-flex", alignItems: "center", gap: 2 } },
+                h("button", {
+                  type: "button",
+                  className: "mneme-btn" + (personaEditing === id ? " mneme-btn--active" : ""),
+                  onClick: () => setPersonaEditing(id)
+                }, id),
+                h("button", {
+                  type: "button",
+                  className: "mneme-set-del",
+                  title: t("memory.settings.personaDeleteCard"),
+                  "aria-label": t("memory.settings.personaDeleteCard") + " " + id,
+                  onClick: () => removePersonaCard(id)
+                }, "×")
+              ))
+          ),
+          // 添加卡：输入 agent 身份名（注入时按它寻址）
+          h("div", { style: { display: "flex", gap: 8 } },
+            h("input", {
+              className: "mneme-set-input",
+              style: { marginBottom: 0 },
+              value: personaNewName,
+              placeholder: t("memory.settings.personaAddPlaceholder"),
+              onChange: (e) => setPersonaNewName(e.target.value),
+              onKeyDown: (e) => { if (e.key === "Enter") addPersonaCard(); }
+            }),
+            h("button", { className: "mneme-btn", onClick: addPersonaCard }, t("memory.settings.personaAdd"))
+          ),
+          // 编辑位标题：default 卡 vs 具体身份卡
+          h("div", { className: "mneme-set-desc" },
+            personaEditing === "default"
+              ? t("memory.settings.personaEditingDefault")
+              : t("memory.settings.personaEditingFor") + " " + personaEditing),
+          // 可见字段标签（v1.1 反馈：aria-label 看不见，框上要有字）
+          h("div", { className: "mneme-featnumlabel" }, t("memory.settings.personaEnabledToggle")),
+          h("div", { className: "mneme-set-row" },
+            h("input", {
+              type: "checkbox",
+              checked: personaEditingCard.enabled === true,
+              "aria-label": t("memory.settings.personaEnabledToggle"),
+              onChange: (e) => toggleEditingPersona(e.target.checked)
+            }),
+            h("span", { className: "mneme-set-ruletext" },
+              personaEditingCard.enabled === true
+                ? t("memory.settings.personaEnabledOn")
+                : t("memory.settings.personaEnabledOff"))
+          ),
+          h("div", { className: "mneme-featnumlabel" }, t("memory.settings.personaName")),
+          h("input", {
+            className: "mneme-set-input",
+            value: personaEditingCard.name,
+            placeholder: t("memory.settings.personaNamePlaceholder"),
+            onChange: (e) => updatePersonaCard("name", e.target.value)
+          }),
+          h("div", { className: "mneme-featnumlabel" }, t("memory.settings.personaPersonality")),
+          h("textarea", {
+            className: "mneme-set-input mneme-set-input--area",
+            value: personaEditingCard.personality,
+            placeholder: t("memory.settings.personaPersonalityPlaceholder"),
+            onChange: (e) => updatePersonaCard("personality", e.target.value)
+          }),
+          h("div", { className: "mneme-featnumlabel" }, t("memory.settings.personaReplyStyle")),
+          h("textarea", {
+            className: "mneme-set-input mneme-set-input--area",
+            value: personaEditingCard.replyStyle,
+            placeholder: t("memory.settings.personaReplyStylePlaceholder"),
+            onChange: (e) => updatePersonaCard("replyStyle", e.target.value)
+          }),
+          h("div", { style: { display: "flex", alignItems: "center", gap: 8 } },
+            h("button", { className: "mneme-btn", onClick: saveEditingPersona }, t("memory.settings.personaSave")),
+            personaSaved && h("span", { className: "mneme-saved" }, t("memory.settings.personaSaved")),
+            personaError && h("span", { className: "mneme-saved", style: { color: "var(--dsw-danger, #d33)" } },
+              t("memory.settings.personaSaveFailed") + " (" + personaError + ")")
+          )
+        ),
+        // Agent 眼中的画像（只读）— 注入生效文本：profile + rules 原样展示。
+        // 纯前端拼接（GET 已在 load 里拿到 profile/rules），零后端新请求。
+        h("section", { className: "mneme-set-card" },
+          h("div", { className: "mneme-set-title" }, t("memory.settings.personaView")),
+          h("div", { className: "mneme-set-desc" }, t("memory.settings.personaViewHint")),
+          (profile.trim() || rules.length)
+            ? h("pre", { className: "mneme-set-input mneme-set-input--area", style: { whiteSpace: "pre-wrap", minHeight: 0 } },
+                [profile.trim() ? "- " + profile.trim() : "", ...rules.map((r) => "- " + r)].filter(Boolean).join("\n"))
+            : h("div", { className: "mneme-xempty" }, t("memory.settings.personaViewEmpty"))
+        ),
         // 规则 — numbered rows, hover reveals the delete affordance
         h("section", { className: "mneme-set-card" },
           h("div", { className: "mneme-set-title" }, t("memory.settings.rules")),
@@ -3417,7 +4162,7 @@ window.__ModuleLoader__.load({
           ),
           apiTokenSaved && h("div", { style: { marginTop: 8 } }, h("span", { className: "mneme-saved" }, t("memory.settings.apiTokenSaved")))
         ),
-        // —— 帮助：意见与反馈（图标行 + 版本 footer，兼当「关于」收尾） ——
+        // —— 帮助：支持与鼓励（图标行 + 检测更新 + star，兼当「关于」收尾） ——
         h("div", { className: "mneme-set-grouphead" }, t("memory.settings.group.help")),
         // 反馈三入口：新建 issue 预填（版本+平台）/ 邮件 / 浏览已知问题。
         // 纯前端链接零后端成本；插件版本来自 /info，平台取 userAgent。GitHub
@@ -3433,6 +4178,21 @@ window.__ModuleLoader__.load({
             feedRow("search", t("memory.settings.feedback.browse"), t("memory.settings.feedback.browse.sub"),
               { href: "https://github.com/slow-stack/mneme/issues", target: "_blank", rel: "noopener noreferrer" })
           ),
+          // 检测更新：手动触发（复验修订——原顶部自动横幅移除），结果内联；
+          // outdated 时提示带 pnpm 钉子警示（#174 报障成因）。
+          h("div", { style: { display: "flex", alignItems: "center", gap: 8, marginTop: 12 } },
+            h("button", { className: "mneme-btn", onClick: checkForUpdate, disabled: updateChecking },
+              updateChecking ? "…" : t("memory.settings.update.check")),
+            updateInfo && h("span", { className: "mneme-feedsub" }, checkResultText())
+          ),
+          updateInfo?.status === "outdated" && h("div", { className: "mneme-set-hint", style: { marginTop: 8 } },
+            t("memory.settings.version.outdatedHint")),
+          // star 鼓励入口：链接到仓库主页而非 stargazers——前者右上角就有
+          // Star 按钮，后者只是「看谁点过」的名单页（复验实测反馈）。
+          h("div", { className: "mneme-feedlist", style: { marginTop: 12 } },
+            feedRow("star", t("memory.settings.star"), t("memory.settings.star.sub"),
+              { href: "https://github.com/slow-stack/mneme", target: "_blank", rel: "noopener noreferrer" })
+          ),
           h("div", { className: "mneme-set-foot" },
             h("span", null, `dsh-mneme v${pkgVersion}`)
           )
@@ -4118,7 +4878,18 @@ window.__ModuleLoader__.load({
       if (n >= 1e3) return `${Math.round(n / 1e3)}K`;
       return String(n);
     };
-    const heatLevel = (n) => (n > 2500000 ? 4 : n > 1500000 ? 3 : n > 750000 ? 2 : n > 0 ? 1 : 0);
+    // 热力分档：固定阈值（75万/150万/250万）在低用量库里整片落在 l1，档位失真
+    // （复验第三轮「颜色不怎么明显」）。改按 56 天窗口内的非零日做三分位切四档
+    // ——GitHub 贡献图同思路，档次随库的实际用量自适应拉开；全零/无数据退化
+    // 为全 0 档（不留空档位）。边界是三个分位值（q 只返回 3 个）：n>p75 → l4、
+    // >p50 → l3、>p25 → l2、其余非零 → l1，四档都有 populated。
+    const heatLevel = (n, q) => (n <= 0 ? 0 : n > q[2] ? 4 : n > q[1] ? 3 : n > q[0] ? 2 : 1);
+    const heatQuartiles = (days) => {
+      const pos = days.map((d) => d.total).filter((v) => v > 0).sort((a, b) => a - b);
+      if (!pos.length) return [0, 0, 0];
+      const pick = (p) => pos[Math.min(pos.length - 1, Math.floor(p * pos.length))];
+      return [pick(0.25), pick(0.5), pick(0.75)];
+    };
 
     function TokenFlowSection({ t }) {
       const [stats, setStats] = useState(null);
@@ -4228,6 +4999,33 @@ window.__ModuleLoader__.load({
           heatCells.push({ key, total: byDayMap.get(key) ?? 0 });
         }
       }
+      // 分档阈值取自本窗口真实分布（见 heatQuartiles 注释），空窗口退化全 0 档。
+      const heatQ = heatQuartiles(heatCells);
+      // 月份标签：GitHub 同款——按周列贴，列首日期属于哪个月，那列就标那个
+      // 月；连续同月的列合并成一段（gridColumn: from / span）。月不在列首
+      // 开始时其首列仍标上一月（列首归属优先），这是贡献图的通行近似。
+      const monthLabels = (() => {
+        if (!heatCells.length) return [];
+        const spans = [];
+        heatCells.forEach((c, i) => {
+          if (i % 7 !== 0) return; // 只看列首
+          const ym = c.key.slice(0, 7);
+          const col = Math.floor(i / 7) + 1;
+          const label = `${Number(ym.slice(5, 7))}月`;
+          const lastSpan = spans[spans.length - 1];
+          if (lastSpan && lastSpan.key === ym) { lastSpan.last = col; return; }
+          spans.push({ key: ym, label, from: col, last: col });
+        });
+        return spans.map((m) => ({ ...m, span: m.last - m.from + 1 }));
+      })();
+      // 行标签：行 r 的星期 = (首列星期 + r) % 7（getUTCDay 周日=0）。一/三/五
+      // 三行有字（GitHub 同款），其余留空。
+      const heatRowLabels = (() => {
+        const startDow = heatCells.length ? new Date(`${heatCells[0].key}T00:00:00Z`).getUTCDay() : 0;
+        const rows = new Array(7).fill("");
+        for (const d of [1, 3, 5]) rows[(d - startDow + 7) % 7] = ["一", "三", "五"][[1, 3, 5].indexOf(d)];
+        return rows;
+      })();
       const kpi = (title, num, cap) =>
         h(StatusCard, { t, title, loading, error: statsError, num, cap });
       const segClass = (s) =>
@@ -4321,12 +5119,22 @@ window.__ModuleLoader__.load({
             days.map((d) => h("span", { key: d.day }, d.day.slice(5)))
           ),
           h("h3", { className: "mneme-xcolhead" }, t("memory.status.token.heat")),
-          h("div", { className: "mneme-heatgrid" },
-            heatCells.map((c) => h("div", {
-              key: c.key,
-              className: heatLevel(c.total) ? `mneme-heatcell l${heatLevel(c.total)}` : "mneme-heatcell",
-              title: `${c.key} · ${c.total.toLocaleString()}`
-            }))
+          // 月份行与格子列同用列主序网格对齐：每月占的列数 = 该月在这个
+          // 56 天窗口里的列数（按列的起始日期算），标签只在该列起点画一次。
+          h("div", { className: "mneme-heatmonths" },
+            monthLabels.map((m) => h("span", { key: m.key, style: { gridColumn: `${m.from} / span ${m.span}` } }, m.label))
+          ),
+          h("div", { className: "mneme-heatwrap" },
+            h("div", { className: "mneme-heatrows", "aria-hidden": "true" },
+              heatRowLabels.map((d, i) => h("span", { key: i }, d))
+            ),
+            h("div", { className: "mneme-heatgrid" },
+              heatCells.map((c) => h("div", {
+                key: c.key,
+                className: heatLevel(c.total, heatQ) ? `mneme-heatcell l${heatLevel(c.total, heatQ)}` : "mneme-heatcell",
+                title: `${c.key} · ${c.total.toLocaleString()}`
+              }))
+            )
           ),
           h("div", { className: "mneme-heatlegend" },
             h("span", null, t("memory.status.token.heatLess")),
@@ -5805,6 +6613,9 @@ window.__ModuleLoader__.load({
           ),
         ),
         view === "memory" && h("div", { className: "mneme-xmain" },
+          // 两栏布局（桉桉规格）：左栏上段=语义检索（怎么搜），下段=重要性/
+          // 来源/热度（留什么）；原第二侧栏的类型列表与计数刷新下沉到内容区
+          // 工具条（.mneme-xbrowsebar），五个功能入口一个不丢。
           h("div", { className: "mneme-xside" },
             h("div", { className: "mneme-xcolhead" }, t("memory.explorer.searchTitle")),
             h("div", { className: "mneme-xsearchwrap" },
@@ -5845,39 +6656,28 @@ window.__ModuleLoader__.load({
                 ["all", "7d", "30d", "90d"].map((k) =>
                   h("option", { key: k, value: k }, t(`memory.explorer.date.${k}`))))
             ),
-            h("div", { className: "mneme-xrow" },
-              h("span", { className: "mneme-xcount" }, t("memory.explorer.count").replace("{n}", String(visible.length))),
-              h("button", { className: "mneme-footbtn", onClick: () => setReloadKey((k) => k + 1) },
-                h(Icon, { name: "refresh", size: 12 }), t("memory.explorer.refresh"))
-            )
-          ),
-          h("div", { className: "mneme-xside mneme-xside--filter" },
-            h("div", { className: "mneme-xcolhead" }, t("memory.explorer.importance")),
-            h("div", { className: "mneme-xrow" },
-              [0, 3, 4, 5].map((v) =>
-                h("button", {
-                  key: v,
-                  className: minImp === v ? "mneme-chip mneme-active" : "mneme-chip",
-                  onClick: () => setMinImp(v)
-                }, v === 0 ? t("memory.tab.all") : h(react.Fragment, null, h(StarGlyph, { size: 11 }), ` ${v}+`)))
-            ),
-            h("div", { className: "mneme-xcolhead" }, t("memory.explorer.sourceFilter")),
-            h("div", { className: "mneme-xrow" },
-              h("button", {
-                className: depositedOnly ? "mneme-chip mneme-active" : "mneme-chip",
-                title: t("memory.explorer.filterDepositedHint"),
-                onClick: () => setDepositedOnly(!depositedOnly)
-              }, t("memory.explorer.filterDeposited")),
-              h("button", {
-                className: archivedOnly ? "mneme-chip mneme-active" : "mneme-chip",
-                title: t("memory.explorer.filterArchivedHint"),
-                onClick: () => setArchivedOnly(!archivedOnly)
-              }, t("memory.explorer.filterArchived"))
-            ),
-            heatAvailable && h(react.Fragment, null,
-              h("div", { className: "mneme-xcolhead" }, t("memory.explorer.sort")),
+            h("div", { className: "mneme-xside-imp" },
+              h("div", { className: "mneme-xcolhead" }, t("memory.explorer.importance")),
               h("div", { className: "mneme-xrow" },
+                [0, 3, 4, 5].map((v) =>
+                  h("button", {
+                    key: v,
+                    className: minImp === v ? "mneme-chip mneme-active" : "mneme-chip",
+                    onClick: () => setMinImp(v)
+                  }, v === 0 ? t("memory.tab.all") : h(react.Fragment, null, h(StarGlyph, { size: 11 }), ` ${v}+`)))
+              ),
+              h("div", { className: "mneme-xrow" },
+                h("button", {
+                  className: depositedOnly ? "mneme-chip mneme-active" : "mneme-chip",
+                  title: t("memory.explorer.filterDepositedHint"),
+                  onClick: () => setDepositedOnly(!depositedOnly)
+                }, t("memory.explorer.filterDeposited")),
                 h("button", {
+                  className: archivedOnly ? "mneme-chip mneme-active" : "mneme-chip",
+                  title: t("memory.explorer.filterArchivedHint"),
+                  onClick: () => setArchivedOnly(!archivedOnly)
+                }, t("memory.explorer.filterArchived")),
+                heatAvailable && h("button", {
                   className: heatSort ? "mneme-chip mneme-active" : "mneme-chip",
                   title: t("memory.explorer.heatSortHint"),
                   onClick: () => {
@@ -5886,23 +6686,28 @@ window.__ModuleLoader__.load({
                   }
                 }, t("memory.explorer.heatSort"))
               )
-            ),
-            h("div", { className: "mneme-xcolhead" }, t("memory.explorer.types")),
-            h("button", {
-              className: type === "all" ? "mneme-xtype mneme-active" : "mneme-xtype",
-              onClick: () => setType("all")
-            }, h("span", { className: "mneme-xdot mneme-xdot--all", "aria-hidden": "true" }), h("span", null, t("memory.tab.all")), h("span", { className: "mneme-xcount2" }, String(items.length))),
-            knownTypes.concat(extraTypes).map((key) =>
-              h("button", {
-                key,
-                className: type === key ? "mneme-xtype mneme-active" : "mneme-xtype",
-                onClick: () => setType(key)
-              },
-                h("span", { className: "mneme-xdot", style: { color: memoryTypeColor(key) }, title: typeLabel(t, key), "aria-hidden": "true" }),
-                h("span", null, typeLabel(t, key)),
-                h("span", { className: "mneme-xcount2" }, String(counts[key]))
-              ))
+            )
           ),
+          h("div", { className: "mneme-xcontent" },
+            h("div", { className: "mneme-xbrowsebar" },
+              h("button", {
+                className: type === "all" ? "mneme-xtype mneme-active" : "mneme-xtype",
+                onClick: () => setType("all")
+              }, h("span", { className: "mneme-xdot mneme-xdot--all", "aria-hidden": "true" }), h("span", null, t("memory.tab.all")), h("span", { className: "mneme-xcount2" }, String(items.length))),
+              knownTypes.concat(extraTypes).map((key) =>
+                h("button", {
+                  key,
+                  className: type === key ? "mneme-xtype mneme-active" : "mneme-xtype",
+                  onClick: () => setType(key)
+                },
+                  h("span", { className: "mneme-xdot", style: { color: memoryTypeColor(key) }, title: typeLabel(t, key), "aria-hidden": "true" }),
+                  h("span", null, typeLabel(t, key)),
+                  h("span", { className: "mneme-xcount2" }, String(counts[key]))
+                )),
+              h("span", { className: "mneme-xcount", style: { marginLeft: "auto" } }, t("memory.explorer.count").replace("{n}", String(visible.length))),
+              h("button", { className: "mneme-footbtn", onClick: () => setReloadKey((k) => k + 1) },
+                h(Icon, { name: "refresh", size: 12 }), t("memory.explorer.refresh"))
+            ),
           viewMode === "cards"
             ? h("div", { className: "mneme-cards" },
                 loading
@@ -6007,8 +6812,11 @@ window.__ModuleLoader__.load({
               )
             ),
             ),
+          ),
       // 详情抽屉：卡片/时间线共用，选中即从右侧滑出（替代旧底部面板）。
       // 两步删除确认在抽屉内完成；编辑/归档经 /update 落库并同步本地视图。
+      // 保持为 .mneme-xmain 直接子元素：抽屉锚在 xmain 的 relative 层上，随
+      // 两栏改版内容区变宽，抽屉锚点不变。
       selected && h(MemoryDrawer, {
         key: selected.id,
         t,
@@ -6274,6 +7082,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 +8192,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;
@@ -6352,3 +8219,7 @@ window.__ModuleLoader__.load({
     return module.exports;
   }
 });
+
+
+
+