@a9i5k4/dsh-auto-memory 3.0.0 → 3.1.0

package/lib/client.js

@@ -7,7 +7,7 @@
  *   3. settings.section      — 自动记忆设置页(存储位置、注入、反思风格)
  * Data flows over /api/dsh-auto-memory/* (loopback-only host routes).
  */
-console.log('[dsh-auto-memory] client v3.0.0 fingerprint: index-self-heal')
+console.log('[dsh-auto-memory] client v3.1.0 fingerprint: promotion-override')
 window.__ModuleLoader__.load({
   id: '@a9i5k4/dsh-auto-memory',
   factory: (require) => {
@@ -43,6 +43,21 @@ window.__ModuleLoader__.load({
     try { pinned = localStorage.getItem(PIN_KEY) === '1' } catch (ePin) {}
     // 几何状态:left/top/width/height,持久化到 localStorage(用户可拖动/缩放)
     var GEOM_KEY = 'dsh-auto-memory.panel.geom'
+    // 承载面(2026-09-21 用户拍板 · 二次修正):'bottom-left'(默认,左下角浮层) | 'page'(会话页) | 'both'(两者共存)。
+    // ★修正原因(用户实测反馈原话):「它现在是浮在整个页面上方的,而不是和对话轨迹、上下文、白板看板在一起,作为一个单独的一页」。
+    //   根因:首版把「顶部」做成 shell.overlay 覆盖条 —— 宿主只给插件 4 个槽位(sidebar/main/rightbar/shell.overlay),
+    //   浮层永远只能"盖"在界面上,做不出"并列的一页";要成为并列页必须走 conversation.view
+    //   (官方「对话轨迹」dsh-client-ui-trajectory 与本插件「白板看板」都用它注册)。
+    // 两种承载面共享同一份内容/页签/数据(见下面的 panelTab 共享状态);本机偏好,仅 localStorage。
+    var POS_KEY = 'dsh-auto-memory.panel.pos'
+    var PANEL_POS_VALUES = { 'bottom-left': 1, page: 1, both: 1 }
+    var panelPos = 'both'
+    try {
+      var savedPos = localStorage.getItem(POS_KEY)
+      // 兼容上一版:旧值 'top'(覆盖条形态)已废弃 ⇒ 自动迁移为 'page'(会话页形态),用户不必手动重选
+      if (savedPos === 'top') savedPos = 'page'
+      if (PANEL_POS_VALUES[savedPos]) panelPos = savedPos
+    } catch (ePos) {}
     var DEFAULT_W = 440
     var DEFAULT_H = 560
     var DEFAULT_GAP = 16
@@ -117,6 +132,16 @@ window.__ModuleLoader__.load({
       return null
     }
     function emit() { listeners.forEach(function (fn) { try { fn() } catch (e) {} }) }
+    // 共享页签状态(2026-09-21):浮层与「记忆」会话页读同一个模块级变量 ⇒ 两处切页互相同步
+    // (用户诉求原话:「两者共存…要保证同步」)。不用两份 useState,从根上杜绝状态漂移。
+    // 两个承载面都订阅 emit()(走 useTick),所以 setPanelTab 只要 emit 就能让两处同时重渲染。
+    var panelTab = 'overview'
+    function setPanelTab(v) { if (panelTab !== v) { panelTab = v; emit() } }
+    // 承载面切换钩子(2026-09-21):conversation.view 的注册/注销在 apply 作用域内(refreshSurfaces),
+    // 而 setPanelPos 在本模块作用域 ⇒ 用一个模块级钩子搭桥:切到「会话页/两者」时当场把页签加上,
+    // 切回「左下角浮层」时把它摘掉(不必等重启或重进会话)。
+    var surfacesRefreshHook = null
+    function setSurfacesRefreshHook(fn) { surfacesRefreshHook = fn }
     var controller = {
       isOpen: function () { return panelOpen },
       isClosing: function () { return panelClosing },
@@ -155,6 +180,22 @@ window.__ModuleLoader__.load({
         try { localStorage.setItem(PIN_KEY, pinned ? '1' : '0') } catch (e) {}
         emit()
       },
+      // 承载面(2026-09-21):左下角浮层 / 会话页 / 两者共存。设置页改动立即生效(即时回显)。
+      panelPos: function () { return panelPos },
+      setPanelPos: function (v) {
+        panelPos = PANEL_POS_VALUES[v] ? v : 'both'
+        try { localStorage.setItem(POS_KEY, panelPos) } catch (e) {}
+        // 承载面切换要即时增删「记忆」会话页签(见 setSurfacesRefreshHook 的说明)
+        try { if (surfacesRefreshHook) surfacesRefreshHook() } catch (eRf) {}
+        // 即时回显(2026-09-21 用户实测:「切到两者共存后上面什么都没出现」):
+        // 位置改在设置页里,而面板若关着,整个 MemoryPanel 渲染 null ⇒ 用户看不到任何变化。
+        // 故切档时面板若关着就自动打开,让新位置当场可见(切回旧档同样打开,保证每次切换都可感知)。
+        if (!panelOpen) controller.open()
+        else emit()
+      },
+      // 共享页签(浮层 ↔ 会话页)
+      panelTab: function () { return panelTab },
+      setPanelTab: setPanelTab,
     }
 
     // ───────────────────────── 国际化 ─────────────────────────
@@ -216,6 +257,10 @@ window.__ModuleLoader__.load({
         kvAvail: '可用', kvUnavail: '不可用', kvDup: '项目笔记重复标题', kvDupCount: ' 个',
         kvMem: '记忆文件', kvMemUser: '用户', kvMemNotes: '笔记', kvMemLog: '日志', kvMemMissing: '缺失',
         kvWs: '当前工作区', kvWsUnknown: '(未取到)', kvApi: 'API 连通', unknown: '(未知)',
+        // ★P0-2/P0-3（2026-09-22）：把后端早已算好、前端零消费者的两组可观测性接到界面上。
+        dbgHubIo: '三层记忆落盘', dbgPrune: '事实淘汰(保留上限)',
+        kvPyTitle: 'Python 语义侧车', kvPyOff: '未启用（JS 端语义不受影响）', kvPyAlive: '运行中',
+        kvPyWatchdog: '看门狗击杀 / 重生', kvPyStderr: '最近 stderr 尾部', kvPyStderrTrunc: '（已截断）',
         updateTitle: 'dsh-auto-memory 已更新', updateSub: '本次更新内容:', gotIt: '知道了', noticeOpen: '了解更多',
         refresh: '刷新', refreshing: '刷新中…', close: '关闭', dragMove: '拖动移动', dragResize: '拖动调整大小', resetPos: '恢复默认位置', pinPanel: '钉住面板(点桌面其他地方不收起)', unpinPanel: '取消钉住(点面板外自动收起)',
         generated: '已生成', failed: '失败: ',
@@ -237,6 +282,44 @@ window.__ModuleLoader__.load({
         empty: '(空)', back: '← 返回', view: '查看',
         clickDateViewLog: '点击日期查看当日日志(append-only):',
         userMemoryBlock: '用户记忆(用户画像 · 跨项目):', userMemoryEmpty: '(空)', userMemoryTruncated: '(内容过长,已截断显示)',
+    // ★R7：硬性约束编辑面板文案
+    // ★R1–R6：审批界面可读性文案
+    hubStageObserved: '刚观察到',
+    hubStageCandidate: '够格待审',
+    hubStageValidated: '已通过验证',
+    hubStageActive: '已启用',
+    hubStageDeprecated: '已弃用',
+    hubWhyTitle: '为什么还不能晋升：',
+    hubWhyCanPromote: '条件已满足，可以晋升。',
+    hubWhyDiversity: function (d, need) { return '需要 ' + need + ' 个不同会话都用过它，目前只有 ' + d + ' 个 —— 换个场景再用一次它就能推进。' },
+    hubWhySuccess: function (n, need) { return '需要成功 ' + need + ' 次，目前 ' + n + ' 次 —— 再成功用一次它会自动变好。' },
+    hubWhyCorrectionRate: function (r, cap) { return '它的纠正率是 ' + r + '，超过了上限 ' + cap + ' —— 说明这套流程本身有问题，需要先改掉。' },
+    hubWhyHasCorrection: function (n) { return '它被纠正过 ' + n + ' 次 —— 有纠正记录说明这流程是错的，不能固化。' },
+    hubWhyNoCriteria: '它没写「怎么算成功」—— 没有验收标准的流程不算技能。',
+    hubWhyHighRisk: '它是高风险操作，需要你人工确认才会固化 —— 点下面这个「批准(人工)」即可。',
+    hubWhyObservationOnly: '它只是「看到过一件事」的线索，不是真正的流程 —— 不会自动晋升。',
+    // ★C（2026-09-22）：三态说清 —— 「没有按钮」必须自己解释清楚，而不是让用户猜。
+    hubWhyStructural: '这道门是结构性的（内容本身不构成一条技能），人工也不能越过；补齐内容才会重新判定。',
+    hubWhyOverridable: '以上只是「证据还没攒够」的统计门，不是内容不合格 —— 你可以点右侧按钮人工越过。',
+    hubForcePromote: '强制晋升（人工）',
+    hubForcePromoteTitle: '人工越过跨会话数/成功次数两道统计门。结构门不会越过，且会在条目上留下「人工授权」痕迹。',
+    hubEvSeen: '见过', hubEvSuccess: '成功', hubEvSessions: '跨会话', hubEvReuse: '被复用', hubEvCorrection: '被纠正',
+    hubEvLine: function (ev) { return '见过 ' + (ev.seen || 0) + ' 次 · 成功 ' + (ev.success || 0) + ' 次 · 在 ' + (ev.sessions || 0) + ' 个会话里用过' + ((ev.correction || 0) ? ' · 被纠正过 ' + ev.correction + ' 次' : '') },
+    hubInjectPreview: '晋升后会注入这些（点开看）',
+    hubInjectCriteria: '验收标准：',
+    hubNoSteps: '(这条没有可用步骤——源头是机械截断，不是真流程)',
+    rulesTitle: '硬性约束（每轮必注入）',
+    rulesIntro: '这些条目每一轮都会原封不动发给我，优先级高于其它内容。它不走检索、不会自动淘汰，所以过时的、或 AI 自己加错的，都要你手动改。',
+    rulesPath: '来源文件：',
+    rulesEmpty: '(暂无条目)',
+    rulesSourceUser: '你写的',
+    rulesSourceAi: 'AI 加的',
+    rulesEdit: '编辑', rulesSave: '保存', rulesCancel: '取消', rulesDelete: '删除',
+    rulesConfirmDelete: '确认删除这条约束？\n\n删除后无法撤销——它下一轮就不再注入了。',
+    rulesAddHint: '新增一条约束：',
+    rulesAddPlaceholder: '例：未经我确认，不要自动修改生产环境的文件。',
+    rulesAdd: '添加',
+    rulesPreviewHint: '预览：下一轮注入时会变成这样',
         appended: '已追加', notesPathLabel: '项目笔记: ',
         notesPlaceholder: '想追加到项目笔记的内容…(保存时自动带日期标题)',
         saving: '保存中…', append: '追加',
@@ -260,13 +343,15 @@ window.__ModuleLoader__.load({
         saved: '已保存',
         settingsHeader: '记忆存储与行为设置(保存到 DSH 主目录 dsh-auto-memory.json):',
         fFontSize: '界面字号', fFontSizeHint: '记忆面板文字大小(立即生效,仅本机)', fsSm: '小', fsMd: '标准', fsLg: '大', fsXl: '特大',
+        fPanelPos: '记忆承载面', fPanelPosHint: '记忆内容的呈现方式:左下角浮层(可拖动缩放)/ 会话页(与「对话轨迹」「上下文」并列的一页,在会话页顶栏切换)/ 两者共存。两种承载面共享同一份内容与页签,实时同步;仅本机生效。',
+        posBottomLeft: '左下角(浮层)', posPage: '会话页(与对话轨迹并列)', posBoth: '两者共存',
         fUserDir: '用户记忆目录', fUserDirHint: '跨项目规则存放处,支持 ~ 开头;需有文件写权限。',
         fProjectDir: '项目记忆目录', fProjectDirHint: '相对各工作区的目录名(默认 .dsh-memory)。',
         fInject: '注入记忆上下文', fInjectHint: '每次组装提示词时自动注入 <memory_system> 块。',
         fBudget: '注入预算(字符)', fBudgetHint: '记忆块总预算,超出部分截断。默认 1600(≈400-600 token/轮);活跃会话每轮都注入这段背景,调低更省 token,调高保留更多记忆。',
         fExclude: '排除来源(每行一条)', fExcludeHint: '这些来源不再进注入,避免坏记忆反复灌入把结果一路带偏。四种写法:记忆 id(mem_xxx)、整层(log/whiteboard/project/user/reflection)、目录前缀(以 / 或 \\ 结尾)、精确文件路径。与 supersede 互补:supersede 管"被新版替代",这里管"整条来源不可信"。被挡下的条数会在注入里以 [降级] 如实标注。',
-        fNoteCap: '项目笔记容量上限(字符)', fNoteCapHint: '项目笔记 MEMORY.md 的容量上限,默认 12000。超出时自动整理:先把较早内容交给模型折叠成要点,失败则退回整条归档(原文进 archive,不丢)——新记忆不会被堵在外面。注意与上面的「注入预算」不是一回事:这个管文件本体大小,注入预算管每轮往上下文塞多少摘要。',
-        fUserCap: '用户级记忆容量上限(字符)', fUserCapHint: '用户级 MEMORY.md(跨项目规则)的容量上限,默认 12000。整理方式与项目笔记相同(先折叠成要点,必要时整条归档)。',
+        fNoteCap: '项目笔记容量上限(字符)', fNoteCapHint: '项目笔记 MEMORY.md 的容量上限,默认 24000。超出时自动整理:先把较早内容交给模型折叠成要点,失败则退回整条归档(原文进 archive,不丢)——新记忆不会被堵在外面。注意与上面的「注入预算」不是一回事:这个管文件本体大小,注入预算管每轮往上下文塞多少摘要。',
+        fUserCap: '用户级记忆容量上限(字符)', fUserCapHint: '用户级 MEMORY.md(跨项目规则)的容量上限,默认 24000。整理方式与项目笔记相同(先折叠成要点,必要时整条归档)。',
         fSnapGap: '快照最小间隔(轮)', fSnapGapHint: '动态记忆快照内容变化后,至少隔 N 轮才重新注入,避免每轮日志微变都追加快照导致历史膨胀。默认 5;0=每轮都尝试(仍受内容变化约束)。',
         fReinjectOnCompact: '压缩后立即重注入快照', fReinjectOnCompactHint: '上下文被压缩/截断(通常伴随 contextVersion 重置)后,快照会被清掉;开启后强制立即重注入一次,确保记忆背景重建。默认开。',
         fPromptCustom: '自定义记忆注入 prompt', fPromptCustomHint: '可覆盖各层提示文案(小众功能)。支持占位符 {date} {ws} {budget} {n}。改坏了可一键恢复默认。',
@@ -292,6 +377,14 @@ window.__ModuleLoader__.load({
         fWaterAuto: '水位自动骨架账本', fWaterAutoHint: '越阈时自动写一篇系统骨架账本(每会话一次),防止模型忽视建议时交接材料缺失。',
         fWaterThreshold: '水位建议阈值', fWaterThresholdHint: '水位比例 = 上下文实占 ÷ 官方声明窗口(不再扣预留输出);超过该值(0.1-1.5)即触发交接建议/骨架账本;默认 0.75——官方自动压缩阈值是 80%,必须留出余量才来得及走完交接。',
         fHandoffPlan: '白板注入预算(字符)', fHandoffPlanHint: 'PLAN.md 全貌注入动态快照的硬截断预算;全文可经 memory_read 或面板白板页查看。默认 1200。',
+        fProcInject: '流程记忆注入(总闸)', fProcInjectHint: '★流程记忆(技能固化)的总闸:关闭后既不写入流程记忆,也不把它注入提示词。默认开。注意:设置页此前的旧键「技能固化与晋升」宿主已不再读取,要改请改这一项。',
+        fFactRetention: '事实条数上限', fFactRetentionHint: '事实层最多保留多少条,超出时自动淘汰:先淘汰已撤销的,再按写入时间从旧到新,重要项(置顶 / 用户级 / 显式写入 / 高置信度)最后淘汰。默认 1000。',
+        fTier0Catalog: '目录层(Tier-0 摘要)', fTier0CatalogHint: '开启时每轮注入一段「记忆目录」摘要(条目名 + 一句话结论),让模型先看到全局再按需下探;关闭则完全不注入目录层,省 token。默认开。',
+        fTier0Max: '目录层 token 上限', fTier0MaxHint: '目录层单次注入的 token 硬上限(与「注入预算 × 目录层占比」取小生效)。默认 400。需要装下更多语料时提高这里,而不是把注入预算整体推高。',
+        fRulesLayering: '规则段分层', fRulesLayeringHint: '开启后规则类记忆单独成段、每轮在场且不参与裁剪(旧行为是把规则混进记忆流一起裁)。关闭 = 完全回到旧行为。默认开。',
+        fCriteriaGate: '账本判据门', fCriteriaGateHint: '开启时白板/账本小节必须满足判据(H1-H4 / S1-S4)才被采纳,防止把思考过程当结论固化。关闭只退掉这道质量门,骨架 fail-soft 仍无条件生效。默认开。',
+        fWsDiscover: '工作区发现上限', fWsDiscoverHint: '扫描本机会话时最多识别多少个工作区(按最近会话时间降序取前 N 个)。默认 200;机器上历史工作区很多时可调小以缩短扫描时间。',
+        fMemFileIndex: '记忆文件索引快照', fMemFileIndexHint: '开启后额外维护一份只读的记忆文件索引快照(供外部查询),有少量 IO 开销;默认关,关时零额外开销。',
         fHandoffLedger: '账本注入预算(字符)', fHandoffLedgerHint: '最新一篇交接账本注入动态快照的硬截断预算。默认 800。',
         fConsSchedule: '定时做梦式固化', fConsScheduleHint: '每天到点自动读最近日志发散提炼长期要点,写入项目笔记/用户级记忆(等价 memory_consolidate)。',
         fConsScheduleTime: '固化触发时间', fConsScheduleTimeHint: 'HH:MM,插件日界内每天一次;默认 09:30。命中时刻需宿主在线。',
@@ -370,6 +463,9 @@ window.__ModuleLoader__.load({
       kvAvail: 'available', kvUnavail: 'unavailable', kvDup: 'Duplicate note headings', kvDupCount: '',
       kvMem: 'Memory files', kvMemUser: 'user', kvMemNotes: 'notes', kvMemLog: 'log', kvMemMissing: 'missing',
       kvWs: 'Current workspace', kvWsUnknown: '(unknown)', kvApi: 'API probes', unknown: '(unknown)',
+      dbgHubIo: 'Layer-3 memory persistence', dbgPrune: 'Fact eviction (retention cap)',
+      kvPyTitle: 'Python sidecar', kvPyOff: 'disabled (JS-side semantics unaffected)', kvPyAlive: 'running',
+      kvPyWatchdog: 'Watchdog kills / respawns', kvPyStderr: 'Last stderr tail', kvPyStderrTrunc: ' (truncated)',
       updateTitle: 'dsh-auto-memory Updated', updateSub: 'What\'s new in this update:', gotIt: 'Got it', noticeOpen: 'Learn more',
         refresh: 'Refresh', refreshing: 'Refreshing…', close: 'Close', dragMove: 'Drag to move', dragResize: 'Drag to resize', resetPos: 'Reset position', pinPanel: 'Pin panel (stays open when clicking elsewhere)', unpinPanel: 'Unpin (auto-hide on outside click)',
         generated: 'Generated', failed: 'Failed: ',
@@ -391,6 +487,41 @@ window.__ModuleLoader__.load({
         empty: '(empty)', back: '← Back', view: 'View',
         clickDateViewLog: 'Click a date to view the daily log (append-only):',
         userMemoryBlock: 'User memory (profile · cross-project):', userMemoryEmpty: '(empty)', userMemoryTruncated: '(content truncated for display)',
+    hubStageObserved: 'observed',
+    hubStageCandidate: 'candidate',
+    hubStageValidated: 'validated',
+    hubStageActive: 'active',
+    hubStageDeprecated: 'deprecated',
+    hubWhyTitle: 'Why it cannot be promoted yet: ',
+    hubWhyCanPromote: 'All conditions met — ready to promote.',
+    hubWhyDiversity: function (d, need) { return 'Needs ' + need + ' distinct sessions, currently ' + d + '.' },
+    hubWhySuccess: function (n, need) { return 'Needs ' + need + ' successes, currently ' + n + '.' },
+    hubWhyCorrectionRate: function (r, cap) { return 'Correction rate ' + r + ' exceeds cap ' + cap + '.' },
+    hubWhyHasCorrection: function (n) { return 'Has ' + n + ' correction(s) — a corrected flow must not be crystallized.' },
+    hubWhyNoCriteria: 'No success criteria — a flow without acceptance criteria is not a skill.',
+    hubWhyHighRisk: 'High risk — it needs your manual approval. Click "approve (manual)" below to crystallize it.',
+    hubWhyObservationOnly: 'This is an observation, not a real flow — it never auto-promotes.',
+    hubWhyStructural: 'This gate is structural (the entry is not a skill yet) — a human cannot override it either. Fill in the content and it gets re-evaluated.',
+    hubWhyOverridable: 'The above is only a statistical gate (not enough evidence yet), not a content failure — you can override it with the button on the right.',
+    hubForcePromote: 'Force promote (manual)',
+    hubForcePromoteTitle: 'Manually bypass the cross-session / success-count statistical gates. Structural gates are NOT bypassed, and a "manual authorization" trace is left on the entry.',
+    hubEvSeen: 'seen', hubEvSuccess: 'success', hubEvSessions: 'sessions', hubEvReuse: 'reused', hubEvCorrection: 'corrected',
+    hubEvLine: function (ev) { return 'seen ' + (ev.seen || 0) + ' · success ' + (ev.success || 0) + ' · used in ' + (ev.sessions || 0) + ' session(s)' + ((ev.correction || 0) ? ' · corrected ' + ev.correction + 'x' : '') },
+    hubInjectPreview: 'This is what gets injected once promoted',
+    hubInjectCriteria: 'Acceptance criteria: ',
+    hubNoSteps: '(no usable steps — mechanically truncated, not a real flow)',
+    rulesTitle: 'Hard constraints (injected every turn)',
+    rulesIntro: 'These entries are sent to the model verbatim on every turn and outrank other content. They bypass retrieval and are never auto-retired, so outdated or AI-added ones must be edited by hand.',
+    rulesPath: 'Source file: ',
+    rulesEmpty: '(none)',
+    rulesSourceUser: 'yours',
+    rulesSourceAi: 'added by AI',
+    rulesEdit: 'Edit', rulesSave: 'Save', rulesCancel: 'Cancel', rulesDelete: 'Delete',
+    rulesConfirmDelete: 'Delete this constraint?\n\nThis cannot be undone — it will stop being injected next turn.',
+    rulesAddHint: 'Add a constraint:',
+    rulesAddPlaceholder: 'e.g. Do not modify production files without my confirmation.',
+    rulesAdd: 'Add',
+    rulesPreviewHint: 'Preview: how it will be injected next turn',
         appended: 'Appended', notesPathLabel: 'Project notes: ',
         notesPlaceholder: 'Content to append to project notes…(date heading added on save)',
         saving: 'Saving…', append: 'Append',
@@ -414,13 +545,15 @@ window.__ModuleLoader__.load({
         saved: 'Saved',
         settingsHeader: 'Memory storage & behavior (saved to ~/.dsh/dsh-auto-memory.json):',
         fFontSize: 'Panel font size', fFontSizeHint: 'Memory panel text size (applies immediately, this device only)', fsSm: 'Small', fsMd: 'Normal', fsLg: 'Large', fsXl: 'Extra large',
+        fPanelPos: 'Memory surface', fPanelPosHint: 'How memory content is presented: bottom-left floating card (draggable/resizable), a session page (a tab alongside "Trajectory"/"Context" in the conversation header), or both. Both surfaces share the same content and tabs, live-synced; this device only.',
+        posBottomLeft: 'Bottom-left (floating)', posPage: 'Session page (alongside Trajectory)', posBoth: 'Both, side by side',
         fUserDir: 'User memory dir', fUserDirHint: 'Cross-project rules; supports ~ prefix; needs write permission.',
         fProjectDir: 'Project memory dir', fProjectDirHint: 'Directory name relative to each workspace (default .dsh-memory).',
         fInject: 'Inject memory context', fInjectHint: 'Auto-inject <memory_system> block into every prompt.',
         fBudget: 'Injection budget (chars)', fBudgetHint: 'Total budget for the memory block; excess is truncated. Default 1600 (~400-600 tokens/turn); this background is injected every turn, so lower = fewer tokens, higher = more memory retained.',
         fExclude: 'Excluded sources (one per line)', fExcludeHint: 'These sources never enter injection again, so a bad memory cannot keep steering the result. Four forms: memory id (mem_xxx), whole layer (log/whiteboard/project/user/reflection), directory prefix (ending in / or \\), exact file path. Complements supersede: supersede covers "replaced by a newer version", this covers "this source is untrustworthy". Blocked counts are reported as a [降级] line, never silently.',
-        fNoteCap: 'Project note capacity (chars)', fNoteCapHint: 'Capacity cap for the project MEMORY.md, default 12000. When exceeded the framework auto-consolidates: older content is first folded into bullet points by the model, falling back to whole-record archiving (originals go to archive, never lost) — new memories are never blocked. This is NOT the injection budget above: this caps the file itself, the injection budget caps the digest added to each turn.',
-        fUserCap: 'User memory capacity (chars)', fUserCapHint: 'Capacity cap for the user-level MEMORY.md (cross-project rules), default 12000. Same consolidation behaviour (fold into points first, whole-record archive as fallback).',
+        fNoteCap: 'Project note capacity (chars)', fNoteCapHint: 'Capacity cap for the project MEMORY.md, default 24000. When exceeded the framework auto-consolidates: older content is first folded into bullet points by the model, falling back to whole-record archiving (originals go to archive, never lost) — new memories are never blocked. This is NOT the injection budget above: this caps the file itself, the injection budget caps the digest added to each turn.',
+        fUserCap: 'User memory capacity (chars)', fUserCapHint: 'Capacity cap for the user-level MEMORY.md (cross-project rules), default 24000. Same consolidation behaviour (fold into points first, whole-record archive as fallback).',
         fSnapGap: 'Snapshot min gap (turns)', fSnapGapHint: 'After the dynamic memory snapshot changes, re-inject at least N turns later, so small per-turn log changes do not append a new snapshot every turn (history bloat). Default 5; 0 = try every turn (still change-gated).',
         fReinjectOnCompact: 'Re-inject snapshot immediately after compaction', fReinjectOnCompactHint: 'When the context is compacted/truncated (usually a contextVersion reset), the snapshot is cleared; on = force re-inject once so the memory background rebuilds. Default on.',
         fPromptCustom: 'Customize memory-injection prompt', fPromptCustomHint: 'Override any prompt layer (power feature). Placeholders: {date} {ws} {budget} {n}. One-click reset restores defaults.',
@@ -446,6 +579,14 @@ window.__ModuleLoader__.load({
         fWaterAuto: 'Auto skeleton ledger', fWaterAutoHint: 'Past the threshold, auto-writes one system skeleton ledger per session as a safety net if the model ignores the advisory.',
         fWaterThreshold: 'Water-level threshold', fWaterThresholdHint: 'The ratio counts session tokens against the official declared window (the reserved output budget is no longer deducted); past this value (0.1-1.5) the handoff advisory / skeleton ledger fires; default 0.75 — the official auto-compaction threshold is 80%, so a 5% margin is needed to finish the handoff first.',
         fHandoffPlan: 'Plan injection budget (chars)', fHandoffPlanHint: 'Hard truncation budget for injecting the PLAN.md snapshot into the dynamic memory; full text via memory_read or the Whiteboard tab. Default 1200.',
+        fProcInject: 'Procedure memory injection (master switch)', fProcInjectHint: 'Master switch for procedure memory (skill crystallization): when off, none is written and none is injected. On by default. The older "Skill crystallization" key is no longer read by the host, so change this one instead.',
+        fFactRetention: 'Fact retention limit', fFactRetentionHint: 'Maximum facts kept; when exceeded, revoked facts are pruned first, then oldest-first by write order, and important ones (pinned / user-level / explicit / high-confidence) last. Default 1000.',
+        fTier0Catalog: 'Tier-0 catalog layer', fTier0CatalogHint: 'When on, a short memory catalog (entry titles plus a one-line takeaway) is injected every round so the model sees the whole picture before drilling down. Off injects no catalog layer at all, saving tokens. On by default.',
+        fTier0Max: 'Tier-0 token cap', fTier0MaxHint: 'Hard per-injection token cap for the catalog layer, taking the minimum with (injection budget x catalog share). Default 400. Raise this rather than the whole injection budget when more corpus must fit.',
+        fRulesLayering: 'Layered rules section', fRulesLayeringHint: 'When on, rule-type memories form their own section that is always present and never trimmed (the legacy behavior mixed rules into the trimmable memory stream). Off is exactly the legacy behavior. On by default.',
+        fCriteriaGate: 'Ledger criteria gate', fCriteriaGateHint: 'When on, whiteboard/ledger sections must satisfy the criteria (H1-H4 / S1-S4) before being accepted, which prevents storing reasoning as conclusions. Off drops only this quality gate; the skeleton fail-soft path always applies. On by default.',
+        fWsDiscover: 'Workspace discovery cap', fWsDiscoverHint: 'Maximum workspaces identified when scanning local sessions (newest session time first). Default 200; lower it to speed up scanning when many historical workspaces exist.',
+        fMemFileIndex: 'Memory file index snapshot', fMemFileIndexHint: 'When on, an extra read-only index snapshot of memory files is maintained for external queries, at a small IO cost. Off by default, and off means zero overhead.',
         fHandoffLedger: 'Ledger injection budget (chars)', fHandoffLedgerHint: 'Hard truncation budget for injecting the latest handoff ledger. Default 800.',
         fConsSchedule: 'Scheduled deep consolidation', fConsScheduleHint: 'Once a day at the set time, read recent logs and distill long-term value into project notes / user memory (same flow as memory_consolidate).',
         fConsScheduleTime: 'Consolidation time', fConsScheduleTimeHint: 'HH:MM, once per plugin day; default 09:30. The host must be online at that moment.',
@@ -555,7 +696,17 @@ window.__ModuleLoader__.load({
       snapshotCalendarTitle: '[日历与日程(未完成)]',
       snapshotWelcomeTitle: '[欢迎回来]',
       snapshotWelcomeBody: '用户离开已超过 1 小时(暂离/下班后回来)。在本轮回复的开头,先用一句简短温暖的话欢迎用户回来…',
-      snapshotInscription: '[铭文 · 每轮提醒 {date}]',
+      // ★T5（2026-09-20 用户拍板）同步服务端 snapshotInscription：铭文自 v0.1.30 起为空壳，
+      //   现恢复「收尾自检三大方向 + 分类别丢」正文。**此常量必须与服务端 lib/index.js 逐字一致**
+      //   （设置页「提示词层级」展示的就是这份镜像，漂移会让用户看到的与实际注入不符）。
+      snapshotInscription: '[铭文 · 每轮提醒 {date}]\n'
+        + '【收尾自检】本轮有实质产出才做；纯只读/闲聊轮跳过。三个方向 + 分类别丢：\n'
+        + '① 写记忆文件 memory_log —— kind 按性质选，**不要一律 fact**：rule=用户约束/约定（会被规则层当硬约束注入）、preference=偏好、fact=事实记录、todo=待办；\n'
+        + '② 更新白板与账本 —— ★**硬映射(满足即必须做,别自行判断"算不算"变化)**:\n   · 本轮**改过 lib/ 下任何文件**(含测试/工具) ⇒ 必写 **memory_note(kind=handoff)** 四段式账本;\n   · 白板"当前进度"与本轮结束时的**事实不符**(回归数字/已完成项/下一步) ⇒ 必做 **memory_note(kind=plan)** 重写白板;\n   · 仅补充一条可复用结论 ⇒ 才用 **memory_note(kind=note, action=append)**。\n   ⚠️ **kind=note 不等于白板/账本**——只写 note 却宣称"已更新白板与账本"是**失职**;write 直接写 docs/ 的 md 也**不算**插件记忆。\n'
+        + '③ 长期记忆判断（三个去处）—— 跨会话有用的 → memory_note / 跨项目规则 → memory_user / **跑通且可复用的多步流程 → memory_procedure**（技能库唯一模型入口，不写就没有；建议填 successCriteria）；\n'
+        + '④ 结论失效/被取代 —— 传 `supersedes=` 旧条目 mem_id 标 **superseded（被更新结论取代）**；**当时就做错了要撤回**则传 `retract=` 标 **retracted（撤回）**并尽量附 `retractReason=` 说明错在哪（两者不同：前者有后继，后者本身就是教训）；标错了用 `restore=` 撤回；\n'
+        + '⑤ 看板落列 —— 白板/账本内容要进面板看板泳道，须在标题或正文写 tag：`type:goal` / `type:state` / `type:dead-end` / `type:progress`（5 条泳道含「版本归档」，靠归档动作而非 tag）；不写 tag 系统只能按标题文字猜，常落空；\n'
+        + '⑥ 语体 —— 客观陈述、第三人称，只留可复用的事实/决策/规则/路径（不写"我考虑/我排查/我想"）。',
       snapshotTail: '</memory_system>',
     }
     var FONT_SCALE_VALUES = { sm: '0.9', md: '1', lg: '1.15', xl: '1.3' }
@@ -585,10 +736,42 @@ window.__ModuleLoader__.load({
 
     // ───────────────────────── 更新弹窗 / 首次指导 ─────────────────────────
     var CHANGELOG = {
+      '3.1.0': { zh: [
+        '新增:记忆中枢「**人工越权晋升**」——给「证据还没攒够」被挡住的自沉淀条目一个真正可用的人工通道。两类门现在分得很清:**统计门**(跨会话数/成功次数没攒够)=内容没问题、只是证据不足 ⇒ 给按钮,你可以人工越过;**结构门**(已弃用/只是观察线索/有纠正记录/没写「怎么算成功」/高风险未批准)=内容本身还不构成技能 ⇒ 不给按钮,并直接写明为什么。所以不会再出现「点了没反应」的假按钮。越权过的条目会留下「人工授权」痕迹,可审计。',
+        '新增:设置页按用途重排为 9 个分区(语义记忆总开关 / 记忆窗口(注入什么) / 记忆容量与归档 / 自动沉淀成技能 / 长会话接续 / 自动化与免打扰 / 存储与外部记忆 / 外观与交互 / 关于与诊断)。**控件一字未改**,只是搬进对应分区并改了分组标题——此前「记忆中枢的判定参数」和「注入配置」混在一个分区里,找东西全靠翻。',
+        '修复:「手动晋升的通道被关掉了」的真相——判定函数对线上 30 条自沉淀条目**全部**返回「不晋升」(跨会话数不足 13 / 已弃用 8 / 只是观察线索 8 / 成功次数不足 1),而按钮此前只在「判定=可晋升」时出现,所以一条也点不亮。现已按上面的语义重做。',
+        '说明:更深一层的源头**本轮只缓解、未根治**——证据里的「跨会话数」恒为 0(唯一写入方依赖一个默认关闭的桥接开关),所以证据永远攒不够;人工通道解决的是「攒不够时能不能人工放行」,不是「证据永不累积」本身。',
+        '优化:宽屏下卡片流转为多列,记忆页改成左侧分区导航 + 右侧内容区(窄屏自动回到顶部横排);顶栏与浮层两种承载面**出厂即共存**——更新后直接在会话页顶栏就能看到记忆入口。',
+        '优化:日志列顺序调整——「硬性约束(每轮必注入)」与「用户笔记」提到最上面,每日日志折进可展开的折叠区。',
+        '说明:宿主侧(记忆中枢判定链)有改动,**建议重启 dsh web** 让其生效;界面半边刷新页面即可。',
+      ], en: [
+        'New: manual promotion override in the memory hub — a genuinely working human channel for self-consolidated entries blocked by "not enough evidence yet". The two kinds of gates are now distinct: **statistical** (cross-session count / success count not yet reached) = the content is fine, only the evidence is thin ⇒ a button is shown and you may override; **structural** (deprecated / mere observation / has corrections / no success criteria / high-risk not approved) = the content is not a skill yet ⇒ no button, with a plain-language reason instead. So the UI no longer offers a fake button that does nothing. Overridden entries keep an auditable "manual authorization" trace.',
+        'New: the settings page is regrouped into 9 purpose-named sections (memory engine / memory window / capacity & retention / skills & promotion / handoff & continuation / automation / storage / appearance / about). **No control was changed** — they were only moved into the matching section with clearer group titles; previously promotion parameters and injection settings shared one section, so finding anything meant scrolling.',
+        'Fix: the real reason the manual promotion channel appeared "off" — the decision function returned "do not promote" for **all 30** self-consolidated entries (13 not enough cross-session usage / 8 deprecated / 8 observation-only / 1 not enough successes), and the button only appeared for "promotable" rows, so not one row could light up. Rebuilt around the semantics above.',
+        'Note: the deeper cause is **mitigated, not cured** in this release — the cross-session count in the evidence record is permanently 0 (its only writer depends on a bridge switch that defaults to off), so evidence never accumulates. The manual channel answers "can a human override when evidence is thin", not "why evidence never accumulates".',
+        'Improved: card flows are multi-column on wide screens, and the memory page uses a left section nav with content on the right (narrow screens fall back to a top strip). The titlebar and overlay surfaces now **coexist out of the box** — the memory entry is right there in the session titlebar after updating.',
+        'Improved: log column order — hard constraints (injected every turn) and user notes moved to the top, with the daily log folded into an expandable section.',
+        'Note: the host side (promotion decision chain) changed — **a dsh web restart is recommended**; the UI half only needs a page refresh.',
+      ] },
+      '3.0.1': { zh: [
+        '修复:宿主控制台被 `restoreLastAgent: candidate rejected` **无限刷屏**(每 15 秒一条,打开就停不下来),同时「最近会话」恢复失效——刷新仪式与自动接续的兜底路径都受影响。根因是归属判据过宽:代码把「有父会话」等同于「是子代理」并一律排除,但**你点过一次接续后产生的新会话其实也有父会话**,它是你的正常会话,却被当成子代理拒掉了;列表里只剩它一个时,每个心跳周期都白试一次。现在改为按 `origin`/`delegationDepth` 精确识别子代理,接续会话正常放行;另给诊断信息加了 5 分钟节流兜底。',
+        '顺带修好两处同样的误判:接续会话里的对话此前**不会自动沉淀**、工作区状态也**不刷新**——都因为同一条过宽判据。',
+        '修复:日历「当天」视图里 **23:59 截止的事项永远不显示**。时段轴原先写死 7:00–22:00,凡落在该区间外(或时间格式解析不出)的事项都被静默丢掉——你自己的课表里就有 7 条这样的截止项。现改为按当天真实事项推算时段范围,并新增「未定时」段落兜住解析不出时间的条目。',
+        '新增:日历当天视图支持前后翻天,并显示 ISO 周序号。',
+        '优化:白板卡片的标题不再是小节名。原先「目标」这一节名重复出现上百次,读起来没有信息量;现在标题取正文首行、小节名降为小标签,并自动剥掉 `<!-- ... -->` 注释与 `- type:xxx ｜ ` 这类前缀。**后端与数据文件零改动**,只在展示层清洗。',
+        '说明:白板「节点图画布」本轮**暂不开放**(默认隐藏)。它的数据源依赖工作区解析,当前在你的机器上解析不稳定时会显示「暂无内容」;代码保留在插件内,待解析路径稳定后再放出。原「白板看板」泳道视图完全不受影响。',
+      ], en: [
+        'Fix: the host console was flooded by `restoreLastAgent: candidate rejected` — one line every 15 seconds, nonstop — and recent-session recovery stopped working (refresh ceremony and the auto-continue fallback both depend on it). Root cause was an over-broad ownership test: "has a parent session" was treated as "is a sub-agent" and excluded. But a session created by **continuing** an older one also has a parent — it is your normal session, and it was being rejected as if it were a sub-agent. When it was the only session in the list, every heartbeat retried in vain. Ownership is now decided by `origin`/`delegationDepth`, so continuation sessions pass; diagnostics are also throttled to one line per 5 minutes as a backstop.',
+        'Two more instances of the same misjudgement fixed along the way: conversations inside a continuation session were **never auto-consolidated**, and its workspace state **never refreshed** — both from the same over-broad test.',
+        'Fix: items due at **23:59 never appeared in the calendar day view**. The hour axis was hardcoded to 07:00–22:00, so anything outside it (or with an unparseable time) was silently dropped — 7 of your own deadlines were affected. The range is now derived from the actual events of the day, with a new "untimed" section for entries whose time cannot be parsed.',
+        'New: prev/next day navigation in the calendar day view, plus the ISO week number.',
+        'Improved: whiteboard card titles are no longer section names. The heading "目标" used to repeat over a hundred times — now the title is the first line of the body, the section name becomes a small kicker, and `<!-- ... -->` comments and `- type:xxx | ` prefixes are stripped. Backend and data files are untouched; cleaning happens in the render layer only.',
+        'Note: the whiteboard node-graph canvas is **not shipped in this release** (hidden by default). It depends on workspace resolution, which is unstable on your machine and shows an empty canvas; the code stays in the plugin and will be enabled once resolution is reliable. The existing swimlane whiteboard is unaffected.',
+      ] },
       '3.0.0': { zh: [
         '★ 大版本：底层重建收官。检索、注入、容量、并发四条底层全部重做；白板与看板从「实验特性」变成出厂形态。',
         '★ 白板默认开启（原来默认关）。交接白板 + 四段式交接账本是这一版的招牌能力，出厂关着等于新用户看不到它。想彻底关掉：设置 → 自动化 → 交接白板。',
-        '★ 白板默认「新版看板」：结构化索引（条目/标签/线索/版本链）+ 列式泳道视图 + 两个遍历工具（按标签展开 memory_expand_pre / 按 id 回溯 memory_trace_pre）。旧的文字白板完整保留，设置页一键切回（「旧版白板」）。',
+        '★ 白板默认「新版看板」：结构化索引（条目/标签/线索/版本链）+ 列式泳道视图 + 两个遍历工具（按标签展开 memory_expand / 按 id 回溯 memory_trace）。旧的文字白板完整保留，设置页一键切回（「旧版白板」）。',
         '说明：自动接续**仍然默认关闭**——水位判据还没在你的机器上实测到位，这一版特意不动它，等验证满意再考虑。',
         '修复:语义唤回长期「查不到东西」的真因。语义索引因一次没收尾的同步被永久占住（重启也只能暂时缓解），此后每轮都退化成「关键词 + 常驻目录」。现已修好：索引能建起来，唤回恢复语义检索。',
         '修复:升级弹窗原先只弹 2.1.0 的旧说明（版本号写死），所以你一直看不到新版更新日志。现在会自动展示当前版本的说明。',
@@ -1049,6 +1232,9 @@ window.__ModuleLoader__.load({
       reflect: ROUTE_PREFIX + '/reflect',
       reflectAuto: ROUTE_PREFIX + '/reflect-auto',
       note: ROUTE_PREFIX + '/note',
+      // ★R7：用户级硬性约束的条目级读写
+      rulesList: ROUTE_PREFIX + '/rules',
+      rulesApply: ROUTE_PREFIX + '/rules/apply',
       external: ROUTE_PREFIX + '/external',
       externalView: ROUTE_PREFIX + '/external-view',
       externalRemove: ROUTE_PREFIX + '/external-remove',
@@ -1143,6 +1329,11 @@ window.__ModuleLoader__.load({
     // 视觉:液态玻璃(毛玻璃)—— backdrop-filter + DSH 主题令牌(--dsw-alias-*),
     // 跟随亮/暗主题与页面背景自适应;位置/尺寸由 JS 几何状态驱动(可拖动、可缩放)。
     var CSS = [
+      // ★2026-09-22 动效刻度作用域(MOTION-SPEC-20260922 §0.2):刻度此前只定义在 [data-dam-page] 内,
+      //   而浮层 [data-dam-panel] 不是它的后代 ⇒ 浮层那组取不到变量,只能写字面量、无法与页面统一。
+      //   本条把同一套刻度同时挂到两个承载面;page 侧原有的那份定义原样保留(不删不搬,避免层叠行为变化)。
+      '[data-dam-panel], [data-dam-page] { --dam-dur-quick: 150ms; --dam-dur-fast: 250ms; --dam-dur-slow: 400ms; --dam-dur-stagger: 40ms;',
+      '  --dam-ease-out: cubic-bezier(.22, 1, .36, 1); --dam-ease-inout: cubic-bezier(.65, 0, .35, 1); --dam-ease-pop: cubic-bezier(.34, 1.36, .64, 1); }',
       '[data-dam-panel] { position: fixed; left: 16px; width: 440px; height: 560px; --dam-scale: 1;',
       '  max-width: calc(100vw - 32px); max-height: calc(100vh - 32px);',
       '  display: flex; flex-direction: column; overflow: hidden; z-index: 3000; pointer-events: auto;',
@@ -1152,10 +1343,10 @@ window.__ModuleLoader__.load({
       '  border: 1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(128,128,128,.35)) 65%, transparent);',
       '  box-shadow: 0 24px 64px rgba(0,0,0,.22), 0 4px 16px rgba(0,0,0,.10), inset 0 1px 0 rgba(255,255,255,.22);',
       '  color: var(--dsw-alias-label-primary, #1f2328);',
-      '  animation: dam-in .2s cubic-bezier(.2,.9,.3,1.15) both; transform-origin: left bottom; }',
+      '  animation: dam-in var(--dam-dur-fast) cubic-bezier(.2,.9,.3,1.15) both; transform-origin: left bottom; }',
       '@keyframes dam-in { from { opacity: 0; transform: scale(.92) translateY(10px); } to { opacity: 1; transform: none; } }',
       '@keyframes dam-out { from { opacity: 1; transform: none; } to { opacity: 0; transform: scale(.95) translateY(6px); } }',
-      '[data-dam-panel][data-closing="true"] { animation: dam-out .16s ease-in both; }',
+      '[data-dam-panel][data-closing="true"] { animation: dam-out var(--dam-dur-quick) var(--dam-ease-out) both; }',
       '[data-dam-panel][data-scale="sm"] { --dam-scale: .9; }',
       '[data-dam-panel][data-scale="lg"] { --dam-scale: 1.15; }',
       '[data-dam-panel][data-scale="xl"] { --dam-scale: 1.3; }',
@@ -1172,14 +1363,115 @@ window.__ModuleLoader__.load({
       '  opacity: .55; z-index: 2; border-radius: 0 0 16px 0;',
       '  background: linear-gradient(135deg, transparent 50%, color-mix(in srgb, var(--dsw-alias-label-secondary, #666) 45%, transparent) 50%); }',
       '[data-dam-resize]:hover { opacity: 1; }',
+      // ★2026-09-21 二次修正:原「顶部通栏停靠条」CSS 已随该形态废弃而删除 —— 它曾把面板做成 shell.overlay 里的
+      // 覆盖条(用户实测:「浮在整个页面上方,而不是和对话轨迹…并列的一页」)。现在第二承载面是 conversation.view 会话页,
+      // 窄容器/宽容器两套样式见下面 [data-dam-page] 一组。
+      // ── 会话页大屏适配(2026-09-22「大屏批」) ───────────────────────────────
+      // 设计刻度:间距 4/8/12/16/24/32、圆角 8/12/16、字号 = 用户档位 × 视口台阶。
+      // 动效刻度(transitions-motion token 表):150 / 250 / 400ms + smooth-out 曲线、错开 40ms。
+      // 作用域只有 [data-dam-page](会话页) —— 浮层 [data-dam-panel] 保持逐字节不变。
+      '[data-dam-page] { display: flex; flex-direction: column; width: 100%; height: 100%; min-height: 0;',
+      '  --dam-scale: var(--dam-user-scale, 1);',
+      '  --dam-measure: 1440px;',
+      '  --dam-pad-x: clamp(16px, 1.6vw + 6px, 44px);',
+      '  --dam-pad-y: clamp(14px, .8vw + 6px, 26px);',
+      '  --dam-gap: clamp(10px, .5vw + 6px, 18px);',
+      '  --dam-dur-quick: 150ms; --dam-dur-fast: 250ms; --dam-dur-slow: 400ms;',
+      '  --dam-ease-out: cubic-bezier(.22, 1, .36, 1);',
+      '  --dam-ease-inout: cubic-bezier(.65, 0, .35, 1);',
+      '  --dam-ease-pop: cubic-bezier(.34, 1.36, .64, 1);',
+      '  color: var(--dsw-alias-label-primary, #1f2328); font: 13px/1.55 system-ui, "Segoe UI", sans-serif; }',
+      '[data-dam-page-head] { display: flex; align-items: center; gap: 8px; padding: 10px 4px;',
+      '  border-bottom: 1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(128,128,128,.25)) 55%, transparent); }',
+      '[data-dam-page-head] strong { font-size: calc(15px * var(--dam-scale)); }',
+      '[data-dam-page-head] .dam-spacer { flex: 1; }',
+      // ★2026-09-22 左侧侧栏(方向文档 PANEL-PAGE-MIGRATION-DIRECTION §2/§3):顶部横向滚动页签 → 左侧固定侧栏;
+      //   内容区独立成列独立滚动。窄窗(<900px)自动降级为顶部横条(只换方向,不注销任何分区)。
+      '[data-dam-page-main] { display: flex; flex: 1; min-height: 0; }',
+      '[data-dam-page-nav] { flex: 0 0 auto; width: 170px; overflow: auto; padding: 10px 8px; display: flex; flex-direction: column; gap: 2px;',
+      '  border-right: 1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(128,128,128,.25)) 55%, transparent); }',
+      '[data-dam-page-nav] button { flex: 0 0 auto; border: 0; background: transparent; color: inherit; text-align: left; cursor: pointer;',
+      '  padding: 7px 10px; border-radius: 8px; font: inherit; font-size: calc(12.5px * var(--dam-scale)); opacity: .68; white-space: nowrap;',
+      '  transition: background-color var(--dam-dur-quick) var(--dam-ease-out), color var(--dam-dur-quick) var(--dam-ease-out), opacity var(--dam-dur-quick) var(--dam-ease-out); }',
+      '[data-dam-page-nav] button[data-active="true"] { opacity: 1; font-weight: 650; color: var(--dam-accent, var(--dsw-alias-brand-primary, #4f7cff));',
+      '  background: color-mix(in srgb, var(--dam-accent, #4f7cff) 12%, transparent); }',
+      '[data-dam-page-content] { flex: 1; min-width: 0; display: flex; flex-direction: column; min-height: 0; }',
+      '[data-dam-page-nav], [data-dam-page-content], [data-dam-page-main] { flex-shrink: 1; }',
+      '[data-dam-page] [data-dam-section] { min-width: 0; }',
+      // 折叠标题(日志列表用):整行可点, 箭头用 transform 旋转(不换字符,避免宽度跳动)。
+      '[data-dam-page] [data-dam-fold] { display: flex; align-items: center; gap: 8px; width: 100%; text-align: left; border: 0; cursor: pointer;',
+      '  background: color-mix(in srgb, var(--dsw-alias-label-secondary, #666) 8%, transparent); color: inherit; font: inherit;',
+      '  font-size: calc(12.5px * var(--dam-scale)); font-weight: 650; padding: 9px 12px; border-radius: 9px;',
+      '  transition: background-color var(--dam-dur-quick) var(--dam-ease-out); }',
+      '[data-dam-page] [data-dam-fold]:hover { background: color-mix(in srgb, var(--dsw-alias-label-secondary, #666) 14%, transparent); }',
+      '[data-dam-page] [data-dam-fold] .dam-fold-caret { display: inline-block; transition: transform var(--dam-dur-fast) var(--dam-ease-inout); }',
+      '[data-dam-page] [data-dam-fold][data-open="true"] .dam-fold-caret { transform: rotate(90deg); }',
+      '[data-dam-page] [data-dam-fold] .dam-fold-count { margin-left: auto; opacity: .55; font-weight: 400; }',
+      '@media (max-width: 900px) {',
+      '  [data-dam-page-main] { flex-direction: column; }',
+      '  [data-dam-page-nav] { width: auto; flex-direction: row; gap: 4px; overflow-x: auto; overflow-y: hidden; padding: 6px 8px;',
+      '    border-right: 0; border-bottom: 1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(128,128,128,.25)) 55%, transparent); } }',
+      '[data-dam-page] [data-dam-body] { flex: 1; min-height: 0; overflow: auto;',
+      '  padding: var(--dam-pad-y) var(--dam-pad-x) 28px;',
+      '  padding-inline: max(var(--dam-pad-x), calc((100% - var(--dam-measure)) / 2));',
+      '  scrollbar-width: thin;',
+      '  scrollbar-color: color-mix(in srgb, var(--dsw-alias-label-secondary, #666) 34%, transparent) transparent; }',
+      '[data-dam-page] [data-dam-body]::-webkit-scrollbar { width: 10px; height: 10px; }',
+      '[data-dam-page] [data-dam-body]::-webkit-scrollbar-track { background: transparent; }',
+      '[data-dam-page] [data-dam-body]::-webkit-scrollbar-thumb { border: 3px solid transparent; background-clip: content-box;',
+      '  border-radius: 8px; background-color: color-mix(in srgb, var(--dsw-alias-label-secondary, #666) 28%, transparent); }',
+      '[data-dam-page] [data-dam-body]::-webkit-scrollbar-thumb:hover {',
+      '  background-color: color-mix(in srgb, var(--dsw-alias-label-secondary, #666) 48%, transparent); }',
+      // 大屏台阶:字号随视口抬两档, 与用户档位相乘, 不覆盖用户选择。
+      '@media (min-width: 1400px) { [data-dam-page] { --dam-scale: calc(var(--dam-user-scale, 1) * 1.06); } }',
+      '@media (min-width: 1800px) { [data-dam-page] { --dam-scale: calc(var(--dam-user-scale, 1) * 1.12); } }',
+      // 首帧/页签切换:主体淡入 + 6px 上浮(只动 opacity/transform, 不触发布局与重绘)。
+      '[data-dam-page] [data-dam-body] > :not([data-dam-flow]) { animation: dam-page-in var(--dam-dur-fast) var(--dam-ease-out) both; }',
+      '@keyframes dam-page-in { from { opacity: 0; transform: translateY(6px); } to { opacity: 1; transform: none; } }',
+      // ★卡片流分列(大屏核心收益):只对打了 [data-dam-flow] 标记的页签生效;
+      //   非卡片子元素一律整行占据 ⇒ 不打标记的页签 = 逐字节旧行为, 打了标记也只有卡片进列。
+      '[data-dam-page] [data-dam-flow] { display: grid; gap: var(--dam-gap); align-items: start; align-content: start;',
+      '  grid-template-columns: repeat(auto-fit, minmax(min(100%, 380px), 1fr)); }',
+      '[data-dam-page] [data-dam-flow] > * { grid-column: 1 / -1; min-width: 0; animation: dam-card-in var(--dam-dur-fast) var(--dam-ease-out) both; }',
+      // ★2026-09-22 动效统一(MOTION-SPEC-20260922 §1.2/§2.2/§2.3):
+      //   ① 时长 400ms → var(--dam-dur-fast) 250ms —— 用途是「页面前进」,400ms 是「面板打开」刻度,用在切页签会拖。
+      //   ② 补 both —— 原缺 animation-fill-mode,而下面 nth-child 带 40~200ms 延迟;fill-mode 默认 none 时
+      //      延迟期内动画不生效 ⇒ 卡片按终态(opacity:1)渲染 ⇒ 第 2~6 张「先闪一下 → 跳空 → 再淡入」。
+      //      同文件的 dam-rise 写了 both(:1466/:1472),属漏写不是设计。
+      //   ③ 错开值改走 --dam-dur-stagger(数值不变,只刻度化)。
+      '[data-dam-page] [data-dam-flow] > [data-dam-card] { grid-column: auto; margin-bottom: 0;',
+      '  animation: dam-card-in var(--dam-dur-fast) var(--dam-ease-out) both; }',
+      '@keyframes dam-card-in { from { opacity: 0; transform: translateY(8px) scale(.988); } to { opacity: 1; transform: none; } }',
+      '[data-dam-page] [data-dam-flow] > [data-dam-card]:nth-child(2) { animation-delay: calc(var(--dam-dur-stagger) * 1); }',
+      '[data-dam-page] [data-dam-flow] > [data-dam-card]:nth-child(3) { animation-delay: calc(var(--dam-dur-stagger) * 2); }',
+      '[data-dam-page] [data-dam-flow] > [data-dam-card]:nth-child(4) { animation-delay: calc(var(--dam-dur-stagger) * 3); }',
+      '[data-dam-page] [data-dam-flow] > [data-dam-card]:nth-child(5) { animation-delay: calc(var(--dam-dur-stagger) * 4); }',
+      '[data-dam-page] [data-dam-flow] > [data-dam-card]:nth-child(n+6) { animation-delay: calc(var(--dam-dur-stagger) * 5); }',
+      // 交互反馈:按压即时(150ms 刻度);悬停只在精确指针设备上生效, 避免触屏误触发。
+      '[data-dam-page] [data-dam-btn], [data-dam-page] [data-dam-tab] {',
+      '  transition: background-color var(--dam-dur-quick) var(--dam-ease-out), color var(--dam-dur-quick) var(--dam-ease-out),',
+      '    opacity var(--dam-dur-quick) var(--dam-ease-out), transform var(--dam-dur-quick) var(--dam-ease-out); }',
+      '[data-dam-page] [data-dam-btn]:active, [data-dam-page] [data-dam-tab]:active { transform: scale(.97); }',
+      '[data-dam-page] [data-dam-tab] { padding: 8px 11px; }',
+      '[data-dam-page] :focus-visible { outline: 2px solid color-mix(in srgb, var(--dam-accent, #2456c4) 72%, transparent); outline-offset: 2px; }',
+      '@media (hover: hover) and (pointer: fine) { [data-dam-page] [data-dam-tab]:hover { opacity: .92; } }',
+      // 减动效闸门:新增动效逐条归零(与文件既有那段同源, 此处只覆盖本批新增的选择器)。
+      '@media (prefers-reduced-motion: reduce) {',
+      '  [data-dam-page] [data-dam-body] > *, [data-dam-page] [data-dam-flow] > [data-dam-card] { animation: none !important; }',
+      '  [data-dam-page] [data-dam-btn], [data-dam-page] [data-dam-tab] { transition: none !important; }',
+      '  [data-dam-page] [data-dam-btn]:active, [data-dam-page] [data-dam-tab]:active { transform: none; } }',
       '[data-dam-btn] { border: none; background: transparent; cursor: pointer; color: inherit; opacity: .75; font-size: calc(13px * var(--dam-scale)); padding: 4px 8px; border-radius: 6px; }',
       '[data-dam-btn]:hover { opacity: 1; background: color-mix(in srgb, var(--dsw-alias-label-secondary, #666) 16%, transparent); }',
       '[data-dam-btn][data-pin="on"] { opacity: 1; background: color-mix(in srgb, var(--dam-accent, #4f7cff) 24%, transparent); }',
       '[data-dam-tabs-wrap] { display: flex; align-items: center; min-width: 0; border-bottom: 1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(128,128,128,.2)) 55%, transparent); }',
       '[data-dam-tabs] { flex: 1; min-width: 0; overflow: hidden; padding: 5px 4px; scrollbar-width: none; -ms-overflow-style: none; }',
       '[data-dam-tabs]::-webkit-scrollbar { display: none; }',
+      // ★2026-09-22 取证记录(MOTION-SPEC-20260922 §3.3,本批**不改值**):下面这条 transition: transform 目前是
+      //   **死声明** —— 全文件只有 3 处提到 data-dam-tab-strip(CSS 定义 / 减动效闸门 / :4714 创建该 div),
+      //   滚动由父容器原生 scrollTo/scrollBy 驱动(:4704-4705/:4710),没有任何代码写过它的 transform。
+      //   保留原样:删它对本轮问题零贡献,却可能挡住「将来把滚动改回 transform 驱动」。要动它请单开一批。
       '[data-dam-tab-strip] { display: flex; width: max-content; transition: transform .42s cubic-bezier(.22,.8,.2,1); will-change: transform; }',
-      '[data-dam-tab] { flex: 0 0 auto; min-width: max-content; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; border: none; background: transparent; cursor: pointer; color: inherit; opacity: .68; padding: 6px 9px; border-radius: 7px; font-size: calc(12.5px * var(--dam-scale)); transition: color .25s ease, background .25s ease, opacity .25s ease, transform .25s ease; }',
+      '[data-dam-tab] { flex: 0 0 auto; min-width: max-content; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; border: none; background: transparent; cursor: pointer; color: inherit; opacity: .68; padding: 6px 9px; border-radius: 7px; font-size: calc(12.5px * var(--dam-scale)); transition: color var(--dam-dur-quick) var(--dam-ease-out), background var(--dam-dur-quick) var(--dam-ease-out), opacity var(--dam-dur-quick) var(--dam-ease-out), transform var(--dam-dur-quick) var(--dam-ease-out); }',
       '[data-dam-tabs-arrow] { flex: 0 0 26px; height: 30px; border: 0; background: transparent; color: inherit; cursor: pointer; opacity: .55; font-size: 18px; }',
       '[data-dam-tabs-arrow]:hover:not(:disabled) { opacity: 1; background: color-mix(in srgb, var(--dam-accent, #2456c4) 16%, transparent); transform: scale(1.12); }',
       '[data-dam-tabs-arrow]:active:not(:disabled) { transform: scale(.92); }',
@@ -1216,21 +1508,31 @@ window.__ModuleLoader__.load({
       '  background: color-mix(in srgb, var(--dsw-alias-bg-layer-1, rgba(128,128,128,.06)) 40%, transparent); }',
       '[data-dam-card] .dam-date { font-weight: 600; margin-bottom: 4px; }',
       '[data-dam-card] .dam-content { white-space: pre-wrap; word-break: break-word; max-height: 220px; overflow: auto; }',
-      '[data-dam-disclosure] { overflow: hidden; opacity: 0; max-height: 0; transform: translateY(-5px) scale(.985); transition: max-height .32s cubic-bezier(.22,.8,.2,1), opacity .2s ease, transform .28s cubic-bezier(.22,.8,.2,1); }',
+      '[data-dam-disclosure] { overflow: hidden; opacity: 0; max-height: 0; transform: translateY(-5px) scale(.985); transition: max-height var(--dam-dur-fast) var(--dam-ease-out), opacity var(--dam-dur-fast) var(--dam-ease-out), transform var(--dam-dur-fast) var(--dam-ease-out); }',
       '[data-dam-disclosure][data-phase="open"] { opacity: 1; max-height: 1800px; transform: translateY(0) scale(1); }',
       '[data-dam-disclosure][data-phase="closing"] { opacity: 0; max-height: 0; transform: translateY(-5px) scale(.985); }',
-      '[data-dam-card], [data-dam-banner] { animation: dam-rise .34s cubic-bezier(.22,.8,.2,1) both; }',
+      '[data-dam-card], [data-dam-banner] { animation: dam-rise var(--dam-dur-fast) var(--dam-ease-out) both; }',
       '@keyframes dam-rise { from { opacity: 0; transform: translateY(7px) scale(.988); } to { opacity: 1; transform: translateY(0) scale(1); } }',
       '@media (prefers-reduced-motion: reduce) { [data-dam-tab-strip], [data-dam-tab], [data-dam-disclosure], [data-dam-card], [data-dam-banner], [data-dam-tour-orb-wrap] *, [data-dam-update-box] * { transition: none !important; animation: none !important; }',
       '  [data-dam-tour-bokeh], [data-dam-tour-slab], [data-dam-tour-orb-core] { opacity: 1 !important; transform: none !important; filter: none !important; }',
       '  [data-dam-update-stage] { display: none !important; }',
       '  [data-dam-update-content] { opacity: 1 !important; transform: none !important; animation: none !important; } }',
-      '[data-dam-calendar] { animation: dam-rise .34s cubic-bezier(.22,.8,.2,1) both; }',
-      '[data-dam-calendar] [data-dam-calendar-day] { transition: transform .18s ease, border-color .2s ease, background .2s ease, box-shadow .2s ease; }',
+      // ★2026-09-22 减动效闸门(第二道) —— MOTION-SPEC-20260922 §1.6:上面那道只覆盖 8 个选择器,
+      //   漏了浮层/日历三件/页签交互/折叠头/侧栏/保存条。本批新增与改动的每一条动效都必须在两道里被归零。
+      '@media (prefers-reduced-motion: reduce) {',
+      '  [data-dam-panel], [data-dam-calendar], [data-dam-calendar-event], [data-dam-calendar-modal],',
+      '  [data-dam-calendar] [data-dam-calendar-day], [data-dam-tabs-arrow], [data-dam-btn],',
+      '  [data-dam-page-nav] button, [data-dam-page] [data-dam-fold], [data-dam-page] [data-dam-fold] .dam-fold-caret,',
+      '  [data-dam-savebar], [data-dam-savebar] button { transition: none !important; animation: none !important; }',
+      '  [data-dam-tab][data-active="true"], [data-dam-calendar] [data-dam-calendar-day]:hover,',
+      '  [data-dam-page] [data-dam-flow] > * { animation: none !important; }',
+      '  [data-dam-tab]:active, [data-dam-btn]:active, [data-dam-tabs-arrow]:active:not(:disabled) { transform: none !important; } }',
+      '[data-dam-calendar] { animation: dam-rise var(--dam-dur-fast) var(--dam-ease-out) both; }',
+      '[data-dam-calendar] [data-dam-calendar-day] { transition: transform var(--dam-dur-quick) var(--dam-ease-out), border-color .2s ease, background .2s ease, box-shadow .2s ease; }',
       '[data-dam-calendar] [data-dam-calendar-day]:hover { transform: translateY(-1px); border-color: var(--dam-accent, #1d4ed8) !important; box-shadow: 0 4px 12px rgba(0,0,0,.08); }',
-      '[data-dam-calendar-event] { animation: dam-event-in .25s cubic-bezier(.22,.8,.2,1) both; transition: transform .18s ease, filter .18s ease; }',
+      '[data-dam-calendar-event] { animation: dam-event-in var(--dam-dur-fast) var(--dam-ease-out) both; transition: transform var(--dam-dur-quick) var(--dam-ease-out), filter var(--dam-dur-quick) var(--dam-ease-out); }',
       '[data-dam-calendar-event]:hover { transform: translateX(2px); filter: brightness(1.06); }',
-      '[data-dam-calendar-modal] { animation: dam-modal-in .26s cubic-bezier(.22,.8,.2,1) both; }',
+      '[data-dam-calendar-modal] { animation: dam-modal-in var(--dam-dur-fast) var(--dam-ease-out) both; }',
       '@keyframes dam-event-in { from { opacity: 0; transform: translateX(-5px); } to { opacity: 1; transform: none; } }',
       '@keyframes dam-modal-in { from { opacity: 0; transform: translateY(10px) scale(.98); } to { opacity: 1; transform: none; } }',
       '[data-dam-banner] { border: 1px solid color-mix(in srgb, var(--dsw-alias-state-warn-primary, #e6a23c) 55%, transparent);',
@@ -1509,6 +1811,99 @@ window.__ModuleLoader__.load({
     }
     function writeLs(key, val) { try { localStorage.setItem(key, String(val)) } catch (e) {} }
 
+    // ─────────────────────────────────────────────────────────────────────────
+    // 白板内容清洗层(2026-09-20 重构批)
+    //
+    // 为什么需要: 卡片数据来自 Markdown 的 `## ` 小节直通(wb-sidecar.js:252→:666),
+    //   全链路无摘要/清洗/标题正文分离 ⇒ 实测 868 张卡只有 195 个不同标题
+    //   (「目标」重复 109 次), 且正文首行常是未剥离的 `<!-- type:goal -->`。
+    //   title 与 body 因此互为镜像 —— 两个字段的信息量只有 1 个。
+    //
+    // 立场: 纯前端派生, 不改后端契约(wb-contract.js 的写入门与 sidecar 结构零改动)。
+    //   清洗是**渲染层**职责: 磁盘上的字节保持原样, 只在显示时剥掉元数据。
+    // ─────────────────────────────────────────────────────────────────────────
+    /** 剥 HTML 注释(锚点行 `<!-- memory:mem_xxx -->` 与 tag 行 `<!-- type:goal -->`)。 */
+    function wbStripComment(s) { return String(s || '').replace(/<!--[\s\S]*?-->/g, '') }
+    /** 剥行首的 tag 前缀(`- type:state ｜ ` / `type:goal` 等)与列表符。 */
+    function wbStripPrefix(s) {
+      return String(s || '')
+        .replace(/^\s*[-*+]\s+/, '')
+        .replace(/^\s*(?:tag|type|topic)\s*[:：]\s*[\w\u4e00-\u9fff-]+\s*[｜|]?\s*/i, '')
+        .replace(/^\s*[｜|]\s*/, '')
+    }
+    /** 剥 Markdown 行内标记(粗体/斜体/行内代码/链接), 只留可读文字。 */
+    function wbStripMarkup(s) {
+      return String(s || '')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/(^|[^*])\*([^*]+)\*/g, '$1$2')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/\s+/g, ' ')
+        .trim()
+    }
+    /** 一条原文 → 可读文本(剥注释 → 逐行剥前缀 → 剥标记), 丢弃空行。 */
+    function wbCleanLines(s) {
+      var lines = wbStripComment(s).split(/\r?\n/)
+      var out = []
+      for (var i = 0; i < lines.length; i++) {
+        var t = wbStripMarkup(wbStripPrefix(lines[i]))
+        if (t) out.push(t)
+      }
+      return out
+    }
+    /** 标题清洗: 剥注释与前缀后取首行, 过长截断。空则回落到小节名。 */
+    function wbCleanTitle(raw) {
+      var ls = wbCleanLines(raw)
+      var t = ls.length ? ls[0] : ''
+      if (!t) return ''
+      return t.length > 60 ? t.slice(0, 57) + '…' : t
+    }
+    /**
+     * 卡片 → { title, body, meta }
+     * 标题优先级: 清洗后的正文首行 > card.title(小节名) > 来源文件名
+     * 正文 = 剩余行拼接(已清洗), 与标题不重复 —— 这正是「标题+正文分离」。
+     */
+    function wbShape(c) {
+      var rawFull = c.full || c.preview || ''
+      var ls = wbCleanLines(rawFull)
+      var head = ls.length ? ls[0] : ''
+      var title = head ? (head.length > 60 ? head.slice(0, 57) + '…' : head) : (c.title || c.short || '')
+      // 副标题: 小节名(短小、可当分类标签), 若与标题相同则省略
+      var kicker = c.title && c.title !== title ? c.title : ''
+      var rest = ls.slice(1)
+      // 小节名常重复出现在正文首行(如「任务状态」), 再剥一次
+      if (kicker && rest.length && rest[0] === kicker) rest = rest.slice(1)
+      var body = rest.join(' ')
+      var isDup = body.indexOf(title) === 0 && body.length <= title.length + 2
+      if (isDup) body = ''
+      return {
+        title: title,
+        kicker: kicker,
+        body: body,
+        docTitle: c.docTitle || '',
+        source: c.source || '',
+        section: c.section || '',
+        tags: c.tags || [],
+        sectionTags: c.sectionTags || [],
+        anchored: !!c.anchored,
+        id: c.id,
+        ts: c.ts,
+        lineStart: c.lineStart,
+        kind: c.kind || '',
+        mtime: c.mtime,
+      }
+    }
+    /** 泳道 key → 色调(图上按类别着色, 与面板泳道语义一致)。 */
+    function wbLaneTone(key) {
+      var k = String(key || '')
+      if (k === 'goal') return '#4d6bfe'
+      if (k === 'state' || k === 'doing') return '#3fa96a'
+      if (k === 'dead' || k === 'deadend') return '#c2603f'
+      if (k === 'progress' || k === 'next') return '#d4a94f'
+      if (k === 'archive') return '#8a7fbf'
+      return 'rgba(128,128,128,.75)'
+    }
+
     /** 单张卡片: 标题 + 判据徽章 + 预览/全文 + 小节徽章 + 标签 + 来源。可点击展开。 */
     function KanbanCard(props) {
       var c = props.card || {}
@@ -1774,6 +2169,9 @@ window.__ModuleLoader__.load({
     /** 整页矩阵看板: 行=日期分组, 列=小节类型。 */
     function KanbanView(props) {
       var st = useState(null), data = st[0], setData = st[1]
+      // ★2026-09-17(L2 修 bug①): 额外保留**原始载荷** —— 旧实现 `setData(k && k.enabled ? k : null)`
+      // 直接把宿主返回的 reason/error 丢掉了, 于是下面只能硬编码一句猜测式提示。
+      var stPay = useState(null), pay = stPay[0], setPay = stPay[1]
       var st2 = useState(null), drawer = st2[0], setDrawer = st2[1]
       var st3 = useState({}), folded = st3[0], setFolded = st3[1]
       var st4 = useState(''), q = st4[0], setQ = st4[1]
@@ -1783,8 +2181,8 @@ window.__ModuleLoader__.load({
       useEffect(function () {
         var alive = true
         apiGet(API.kanbanBoard, { sessionId: currentSessionIdClient() })
-          .then(function (k) { if (alive) setData(k && k.enabled ? k : null) })
-          .catch(function () { if (alive) setData(null) })
+          .then(function (k) { if (alive) { setPay(k || null); setData(k && k.enabled ? k : null) } })
+          .catch(function (e) { if (alive) { setPay({ reason: 'error', error: String((e && e.message) || e) }); setData(null) } })
         return function () { alive = false }
       }, [tick])
 
@@ -1797,6 +2195,27 @@ window.__ModuleLoader__.load({
       var total = (mx && mx.stats && mx.stats.totalCards) || 0
       var missing = (mx && mx.stats && mx.stats.missingDeadend) || []
 
+      // ★2026-09-17(L2 修 bug①): **按宿主返回的真实 reason 分支**, 不再硬编码猜测式提示。
+      // 旧文案把「看板未启用」归因于 **handoff 未开启**, 把用户指向错误方向 —— 用户报告:
+      // 「明明已经启用了, 却显示未启用或加载失败」。现消费 payload 里的 reason/error。
+      var emptyMsg = (function () {
+        var r = pay && pay.reason
+        if (r === 'legacy-mode') {
+          return zh ? '当前是旧版白板(legacy)档。切到新版看板: 设置 → 自动记忆引擎 → 看板模式 → 「新版看板（dsh-graph）」，重启 dsh web 后生效。'
+            : 'Legacy board mode. Switch to graph board: Settings → Auto Memory Engine → Board mode → "Graph board (dsh-graph)", then restart dsh web.'
+        }
+        if (r === 'error') {
+          var m = String((pay && pay.error) || '')
+          return (zh ? '看板加载出错: ' : 'Board load error: ') + (m || (zh ? '(无错误详情)' : '(no detail)'))
+        }
+        if (r === 'handoff-disabled') {
+          // 兼容极旧宿主(本版后端已不再返回该 reason), 如实说明而非误导
+          return zh ? '看板数据源已关闭。请在设置里启用白板/账本(handoff)。' : 'Board data source is off. Enable whiteboard/ledger (handoff) in settings.'
+        }
+        return zh ? '看板尚未就绪或加载失败。请点上方「刷新」重试; 若持续如此, 检查是否已切到新版看板(dsh-graph)档。'
+          : 'Board not ready or failed to load. Click "reload" above; if it persists, check the graph board mode.'
+      })()
+
       return h('div', { 'data-dam-kanban-view': '', style: {
         // position:relative 是**必需**的: 抽屉用 absolute 定位, 它的参照系就是这里 ⇒ 抽屉被裁剪在
         // 看板承载面内, 不会像 fixed 那样越界盖住底部输入框。overflow:hidden 同时兜底裁剪。
@@ -1825,9 +2244,8 @@ window.__ModuleLoader__.load({
           h('button', { key: 'zi', 'data-dam-btn': '', onClick: function () { setZoom(Math.min(1.6, zoom + 0.1)) } }, 'A+'),
           h('button', { key: 'rf', 'data-dam-btn': '', onClick: function () { setData(null); bump(function (n) { return n + 1 }) } }, zh ? '刷新' : 'reload'),
         ]),
-        // ── 空态 / 错误态(不静默) ──
-        !data ? h('div', { key: 'ph', 'data-dam-kx-empty': 'nodata', 'data-dam-hint': '' },
-          zh ? '看板未启用或加载失败(需 boardMode=graph 且 handoff 已开启)。' : 'Board unavailable.') : null,
+        // ── 空态 / 错误态(不静默; ★2026-09-17 按真实 reason 分支, 见上方 emptyMsg) ──
+        !data ? h('div', { key: 'ph', 'data-dam-kx-empty': 'nodata', 'data-dam-hint': '' }, emptyMsg) : null,
         data && !mx ? h('div', { key: 'nm', 'data-dam-kx-empty': 'nomatrix', 'data-dam-hint': '' },
           zh ? '本次载荷缺矩阵视图。' : 'No matrix in payload.') : null,
         data && mx && !rows.length ? h('div', { key: 'nr', 'data-dam-kx-empty': 'norows', 'data-dam-hint': '' },
@@ -1950,6 +2368,412 @@ window.__ModuleLoader__.load({
       ])
     }
 
+    // ══════════════════════════════════════════════════════════════════════════
+    // 白板节点图画布(2026-09-20 重构批 · 风格参考 kanghelyu/dsh-deepseek-flow)
+    //
+    // 立场: **只改渲染层**。数据源仍是同一个 /kanban-board 载荷, 后端与 sidecar 零改动。
+    //   参考项目用 esbuild 打包 8 个模块, 本插件受「单文件 / 无构建链」约束
+    //   (package.json exports["./client"]='./lib/client.js' 直送浏览器) ⇒
+    //   不引第三方图库, 布局算法手写。
+    //
+    // 与泳道看板的关系(共存, 非替换):
+    //   · 会话页整页宽(≥700px) = 本画布(节点 + 连线, 平移缩放);
+    //   · 侧边面板 440px = 原泳道看板(装不下画布, 保持不动)。
+    //
+    // 图要素(全部来自现有数据, §6 侦察报告结论):
+    //   · 节点 = 小节卡(WbShape 清洗后: title 为正文首行, kicker 为小节名)
+    //   · 结构边 = 同泳道内的时间/顺序链
+    //   · 分层 = 按**泳道**分列(有限 6 类), 列内按时间倒序排列
+    //   ⚠ 语义边(tag 关联/版本链)数据当前不可用(by_tag 全 sec: / versionCount 恒 0),
+    //     故本版**不画**这类边 —— 宁可少画, 不画假的。
+    // ──────────────────────────────────────────────────────────────────────────
+    var WBG_NODE_W = 232
+    var WBG_NODE_H = 104
+    var WBG_GAP_X = 74
+    var WBG_GAP_Y = 22
+    var WBG_PAD = 40
+    var WBG_ZOOM_KEY = 'dam-wbg-zoom'
+    var WBG_PAN_KEY = 'dam-wbg-pan'
+    // 每列最多排多少个节点, 其余折叠为「+N」汇总节点。
+    //
+    // ★2026-09-21 布局重做(实测驱动): 原实现「一篇文档 = 一列」在真实数据下**数学上不可用** ——
+    //   本仓库实测 876 节点 / 189 篇文档 ⇒ 画布 57,840 × 1,318 px, 宽高比 **43.9:1**
+    //   (容器仅 1.72:1), 理想 fit 需缩到 **1.9%**, 而缩放下限 35% ⇒ **永远看不到全貌,
+    //   要横向拖 52 屏**。按泳道分列同样不行(1,842 × 23,494 ⇒ 纵向 37 屏)。
+    //   结论: 病根不是「按什么分组」, 而是**一屏塞不下 876 个节点**。
+    //   人的看图逻辑是「先全局分类 → 再逐层下钻」⇒ 默认视图必须是**概览**而非全量平铺。
+    var WBG_COL_CAP = 14
+    var WBG_MIN_ZOOM = 0.08
+    var WBG_HDR_H = 34
+
+    /**
+     * 分层布局: 列 = 泳道(类型), 行 = 时间倒序。
+     *
+     * 为什么按泳道而非文档: 泳道是**有限的 6 类**(goal/state/deadend/progress/archive/misc),
+     *   语义稳定、用户已知; 文档是 189 个且会持续增长 —— 用它当轴等于把画布宽度绑死在数据量上。
+     * 每列内按时间倒序(最近的在最上面), 超出 WBG_COL_CAP 的折叠为汇总节点,
+     *   既保证一屏可读, 又不隐藏数据(可搜索或切「白板看板」看全部)。
+     */
+    function wbLayout(cards) {
+      var byLane = {}
+      for (var i = 0; i < cards.length; i++) {
+        var k = cards[i].laneKey || cards[i].lane || 'misc'
+        if (!byLane[k]) byLane[k] = []
+        byLane[k].push(cards[i])
+      }
+      // 固定列序(与面板泳道语义一致), 未在表中出现的追加在后
+      var ORDER = ['goal', 'state', 'deadend', 'progress', 'archive', 'misc']
+      var keys = []
+      for (var oi = 0; oi < ORDER.length; oi++) if (byLane[ORDER[oi]]) keys.push(ORDER[oi])
+      for (var kk in byLane) if (keys.indexOf(kk) < 0) keys.push(kk)
+
+      var nodes = []
+      var edges = []
+      var groups = []
+      var maxRows = 0
+      for (var ci = 0; ci < keys.length; ci++) {
+        var key = keys[ci]
+        var list = byLane[key].slice().sort(function (a, b) {
+          // 时间新的在上; 无 ts 时按 lineStart 兜底
+          var ta = Number(a.ts) || 0
+          var tb = Number(b.ts) || 0
+          if (ta !== tb) return tb - ta
+          return (Number(a.lineStart) || 0) - (Number(b.lineStart) || 0)
+        })
+        var shown = list.slice(0, WBG_COL_CAP)
+        var hidden = list.length - shown.length
+        var colX = WBG_PAD + ci * (WBG_NODE_W + WBG_GAP_X)
+        groups.push({ key: key, x: colX, total: list.length, shownN: shown.length, hidden: hidden })
+        var rows = shown.length + (hidden > 0 ? 1 : 0)
+        if (rows > maxRows) maxRows = rows
+        for (var ri = 0; ri < shown.length; ri++) {
+          var nd = wbShape(shown[ri])
+          nd.x = colX
+          nd.y = WBG_PAD + WBG_HDR_H + ri * (WBG_NODE_H + WBG_GAP_Y)
+          nd.laneKey = key
+          nd.col = ci
+          nd.row = ri
+          nodes.push(nd)
+          // 结构边: 同泳道内相邻节点相连(时间链)
+          if (ri > 0) edges.push({ from: shown[ri - 1].id, to: shown[ri].id, key: key })
+        }
+        if (hidden > 0) {
+          nodes.push({
+            id: '__more__' + key, x: colX,
+            y: WBG_PAD + WBG_HDR_H + shown.length * (WBG_NODE_H + WBG_GAP_Y),
+            title: (zh ? '还有 ' + hidden + ' 条' : '+' + hidden + ' more'),
+            body: zh ? '已折叠以免画布过长 —— 用上方搜索, 或切到「白板看板」看全部' : 'collapsed for readability',
+            kicker: '', docTitle: '', laneKey: key, col: ci, row: shown.length, isMore: true,
+          })
+        }
+      }
+      return {
+        nodes: nodes,
+        edges: edges,
+        groups: groups,
+        width: WBG_PAD * 2 + keys.length * WBG_NODE_W + Math.max(0, keys.length - 1) * WBG_GAP_X,
+        height: WBG_PAD * 2 + WBG_HDR_H + maxRows * WBG_NODE_H + Math.max(0, maxRows - 1) * WBG_GAP_Y,
+        keys: keys,
+        totalCards: cards.length,
+      }
+    }
+
+    /** 节点卡: 标题(正文首行) + 小节名 kicker + 正文摘要。四段式。 */
+    function WbgNode(props) {
+      var n = props.node
+      var zoom = Number(props.zoom) || 1
+      var sel = !!props.selected
+      var tone = wbLaneTone(n.laneKey || n.section || '')
+      var body = n.body || ''
+      if (body.length > 220) body = body.slice(0, 217) + '…'
+      var anchor = props.anchor
+      return h('div', {
+        'data-dam-wbg-node': '',
+        'data-selected': sel ? 'true' : 'false',
+        onClick: function (e) { e.stopPropagation(); props.onPick(n.id) },
+        style: {
+          position: 'absolute',
+          left: n.x + 'px', top: n.y + 'px',
+          width: WBG_NODE_W + 'px', minHeight: WBG_NODE_H + 'px',
+          boxSizing: 'border-box',
+          padding: '9px 11px 10px',
+          borderRadius: '10px',
+          cursor: 'pointer',
+          background: sel
+            ? 'color-mix(in srgb, ' + tone + ' 16%, var(--dsw-alias-bg-layer-2, rgba(22,22,26,.96)))'
+            : 'var(--dsw-alias-bg-layer-2, rgba(22,22,26,.92))',
+          border: '1px solid ' + (sel ? tone : 'color-mix(in srgb, ' + tone + ' 34%, transparent)'),
+          boxShadow: sel ? ('0 0 0 1px ' + tone + ', 0 6px 22px color-mix(in srgb, ' + tone + ' 26%, transparent)') : '0 2px 10px rgba(0,0,0,.18)',
+          transition: 'background .14s ease, border-color .14s ease',
+        },
+      }, [
+        // ① 分类条(kicker): 小节名 —— 短、可扫读
+        n.kicker ? h('div', {
+          key: 'k', 'data-dam-hint': '',
+          style: {
+            fontSize: (9.5 * zoom) + 'px', letterSpacing: '.06em', textTransform: 'uppercase',
+            color: tone, opacity: .95, marginBottom: '4px',
+            whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
+          },
+        }, n.kicker + (n.anchored ? ' ⚓' : '')) : null,
+        // ② 标题: 清洗后的正文首行(不再是重复的小节名)
+        h('div', {
+          key: 't',
+          style: {
+            fontSize: (12.5 * zoom) + 'px', fontWeight: 700, lineHeight: '1.34',
+            color: 'var(--dsw-alias-label-primary)',
+            display: '-webkit-box', WebkitLineClamp: 2, WebkitBoxOrient: 'vertical', overflow: 'hidden',
+          },
+        }, n.title),
+        // ③ 正文: 与标题不重复的剩余内容
+        body ? h('div', {
+          key: 'b', 'data-dam-hint': '',
+          style: {
+            marginTop: '5px', fontSize: (10.5 * zoom) + 'px', lineHeight: '1.42',
+            color: 'var(--dsw-alias-label-secondary)',
+            display: '-webkit-box', WebkitLineClamp: 3, WebkitBoxOrient: 'vertical', overflow: 'hidden',
+          },
+        }, body) : null,
+        // ④ 来源: 文档名(定位"这条来自哪篇")
+        h('div', {
+          key: 's', 'data-dam-hint': '',
+          style: {
+            marginTop: '6px', fontSize: (9.5 * zoom) + 'px', opacity: .55,
+            whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
+          },
+        }, String(n.docTitle || n.source || '').replace(/^.*[\\/]/, '')),
+      ])
+    }
+
+    /** 画布: 平移(拖拽) + 缩放(滚轮/按钮) + fit + 点选侧栏。零依赖、纯 SVG 连线。 */
+    function WhiteboardGraphView(props) {
+      var st = useState(null), data = st[0], setData = st[1]
+      var stPay = useState(null), pay = stPay[0], setPay = stPay[1]
+      var stTick = useState(0), tick = stTick[0], bump = stTick[1]
+      var stZoom = useState(function () { return readLsNum(WBG_ZOOM_KEY, 1) }), zoom = stZoom[0], setZoom = stZoom[1]
+      var stPan = useState(function () {
+        try { var v = JSON.parse(localStorage.getItem(WBG_PAN_KEY) || 'null'); return v && typeof v.x === 'number' ? v : { x: 0, y: 0 } } catch (e) { return { x: 0, y: 0 } }
+      }), pan = stPan[0], setPan = stPan[1]
+      var stSel = useState(null), sel = stSel[0], setSel = stSel[1]
+      var stQ = useState(''), q = stQ[0], setQ = stQ[1]
+      var dragRef = useRef(null)
+      var wrapRef = useRef(null)
+      var zh = (locale || 'zh').indexOf('zh') === 0
+
+      useEffect(function () {
+        var alive = true
+        apiGet(API.kanbanBoard, { sessionId: currentSessionIdClient() })
+          .then(function (k) { if (alive) { setPay(k || null); setData(k && k.enabled ? k : null) } })
+          .catch(function (e) { if (alive) { setPay({ reason: 'error', error: String((e && e.message) || e) }); setData(null) } })
+        return function () { alive = false }
+      }, [tick])
+
+      // 把 lanes[].cards[] 摊平成一张卡列表(画布不按泳道分组, 泳道只当节点色调)
+      var cards = []
+      var laneOf = {}
+      var lanes = (data && data.lanes) || []
+      for (var li = 0; li < lanes.length; li++) {
+        var lc = lanes[li].cards || []
+        for (var ci = 0; ci < lc.length; ci++) {
+          cards.push(lc[ci])
+          laneOf[lc[ci].id] = lanes[li].key
+        }
+      }
+      var kg = wbLayout(cards.map(function (c) { return Object.assign({}, c, { laneKey: laneOf[c.id] }) }))
+
+      var kw = q.trim().toLowerCase()
+      var matches = function (n) {
+        if (!kw) return true
+        return (n.title + ' ' + n.body + ' ' + n.docTitle + ' ' + n.kicker).toLowerCase().indexOf(kw) >= 0
+      }
+      var visibleNodes = kg.nodes.filter(matches)
+      var visIds = {}
+      for (var vi = 0; vi < visibleNodes.length; vi++) visIds[visibleNodes[vi].id] = 1
+
+      var nodeById = {}
+      for (var ni = 0; ni < kg.nodes.length; ni++) nodeById[kg.nodes[ni].id] = kg.nodes[ni]
+
+      var selNode = sel ? nodeById[sel] : null
+
+      var setZoomBoth = function (v) {
+        var nv = Math.min(2.0, Math.max(WBG_MIN_ZOOM, Math.round(v * 100) / 100))
+        setZoom(nv); writeLs(WBG_ZOOM_KEY, nv)
+      }
+      var fit = function () {
+        var el = wrapRef.current
+        if (!el || !kg.width) return
+        var w = el.clientWidth - 24
+        var hgt = el.clientHeight - 24
+        // 下限用 WBG_MIN_ZOOM(0.08)而非 0.35 —— 876 节点的概览视图本就是「缩小看结构」,
+        // 用 0.35 当底会永远 fit 不到全貌(实测需 1.9%)。
+        var z = Math.min(1.6, Math.max(WBG_MIN_ZOOM, Math.min(w / kg.width, hgt / kg.height)))
+        setZoomBoth(z)
+        setPanBoth({ x: 0, y: 0 })
+      }
+      var setPanBoth = function (p) { setPan(p); try { localStorage.setItem(WBG_PAN_KEY, JSON.stringify(p)) } catch (e) {} }
+
+      var onDown = function (e) {
+        if (e.button !== 0) return
+        dragRef.current = { sx: e.clientX, sy: e.clientY, px: pan.x, py: pan.y, moved: false }
+        e.currentTarget.setPointerCapture && e.currentTarget.setPointerCapture(e.pointerId)
+      }
+      var onMove = function (e) {
+        var d = dragRef.current
+        if (!d) return
+        var dx = e.clientX - d.sx, dy = e.clientY - d.sy
+        if (Math.abs(dx) + Math.abs(dy) > 3) d.moved = true
+        setPan({ x: d.px + dx, y: d.py + dy })
+      }
+      var onUp = function (e) {
+        var d = dragRef.current
+        dragRef.current = null
+        if (d) { try { localStorage.setItem(WBG_PAN_KEY, JSON.stringify(pan)) } catch (e2) {} }
+        e.currentTarget.releasePointerCapture && e.currentTarget.releasePointerCapture(e.pointerId)
+      }
+      var onWheel = function (e) {
+        if (!e.ctrlKey && !e.metaKey && Math.abs(e.deltaY) < 2) return
+        e.preventDefault()
+        setZoomBoth(zoom + (e.deltaY < 0 ? 0.08 : -0.08))
+      }
+
+      // 空态/错误态: 与 KanbanView 同一套 reason 消费
+      if (!data || !cards.length) {
+        var reason = pay && pay.reason
+        var msg = reason === 'legacy-mode'
+          ? (zh ? '当前是旧版白板(legacy)档。切到新版看板: 设置 → 自动记忆引擎 → 看板模式 → 「新版看板（dsh-graph）」。'
+            : 'Legacy board mode. Switch to graph board in Settings.')
+          : reason === 'error'
+            ? ((zh ? '加载出错: ' : 'Load error: ') + String((pay && pay.error) || ''))
+            : (zh ? '画布暂无内容 —— 写一次白板或账本(memory_note)后这里会出现节点。'
+              : 'No nodes yet — write a plan or ledger (memory_note) and nodes will appear.')
+        return h('div', { 'data-dam-wbg-wrap': '', style: { padding: '18px' } }, [
+          h('div', { 'data-dam-hint': '', key: 'm', style: { lineHeight: 1.7 } }, msg),
+          h('button', { key: 'r', 'data-dam-btn': '', onClick: function () { bump(tick + 1) }, style: { marginTop: '10px' } }, zh ? '刷新' : 'reload'),
+        ])
+      }
+
+      var btn = function (label, onClick, title) {
+        return h('button', { 'data-dam-btn': '', onClick: onClick, title: title || '', style: { padding: '1px 8px', fontSize: '11px' } }, label)
+      }
+      var bar = h('div', {
+        'data-dam-wbg-bar': '',
+        style: { display: 'flex', flexWrap: 'wrap', gap: '6px', alignItems: 'center', padding: '8px 10px', borderBottom: '1px solid color-mix(in srgb, currentColor 12%, transparent)' },
+      }, [
+        btn('A-', function () { setZoomBoth(zoom - 0.1) }),
+        h('span', { key: 'z', 'data-dam-hint': '', style: { fontSize: '10.5px', minWidth: '38px', textAlign: 'center' } }, Math.round(zoom * 100) + '%'),
+        btn('A+', function () { setZoomBoth(zoom + 0.1) }),
+        h('span', { key: 'g1', style: { width: '6px' } }),
+        btn(zh ? '适应' : 'fit', fit, zh ? '缩放到刚好装下' : 'fit to view'),
+        h('span', { key: 'g2', style: { width: '6px' } }),
+        h('input', {
+          key: 'q', 'data-dam-input': '', value: q, placeholder: zh ? '搜索节点…' : 'search nodes…',
+          onChange: function (e) { setQ(e.target.value) },
+          style: { flex: '1 1 120px', minWidth: '100px', fontSize: '11px', padding: '2px 7px' },
+        }),
+        h('span', { key: 'st', 'data-dam-hint': '', style: { fontSize: '10.5px', opacity: .7 } },
+          (zh ? '节点 ' : 'nodes ') + visibleNodes.length + '/' + kg.nodes.length + (zh ? ' · 列 ' : ' · cols ') + (kg.keys || []).length + (zh ? ' · 共 ' : ' · total ') + kg.totalCards),
+      ])
+
+      // SVG 连线(在 transform 容器内, 与节点同一坐标系)
+      var edgeEls = []
+      for (var ei = 0; ei < kg.edges.length; ei++) {
+        var ed = kg.edges[ei]
+        var a = nodeById[ed.from], b = nodeById[ed.to]
+        if (!a || !b || !visIds[a.id] || !visIds[b.id]) continue
+        var x1 = a.x + WBG_NODE_W / 2, y1 = a.y + WBG_NODE_H
+        var x2 = b.x + WBG_NODE_W / 2, y2 = b.y
+        var my = (y1 + y2) / 2
+        edgeEls.push(h('path', {
+          key: 'e' + ei,
+          d: 'M' + x1 + ' ' + y1 + ' C' + x1 + ' ' + my + ', ' + x2 + ' ' + my + ', ' + x2 + ' ' + y2,
+          fill: 'none',
+          stroke: 'color-mix(in srgb, ' + wbLaneTone(nodeById[ed.to].laneKey || '') + ' 46%, transparent)',
+          'stroke-width': 1.4,
+        }))
+      }
+
+      var nodeEls = []
+      for (var nk = 0; nk < kg.nodes.length; nk++) {
+        var nn = kg.nodes[nk]
+        if (!visIds[nn.id]) continue
+        nodeEls.push(h(WbgNode, { key: nn.id, node: nn, zoom: zoom, selected: sel === nn.id, onPick: function (id) { setSel(function (p) { return p === id ? null : id }) } }))
+      }
+
+      // 列标题: 泳道名 + 「已显示/总数」+ 色条。
+      // 为什么必须有: 默认缩放到 fit 时节点字会小到读不清, **列标题是唯一还能读的锚点**;
+      //   人的看图顺序是「先认这 6 列是什么 → 再看某一列里有什么」, 没有列标题就只剩一堆色块。
+      var LANE_LABEL_ZH = { goal: '目标', state: '进行中', deadend: '失败与弯路', progress: '进度与下一步', archive: '版本归档', misc: '其它' }
+      var groupEls = []
+      for (var gi = 0; gi < (kg.groups || []).length; gi++) {
+        var g = kg.groups[gi]
+        var tone = wbLaneTone(g.key)
+        var laneName = zh ? (LANE_LABEL_ZH[g.key] || g.key) : g.key
+        groupEls.push(h('div', {
+          key: 'gh' + g.key, 'data-dam-wbg-colhead': '',
+          style: {
+            position: 'absolute', left: g.x + 'px', top: WBG_PAD + 'px', width: WBG_NODE_W + 'px',
+            boxSizing: 'border-box', paddingBottom: '6px',
+            borderBottom: '2px solid color-mix(in srgb, ' + tone + ' 62%, transparent)',
+          },
+        }, [
+          h('div', {
+            key: 'n', style: {
+              fontSize: (13.5 / Math.max(zoom, 0.4)) + 'px', fontWeight: 700, color: tone,
+              whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
+            },
+          }, laneName),
+          h('div', { key: 'c', 'data-dam-hint': '', style: { fontSize: (10.5 / Math.max(zoom, 0.4)) + 'px', opacity: .7, marginTop: '1px' } },
+            (g.shownN + '/' + g.total) + '  ' + (zh ? '条' : '')),
+        ]))
+      }
+
+      return h('div', { 'data-dam-wbg-wrap': '', style: { display: 'flex', flexDirection: 'column', height: '100%', minHeight: 0 } }, [
+        bar,
+        h('div', { key: 'body', style: { display: 'flex', flex: '1 1 auto', minHeight: 0 } }, [
+          h('div', {
+            key: 'canvas', ref: wrapRef,
+            'data-dam-wbg-canvas': '',
+            onPointerDown: onDown, onPointerMove: onMove, onPointerUp: onUp, onPointerCancel: onUp,
+            onWheel: onWheel,
+            onClick: function () { setSel(null) },
+            style: {
+              position: 'relative', flex: '1 1 auto', minWidth: 0, overflow: 'hidden',
+              cursor: dragRef.current ? 'grabbing' : 'grab',
+              backgroundImage: 'radial-gradient(color-mix(in srgb, currentColor 9%, transparent) 1px, transparent 1px)',
+              backgroundSize: '22px 22px',
+            },
+          }, h('div', {
+            'data-dam-wbg-stage': '',
+            style: {
+              position: 'absolute', left: 0, top: 0,
+              width: kg.width + 'px', height: kg.height + 'px',
+              transform: 'translate(' + pan.x + 'px,' + pan.y + 'px) scale(' + zoom + ')',
+              transformOrigin: '0 0',
+              willChange: 'transform',
+            },
+          }, [
+            h('svg', { key: 'svg', width: kg.width, height: kg.height, style: { position: 'absolute', left: 0, top: 0, pointerEvents: 'none' } }, edgeEls),
+          ].concat(groupEls).concat(nodeEls))),
+          // 侧栏: 选中节点的完整信息(宽屏才放得下全文 —— 这才是画布相对泳道的增量价值)
+          selNode ? h('div', {
+            key: 'side', 'data-dam-wbg-side': '',
+            style: {
+              flex: '0 0 320px', maxWidth: '44%', overflow: 'auto', padding: '12px 14px',
+              borderLeft: '1px solid color-mix(in srgb, currentColor 12%, transparent)',
+            },
+          }, [
+            h('div', { key: 'x', style: { display: 'flex', alignItems: 'flex-start', gap: '8px' } }, [
+              h('div', { key: 'h', style: { flex: 1, fontWeight: 700, fontSize: '14px', lineHeight: 1.4 } }, selNode.title),
+              h('button', { key: 'c', 'data-dam-btn': '', onClick: function () { setSel(null) } }, '✕'),
+            ]),
+            selNode.kicker ? h('div', { key: 'k', 'data-dam-hint': '', style: { marginTop: '4px', fontSize: '11px', opacity: .75 } }, selNode.kicker + (selNode.anchored ? ' · ⚓ ' + (zh ? '有锚点' : 'anchored') : '')) : null,
+            selNode.docTitle ? h('div', { key: 'd', 'data-dam-hint': '', style: { marginTop: '2px', fontSize: '11px', opacity: .6, wordBreak: 'break-all' } }, selNode.docTitle) : null,
+            selNode.body ? h('div', { key: 'b', style: { marginTop: '12px', fontSize: '12px', lineHeight: 1.72, whiteSpace: 'pre-wrap', wordBreak: 'break-word' } }, selNode.body) : h('div', { key: 'b2', 'data-dam-hint': '', style: { marginTop: '12px', fontSize: '11.5px', opacity: .6 } }, zh ? '(这一节没有更多正文)' : '(no further body)'),
+          ]) : null,
+        ]),
+      ])
+    }
+
     function Loading(props) {
       var label = props && props.label ? props.label : t('loading')
       return h('div', { 'data-dam-loading': '' }, h('span', { 'data-dam-spinner': '', 'aria-hidden': 'true' }), h('span', null, label))
@@ -2413,12 +3237,15 @@ window.__ModuleLoader__.load({
           })
         ) : null,
         groups.map(function (grp) {
-          return h('div', { key: grp.day, style: { marginBottom: '16px' } },
+          // ★大屏分列(2026-09-22):判定队列每天一组的卡片在宽屏排成多列。
+          //   CSS 规则是 `[data-dam-flow] > [data-dam-card]`(直接子元素) ⇒ 标记必须打在**分组容器**上,
+          //   打在页签根上卡片不是直接子元素,只会退化成整行占位(无效接线)。
+          return h('div', { key: grp.day, 'data-dam-flow': '', style: { marginBottom: '16px' } },
             h('div', { style: { fontSize: 'calc(11.5px * var(--dam-scale))', fontWeight: 700, opacity: .7, margin: '2px 2px 8px' } }, grp.day),
             grp.rows.map(function (row, i) {
               var rc = row.reasonCodes || []
               var del = row.delivery
-              return h('div', { key: row.observationId || i, style: card },
+              return h('div', { key: row.observationId || i, 'data-dam-card': '', style: card },
                 h('div', { style: { display: 'flex', alignItems: 'center', gap: '7px', marginBottom: '5px' } },
                   (function () { var lk = row.lane === 'explicit' ? 'explicit' : 'proactive'; var c = laneBg[lk] || ['rgba(128,128,128,.16)', null]; return badge(locale === 'zh' ? (lk === 'explicit' ? '明确召回' : '主动观测') : lk, c[0], c[1]) })(),
                   (function () { var dk = String(row.decision); var c = decBg[dk] || ['rgba(128,128,128,.14)', null]; return badge(dk.toUpperCase(), c[0], c[1]) })(),
@@ -2450,6 +3277,11 @@ window.__ModuleLoader__.load({
       var userTruncPair = useState(false)
       var userTruncated = userTruncPair[0]
       var setUserTruncated = userTruncPair[1]
+      // ★2026-09-22:日志列表改折叠(用户要求「日志可以做成折叠的形式,可以展开」)。默认收起 ——
+      //   首屏留给「硬性约束 + 用户笔记」这两块每轮无条件注入的稳定内容,日志属于翻查型内容。
+      var logsOpenPair = useState(false)
+      var logsOpen = logsOpenPair[0]
+      var setLogsOpen = logsOpenPair[1]
       useEffect(function () {
         var alive = true
         apiGet(API.list).then(function (d) { if (alive) setData(d) }).catch(function () {})
@@ -2469,23 +3301,181 @@ window.__ModuleLoader__.load({
           h('div', { 'data-dam-content': '' }, content || t('empty')),
           h('button', { 'data-dam-btn': '', onClick: function () { setOpen(null); setContent('') } }, t('back'))))
       } else {
-        rows.push(h('div', { 'data-dam-hint': '' }, t('clickDateViewLog')))
-        for (var i = 0; i < data.logs.length; i++) {
-          (function (log) {
-            rows.push(h(Card, { title: log.date + ' · ' + fmtSize(log.size) },
-              h('button', { 'data-dam-btn': '', onClick: function () { setOpen(log.date + '.md') } }, t('view'))))
-          })(data.logs[i])
-        }
-        // 三级记忆之用户级:当日日志下方展示用户画像(跨项目规则/偏好)
-        rows.push(h('div', { 'data-dam-hint': '', style: { marginTop: '12px' } }, t('userMemoryBlock')))
-        rows.push(h(Card, { title: 'MEMORY.md (' + (locale === 'zh' ? '用户级' : 'user-level') + ')' },
-          h('div', { 'data-dam-content': '' }, userText || t('userMemoryEmpty')),
-          userTruncated ? h('div', { 'data-dam-hint': '' }, t('userMemoryTruncated')) : null))
+        // ★2026-09-22 版式调整(用户要求「把上面的那一堆东西和下面的对调」):
+        //   ① 硬性约束 与 用户笔记 提到最上面 —— 两者都是**每轮无条件注入**的稳定内容,使用者最该先看到;
+        //   ② 日志列表下移并改折叠 —— 日志是翻查型内容,不该占据首屏。
+        //   两块都用 [data-dam-section] 包裹:它在 [data-dam-flow] 栅格里整行占位,不会被分列。
+        rows.push(h('div', { 'data-dam-section': '' }, h(RulesEditPanel, {})))
+        rows.push(h('div', { 'data-dam-section': '', style: { marginTop: '14px' } },
+          h('div', { 'data-dam-hint': '', style: { marginBottom: '6px' } }, t('userMemoryBlock')),
+          h(Card, { title: 'MEMORY.md (' + (locale === 'zh' ? '用户级' : 'user-level') + ')' },
+            h('div', { 'data-dam-content': '' }, userText || t('userMemoryEmpty')),
+            userTruncated ? h('div', { 'data-dam-hint': '' }, t('userMemoryTruncated')) : null)))
+        rows.push(h('div', { 'data-dam-section': '', style: { marginTop: '14px' } }, h(FoldableLogs, {
+          logs: data.logs || [], open: logsOpen, setOpen: setLogsOpen, onOpenFile: setOpen,
+        })))
       }
-      return h('div', null, rows)
+      // 大屏分列:卡片流页签(见 CSS [data-dam-flow]);非卡片子元素仍整行。
+      return h('div', { 'data-dam-flow': '' }, rows)
+    }
+    // ★2026-09-22 日志折叠块(从 LogsTab 抽出, 便于独立校验括号):标题可点, 内容用既有 AnimatedDisclosure。
+    function FoldableLogs(props) {
+      var open = !!props.open
+      var list = props.logs || []
+      return h('div', null,
+        h('button', {
+          'data-dam-fold': '', 'data-open': open ? 'true' : 'false', 'aria-expanded': open ? 'true' : 'false',
+          onClick: function () { props.setOpen(!open) },
+        },
+          h('span', { className: 'dam-fold-caret' }, '▸'),
+          h('span', null, t('logs')),
+          h('span', { className: 'dam-fold-count' }, list.length + (locale === 'zh' ? ' 篇' : ' files'))),
+        h(AnimatedDisclosure, { open: open },
+          h('div', { style: { paddingTop: '8px' } },
+            h('div', { 'data-dam-hint': '' }, t('clickDateViewLog')),
+            list.map(function (log) {
+              return h(Card, { key: log.date, title: log.date + ' · ' + fmtSize(log.size) },
+                h('button', { 'data-dam-btn': '', onClick: function () { props.onOpenFile(log.date + '.md') } }, t('view')))
+            }))))
     }
+
     function pathName(p) { var parts = String(p).split(/[\\/]/); return parts[parts.length - 1] }
 
+    // ── ★R1–R6（2026-09-20 用户「看不懂只能盲确认」）审批面人话化辅助 ────────
+    //   R3：stage 枚举 → 中文。
+    function stageLabel(stage) {
+      var m = { observed: 'hubStageObserved', candidate: 'hubStageCandidate', validated: 'hubStageValidated', active: 'hubStageActive', deprecated: 'hubStageDeprecated' }
+      return m[stage] ? t(m[stage]) : String(stage || '')
+    }
+    //   R2：reasonCodes → 人话。**为什么不能晋升**必须看得见。
+    //   后端只回传机器码（如 diversity-below-3），这里翻成具体数字与下一步动作。
+    function whyNotPromotable(promotion) {
+      if (!promotion) return ''
+      var d = promotion.detail || {}
+      var codes = promotion.reasonCodes || []
+      for (var i = 0; i < codes.length; i++) {
+        var c = codes[i]
+        if (c === 'observation-only') return t('hubWhyObservationOnly')
+        if (c === 'deprecated') return t('hubStageDeprecated')
+        if (c === 'no-success-criteria') return t('hubWhyNoCriteria')
+        if (c === 'has-correction') return t('hubWhyHasCorrection')(d.corrections || 0)
+        if (c.indexOf('high-risk-awaiting-approval') === 0) return t('hubWhyHighRisk')
+        if (c.indexOf('diversity-below-') === 0) return t('hubWhyDiversity')(d.diversity != null ? d.diversity : 0, d.need != null ? d.need : 0)
+        if (c.indexOf('success-below-') === 0) return t('hubWhySuccess')(d.successCount != null ? d.successCount : 0, d.need != null ? d.need : 0)
+        if (c.indexOf('correction-rate-') === 0) return t('hubWhyCorrectionRate')(String(c).replace('correction-rate-', ''), d.cap != null ? d.cap : '')
+        if (c === 'model-authorized') continue
+      }
+      if (promotion.decision === 'promote') return t('hubWhyCanPromote')
+      // ★C（2026-09-22）：把「关在哪一类门」说透 —— 统计门可人工越过，结构门不可。
+      //   没有这一段时，界面上"一个按钮都没有"，用户只能猜（这正是"手动通道被关掉"的观感来源）。
+      if (promotion.decision === 'keep') {
+        var head = codes.length ? codes.join(' · ') : ''
+        if (promotion.overridable === true) return head + ' ｜ ' + t('hubWhyOverridable')
+        if (promotion.gateKind === 'structural') return head + ' ｜ ' + t('hubWhyStructural')
+        return head
+      }
+      return codes.length ? codes.join(' · ') : ''
+    }
+
+    // ── ★R7（2026-09-20 用户要求「用户级硬性约束须能自行增删改」）─────────────
+    //   这一段规则**每轮无条件注入、不走语义层** ⇒ 过时条目不会被自动淘汰、
+    //   AI（memory_user）也可能写错 ⇒ 必须让用户能自己改。
+    //   接口与将来换风格无关：本面板只用 data-dam-* 语义属性，样式由外层决定。
+    function RulesEditPanel(props) {
+      var nonce = props && props.nonce ? props.nonce : 0
+      var dataPair = useState(null); var data = dataPair[0]; var setData = dataPair[1]
+      var errPair = useState(''); var err = errPair[0]; var setErr = errPair[1]
+      var busyPair = useState(false); var busy = busyPair[0]; var setBusy = busyPair[1]
+      var msgPair = useState(''); var msg = msgPair[0]; var setMsg = msgPair[1]
+      var draftPair = useState({}); var draft = draftPair[0]; var setDraft = draftPair[1]
+      var newPair = useState(''); var newText = newPair[0]; var setNewText = newPair[1]
+      var tickPair = useState(0); var tick = tickPair[0]; var setTick = tickPair[1]
+      useEffect(function () {
+        var alive = true
+        apiGet(API.rulesList, {}).then(function (r) {
+          if (!alive) return
+          if (r && r.error) { setErr(r.error) } else { setData(r); setErr('') }
+        }).catch(function (e) { if (alive) setErr(String(e && e.message ? e.message : e)) })
+        return function () { alive = false }
+      }, [nonce, tick])
+      function apply(op, payload) {
+        setBusy(true); setMsg('')
+        apiPost(API.rulesApply, Object.assign({ op: op }, payload || {})).then(function (r) {
+          setBusy(false)
+          if (r && r.error) { setMsg('❌ ' + r.error); return }
+          // ★即时回显（用户既有硬性偏好）：直接用餐后端返回的新列表，不等重新拉整页
+          setData({ path: data && data.path, items: r.items, preview: r.preview })
+          setMsg('✅ ' + (r.result || 'ok'))
+          setDraft({})
+        }).catch(function (e) { setBusy(false); setMsg('❌ ' + String(e && e.message ? e.message : e)) })
+      }
+      if (err) return h(Card, { title: t('rulesTitle') }, h('div', { 'data-dam-hint': '' }, err))
+      if (!data) return h(Card, { title: t('rulesTitle') }, h('div', { 'data-dam-hint': '' }, '…'))
+      var items = data.items || []
+      var rows = []
+      rows.push(h('div', { 'data-dam-hint': '' }, t('rulesIntro')))
+      rows.push(h('div', { 'data-dam-hint': '', style: { marginTop: '4px' } }, t('rulesPath') + (data.path || '')))
+      if (msg) rows.push(h('div', { key: 'msg', 'data-dam-hint': '', style: { marginTop: '6px' } }, msg))
+      if (!items.length) rows.push(h('div', { key: 'empty', 'data-dam-hint': '', style: { marginTop: '8px' } }, t('rulesEmpty')))
+      for (var i = 0; i < items.length; i++) {
+        (function (it, idx) {
+          var editing = draft[idx] != null
+          var srcTag = it.source === 'ai' ? t('rulesSourceAi') : t('rulesSourceUser')
+          var head = h('div', { 'data-dam-hint': '', style: { fontSize: '12px', opacity: .75 } },
+            '#' + (idx + 1) + ' · ' + srcTag + (it.dateSection ? ' · ' + it.dateSection : ''))
+          var bodyEl
+          if (editing) {
+            bodyEl = h('div', null,
+              h('textarea', {
+                'data-dam-input': '',
+                value: draft[idx],
+                rows: 3,
+                style: { width: '100%', boxSizing: 'border-box' },
+                onInput: function (e) { var d = Object.assign({}, draft); d[idx] = e.target.value; setDraft(d) },
+              }),
+              h('button', { 'data-dam-btn': '', disabled: busy, onClick: function () { apply('update', { index: idx, text: draft[idx] }) } }, t('rulesSave')),
+              ' ',
+              h('button', { 'data-dam-btn': '', onClick: function () { var d = Object.assign({}, draft); delete d[idx]; setDraft(d) } }, t('rulesCancel')))
+          } else {
+            bodyEl = h('div', null,
+              h('div', { 'data-dam-content': '' }, it.text),
+              h('button', { 'data-dam-btn': '', onClick: function () { var d = Object.assign({}, draft); d[idx] = it.text; setDraft(d) } }, t('rulesEdit')),
+              ' ',
+              h('button', {
+                'data-dam-btn': '',
+                disabled: busy,
+                onClick: function () {
+                  // ★R7-4：该层渲染器（renderRulesSectionPre）**不认任何状态标记** ⇒
+                  //   软删标记会被当正文注入模型。故删除**真删**且不可撤销 ⇒ 二次确认。
+                  if (typeof window !== 'undefined' && !window.confirm(t('rulesConfirmDelete'))) return
+                  apply('remove', { index: idx })
+                },
+              }, t('rulesDelete')))
+          }
+          rows.push(h('div', { key: 'r' + idx, 'data-dam-rule': '', style: { marginTop: '8px', paddingTop: '8px', borderTop: '1px solid rgba(128,128,128,.25)' } }, head, bodyEl))
+        })(items[i], i)
+      }
+      rows.push(h('div', { key: 'add', style: { marginTop: '12px' } },
+        h('div', { 'data-dam-hint': '' }, t('rulesAddHint')),
+        h('textarea', {
+          'data-dam-input': '',
+          value: newText,
+          rows: 2,
+          placeholder: t('rulesAddPlaceholder'),
+          style: { width: '100%', boxSizing: 'border-box' },
+          onInput: function (e) { setNewText(e.target.value) },
+        }),
+        h('button', {
+          'data-dam-btn': '',
+          disabled: busy || !String(newText || '').trim(),
+          onClick: function () { apply('add', { text: newText }); setNewText('') },
+        }, t('rulesAdd'))))
+      // ★R7-6：预览「下一轮注入会变成什么样」
+      rows.push(h('div', { key: 'pvh', 'data-dam-hint': '', style: { marginTop: '12px' } }, t('rulesPreviewHint')))
+      rows.push(h('pre', { key: 'pv', 'data-dam-content': '', style: { whiteSpace: 'pre-wrap' } }, data.preview || ''))
+      return h(Card, { title: t('rulesTitle') }, h('div', null, rows))
+    }
+
     // M8 记忆中枢页签:展示三层记忆(经历/事实/技能)概览。数据源=/memory-hub 只读投影。
     function MemoryHubTab(props) {
       var nonce = props && props.nonce ? props.nonce : 0
@@ -2551,12 +3541,57 @@ window.__ModuleLoader__.load({
           pipeline.map(function (p) {
             var ev = p.evidence || {}
             return h('div', { 'data-dam-content': '', key: p.procedureId, style: { padding: '5px 0', borderBottom: '1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(255,255,255,.16)) 40%, transparent)' } },
-              h('div', null, h('b', null, p.title), h('span', { 'data-dam-hint': '', style: { marginLeft: '6px' } }, '[' + p.stage + ']' + (p.observationOnly ? (locale === 'zh' ? ' · 观察（不参与自动晋升）' : ' · observation-only') : '') + (p.pinned ? ' 📌' : '') + (p.riskLevel === 'high' ? ' ⚠' : '')),
-                h('span', { 'data-dam-hint': '', style: { marginLeft: '6px' } }, (locale === 'zh' ? '成功 ' : 'succ ') + (ev.success || 0) + ' · ' + (locale === 'zh' ? '会话 ' : 'sess ') + (ev.sessions || 0))),
+              // ★R1：技能名 + 可读标注；★R3：stage 给中文
+              h('div', null, h('b', null, p.title), h('span', { 'data-dam-hint': '', style: { marginLeft: '6px' } },
+                '[' + stageLabel(p.stage) + ']'
+                + (p.observationOnly ? (locale === 'zh' ? ' · 观察（不参与自动晋升）' : ' · observation-only') : '')
+                + (p.pinned ? ' 📌' : '') + (p.riskLevel === 'high' ? ' ⚠' : '')),
+                // ★R5：evidence 给人话（不是裸数字）
+                h('span', { 'data-dam-hint': '', style: { marginLeft: '6px' } }, t('hubEvLine')(ev))),
+              // ★R2：**为什么不能晋升** —— 必须在界面上说清楚
+              (function () {
+                var why = whyNotPromotable(p.promotion)
+                if (!why) return null
+                var ok = p.promotion && p.promotion.decision === 'promote'
+                return h('div', { 'data-dam-hint': '', style: { marginTop: '4px', color: ok ? 'inherit' : 'var(--dsw-alias-text-warning, #d90)', opacity: .95 } },
+                  h('b', null, t('hubWhyTitle')), why)
+              })(),
+              // ★R4：预览「晋升后会注入什么」（真实 steps / successCriteria）
+              ((p.steps && p.steps.length) || (p.successCriteria && p.successCriteria.length))
+                ? h('details', { style: { marginTop: '4px' } },
+                    h('summary', { 'data-dam-hint': '', style: { cursor: 'pointer' } }, t('hubInjectPreview')),
+                    h('div', { 'data-dam-content': '', style: { marginTop: '4px', paddingLeft: '10px' } },
+                      (p.steps || []).map(function (s, si) { return h('div', { key: 's' + si }, (si + 1) + '. ' + s) }),
+                      (p.successCriteria && p.successCriteria.length)
+                        ? h('div', { style: { marginTop: '4px' } }, h('b', null, t('hubInjectCriteria')), (p.successCriteria || []).join(' / '))
+                        : null))
+                : h('div', { 'data-dam-hint': '', style: { marginTop: '4px', opacity: .7 } }, t('hubNoSteps')),
               h('div', { style: { display: 'flex', gap: '6px', marginTop: '5px' } },
                 // issue #30:纯 episode 观察行**结构上**不可能晋升(无 successCriteria),
                 // 继续显示"晋升"按钮只会让人反复点击却看不到变化 ⇒ 直接隐藏并打观察标。
-                !p.observationOnly && h('button', { 'data-dam-btn': '', style: { fontSize: 'calc(10.5px * var(--dam-scale))', padding: '3px 10px' }, onClick: function () { hubAct('promote', p.procedureId) } }, locale === 'zh' ? '晋升' : 'promote'),
+                // ★ 2026-09-21 bugfix(A-9):原条件只挡 observationOnly,与 store 真实门限**不一致** ——
+                //   缺 successCriteria / 有 correction / correctionRate 超限的条目照样显示按钮,
+                //   用户点下去只得到一行 keep 灰字,感受即「批准不了」。
+                //   现改为**直接依赖只读投影** `p.promotion`(宿主 memory-hub 用 evaluatePromotion 生成,
+                //   纯只读、不写盘):decision==='promote' 才给按钮,否则界面已由 R2 区块说明原因。
+                //   fail-soft:投影缺失(旧宿主/异常)时退回原 observationOnly 判据,不做过度拦截。
+                (!p.observationOnly && (!p.promotion || p.promotion.decision === 'promote'))
+                  && h('button', { 'data-dam-btn': '', style: { fontSize: 'calc(10.5px * var(--dam-scale))', padding: '3px 10px' }, onClick: function () { hubAct('promote', p.procedureId) } }, locale === 'zh' ? '晋升' : 'promote'),
+                // ★2026-09-22 补接线(前端接线审计 P0-1):宿主已提供 approve 原语
+                //   (index.js 白名单含 action:'approve' + procedure-store-pre approve('user')),
+                //   而上面「晋升」按钮门控在 decision==='promote' ⇒ 高风险条目(decision==='ask')
+                //   在界面上是死路:用户看得到「待人工批准」却没有任何按钮可点。
+                (p.promotion && p.promotion.decision === 'ask')
+                  && h('button', { 'data-dam-btn': '', style: { fontSize: 'calc(10.5px * var(--dam-scale))', padding: '3px 10px', fontWeight: 650 }, onClick: function () { hubAct('approve', p.procedureId) } }, locale === 'zh' ? '批准(人工)' : 'approve (manual)'),
+                // ★B/C（2026-09-22）：人工**强制晋升** —— 只在「拦它的门**全是统计门**」时给出。
+                //   判据来自宿主只读投影 p.promotion.overridable（memory-hub 用 promotionOverrideView 生成，
+                //   只读、零副作用、且**不重复实现门限** ⇒ 结构上不可能与 promote() 漂移）。
+                //   结构门拦（已弃用 / 观察型 / 无 successCriteria / 有纠正记录）时**不给按钮** ——
+                //   否则就是再造一个「点了没反应」的假通道（A-9 收掉旧按钮的正是这个原因）。
+                //   动作走 index.js 白名单 `force-promote` → promote(pid, {}, { authorizedBy:'user' })，
+                //   只越过 diversity/success 两道统计门，并在条目上留 `authorizedBy:'user'` 痕迹。
+                (p.promotion && p.promotion.overridable === true)
+                  && h('button', { 'data-dam-btn': '', title: t('hubForcePromoteTitle'), style: { fontSize: 'calc(10.5px * var(--dam-scale))', padding: '3px 10px', fontWeight: 650 }, onClick: function () { hubAct('force-promote', p.procedureId) } }, t('hubForcePromote')),
                 !p.observationOnly && p.stage === 'validated' && h('button', { 'data-dam-btn': '', style: { fontSize: 'calc(10.5px * var(--dam-scale))', padding: '3px 10px' }, onClick: function () { hubAct('activate', p.procedureId) } }, locale === 'zh' ? '直接激活' : 'activate'),
                 h('button', { 'data-dam-btn': '', style: { fontSize: 'calc(10.5px * var(--dam-scale))', padding: '3px 10px', opacity: .75 }, onClick: function () { hubAct('deprecate', p.procedureId) } }, locale === 'zh' ? '弃用' : 'deprecate'),
                 h('button', { 'data-dam-btn': '', style: { fontSize: 'calc(10.5px * var(--dam-scale))', padding: '3px 10px', opacity: .75 }, onClick: function () { hubAct('pin', p.procedureId, !p.pinned) } }, p.pinned ? (locale === 'zh' ? '取消置顶' : 'unpin') : (locale === 'zh' ? '置顶' : 'pin'))))
@@ -2570,6 +3605,18 @@ window.__ModuleLoader__.load({
         factList.length ? factList.slice(0, 6).map(function (f) {
           return h('div', { 'data-dam-content': '', key: f.factId, style: { padding: '3px 0' } }, f.subject + ' · ' + f.predicate + (f.object ? ' · ' + f.object : ''))
         }) : h('div', { 'data-dam-content': '' }, t('hubFactsEmpty'))))
+      // ★P0-3a 补接线(2026-09-22):事实保留上限淘汰台账。宿主早已把它放进 /memory-hub 应答
+      //   (memory-hub.js:245 → stores.facts.getStats()),前端此前零渲染
+      //   ⇒「事实被悄悄淘汰了」在界面上无处可查。pruneProtected>0 表示已轮到删「重要项」⇒ 上限偏低。
+      var factStats = (facts && facts.stats) || null
+      if (factStats && (Number(factStats.pruned) > 0 || Number(factStats.pruneProtected) > 0)) {
+        var fpPruned = Number(factStats.pruned) || 0
+        var fpProtected = Number(factStats.pruneProtected) || 0
+        rows.push(h('div', { 'data-dam-hint': '', style: { marginTop: '6px', color: fpProtected > 0 ? 'var(--dsw-alias-state-warn-primary, #e8c584)' : undefined } },
+          locale === 'zh'
+            ? '已按保留上限淘汰 ' + fpPruned + ' 条事实' + (fpProtected > 0 ? '，其中 ' + fpProtected + ' 条属重要/未撤销条目 —— 上限偏低，建议到 设置 → 自动记忆引擎 调高「事实保留上限」' : '')
+            : fpPruned + ' fact(s) evicted by the retention cap' + (fpProtected > 0 ? ', incl. ' + fpProtected + ' important/unrevoked — cap too low; raise "Fact retention limit" under Settings → Semantic engine' : '')))
+      }
       if (facts && facts.pendingConflicts && facts.pendingConflicts.length) {
         rows.push(h('div', { 'data-dam-hint': '', style: { color: 'var(--dsw-alias-state-warn-primary, #e8c584)' } }, t('hubConflicts') + ': ' + facts.pendingConflicts.length))
       }
@@ -2584,7 +3631,8 @@ window.__ModuleLoader__.load({
       // 统计
       rows.push(h('div', { 'data-dam-hint': '', style: { marginTop: '12px', opacity: .7 } },
         (locale === 'zh' ? '中枢统计: ' : 'Hub stats: ') + (data.stats ? JSON.stringify(data.stats) : '')))
-      return h('div', null, rows)
+      // 大屏分列:卡片流页签(见 CSS [data-dam-flow]);非卡片子元素仍整行。
+      return h('div', { 'data-dam-flow': '' }, rows)
     }
 
     // M10 存储管理页签(2026-08-30 P3):数据源=/storage-manage(loopback 只读投影 + 三类动作)。
@@ -2673,7 +3721,8 @@ window.__ModuleLoader__.load({
         rows.push(h('div', { 'data-dam-hint': '', style: { marginTop: '12px', opacity: .7 } },
           (locale === 'zh' ? '最近动作: ' : 'recent: ') + audit.map(function (a) { return a.action }).join(', ')))
       }
-      return h('div', null, rows)
+      // 大屏分列:卡片流页签(见 CSS [data-dam-flow]);非卡片子元素仍整行。
+      return h('div', { 'data-dam-flow': '' }, rows)
     }
 
     function NotesTab() {
@@ -2992,7 +4041,21 @@ window.__ModuleLoader__.load({
           autoCfg ? h('label', { 'data-dam-hint': '', style: { marginLeft: '8px' } }, t('autoContThreshold') + ' ', h('input', { 'data-dam-input': '', type: 'number', min: 0.5, max: 0.95, step: 0.05, value: String(autoCfg.threshold), onChange: function (e) { var v = Number(e.target.value); if (v >= 0.5 && v <= 0.95) autoSave({ autoContinueThreshold: v }) } })) : null,
         ]),
       ]))
-      if (!data.enabled) return h('div', null, [switchCard, h(Card, { title: t('planTitle') }, h('div', { 'data-dam-hint': '' }, t('planDisabled')))])
+      // ★2026-09-17(L2 修 bug①): 面板侧同样**按真实 reason 分支** —— 旧实现一律显示 t('planDisabled')
+      // (「白板未启用」), 与看板那句同源的误导。后端现在会带 reason: 'legacy-mode' / 'error'。
+      if (!data.enabled) {
+        var disMsg = (function () {
+          var r = data && data.reason
+          if (r === 'legacy-mode') {
+            return locale === 'zh'
+              ? '当前是旧版白板(legacy)档。看板需要切到「新版看板（dsh-graph）」——用上方开关切换, 重启 dsh web 后生效。'
+              : 'Legacy board mode. The kanban needs the graph board — toggle it above, then restart dsh web.'
+          }
+          if (r === 'error') return (locale === 'zh' ? '白板加载出错: ' : 'Whiteboard load error: ') + String((data && data.error) || '')
+          return t('planDisabled')
+        })()
+        return h('div', null, [switchCard, h(Card, { title: t('planTitle') }, h('div', { 'data-dam-hint': '' }, disMsg))])
+      }
       var wl = data.waterLevel || {}
       // 2026-09-13(工作区切换修复):宿主对当前会话解析不出工作区身份时(wsBound:false),如实提示
       // 而不是渲染另一个会话/启动目录下的白板内容(旧全局单值行为的残余观感)。
@@ -3027,7 +4090,7 @@ window.__ModuleLoader__.load({
               tg.tag + ' ×' + tg.count)
           })))
           tagKids.push(h('div', { 'data-dam-hint': '', style: { marginTop: '4px' } },
-            locale === 'zh' ? '标签来自账本/白板行内标记(tag:xxx / type:xxx / topic:xxx)。模型侧可用 memory_expand_pre(tag) 按标签展开条目、memory_trace_pre(id) 回溯来源与版本链。' : 'Tags come from inline markers (tag:xxx / type:xxx / topic:xxx). The model can use memory_expand_pre(tag) to expand by tag and memory_trace_pre(id) to trace origin and version chain.'))
+            locale === 'zh' ? '标签来自账本/白板行内标记(tag:xxx / type:xxx / topic:xxx)。模型侧可用 memory_expand(tag) 按标签展开条目、memory_trace(id) 回溯来源与版本链。' : 'Tags come from inline markers (tag:xxx / type:xxx / topic:xxx). The model can use memory_expand(tag) to expand by tag and memory_trace(id) to trace origin and version chain.'))
         } else {
           tagKids.push(h('div', { 'data-dam-muted': '' }, locale === 'zh' ? '尚无标签——在账本/白板里写 tag:xxx 后重新写入即出现。' : 'No tags yet — write tag:xxx in a ledger/plan and re-save.'))
         }
@@ -3087,7 +4150,8 @@ window.__ModuleLoader__.load({
       }
       // 2026-09-14 修复:开关卡此前只在「未启用」分支被返回 ⇒ 白板一旦开启,白板页就再也看不到开关(开得了、关不掉)。
       // 开关卡必须在**两种**状态下都渲染 —— 它是这个页面上唯一的开关入口。
-      return h('div', null, [switchCard].concat(rows))
+      // 大屏分列:卡片流页签(见 CSS [data-dam-flow]);非卡片子元素仍整行。
+      return h('div', { 'data-dam-flow': '' }, [switchCard].concat(rows))
     }
 
     function ReflectionsTab() {
@@ -3143,7 +4207,8 @@ window.__ModuleLoader__.load({
           })(data.reflections[i])
         }
       }
-      return h('div', null, rows)
+      // 大屏分列:卡片流页签(见 CSS [data-dam-flow]);非卡片子元素仍整行。
+      return h('div', { 'data-dam-flow': '' }, rows)
     }
 
     function SearchTab() {
@@ -3171,7 +4236,8 @@ window.__ModuleLoader__.load({
         apiPost(API.smartRecall, { query: q.trim() }).then(function (d) { setSmart(d); setBusy(false) })
           .catch(function (e) { setSmart({ answer: t('searchFailed') + e.message, keywords: [], hits: [] }); setBusy(false) })
       }
-      return h('div', null,
+      // 大屏分列:卡片流页签(见 CSS [data-dam-flow]);非卡片子元素仍整行。
+      return h('div', { 'data-dam-flow': '' },
         h('div', { 'data-dam-row': '' },
           h('input', { 'data-dam-input': '', placeholder: t('searchPlaceholder'), value: q, onChange: function (e) { setQ(e.target.value) }, onKeyDown: function (e) { if (e.key === 'Enter') search() } }),
           h('button', { 'data-dam-btn': '', onClick: search, disabled: busy }, t('searchBtn')),
@@ -3181,7 +4247,16 @@ window.__ModuleLoader__.load({
           h('div', { 'data-dam-content': '' }, smart.answer || t('empty')),
           smart.keywords && smart.keywords.length ? h('div', { 'data-dam-hint': '', style: { marginTop: '6px' } }, t('keywordsLabel') + smart.keywords.join(' / ')) : null,
           Array.isArray(smart.hits) && smart.hits.length ? h('div', { 'data-dam-hint': '', style: { marginTop: '6px' } },
-            smart.hits.map(function (hit, i) { return hit && typeof hit === 'object' ? h('div', { key: i, style: { marginTop: '3px', overflowWrap: 'anywhere' } }, '· [' + String(hit.where || '') + '] ' + String(hit.line || '')) : null })) : null)
+            // ★P1-2 补接线(2026-09-22):宿主**早已**把结论层标记放进 smartRecall 的 hits 投影
+            //   (index.js:6469 → l0-extract.js:295+,文案形如「⚠已撤回」),前端此前零渲染
+            //   ⇒「这条结论已失效」在界面上完全看不出来,用户会把它当有效结论读。mark 自带文案 ⇒ 零 i18n。
+            smart.hits.map(function (hit, i) {
+              if (!hit || typeof hit !== 'object') return null
+              var mark = hit.mark === undefined || hit.mark === null ? '' : String(hit.mark).trim()
+              return h('div', { key: i, style: { marginTop: '3px', overflowWrap: 'anywhere' } },
+                mark ? h('span', { 'data-dam-hint': '', style: { marginRight: '5px', fontWeight: 600, color: 'var(--dsw-alias-state-warn-primary, #e8c584)' } }, mark) : null,
+                '· [' + String(hit.where || '') + '] ' + String(hit.line || ''))
+            })) : null)
           : null,
         result ? h(Card, { title: t('resultTitle') }, h('div', { 'data-dam-content': '' }, result)) : null)
     }
@@ -3303,7 +4378,8 @@ window.__ModuleLoader__.load({
           h('div', { 'data-dam-graph-toolbar': '' }, h('span', { 'data-dam-hint': '' }, locale === 'zh' ? '思维导图大小' : 'Map size'), h('input', { type: 'range', min: '0.55', max: '1.75', step: '0.05', value: graphScale, 'aria-label': locale === 'zh' ? '调整思维导图大小' : 'Adjust map size', onChange: function (e) { setGraphScale(Number(e.target.value) || 1.0) } }), h('span', { 'data-dam-hint': '' }, Math.round(graphScale * 100) + '%'), h('button', { 'data-dam-btn': '', title: locale === 'zh' ? '重置视图' : 'Reset view', onClick: function () { setGraphScale(1.0) } }, '⌂')),
           h('div', { 'data-dam-hint': '' }, locale === 'zh' ? '点击工作区卡片查看摘要；拖动滑块调整图的大小。' : 'Select a workspace card for details; use the slider to resize the map.'),
           h(WorkspaceGraph, { workspaces: workspaces, graph: data.graph, scale: graphScale, onSelect: function (ws) { setSelected(ws); var n = Object.assign({}, collapsedByPath); n[ws.path] = false; setCollapsedByPath(n) } }),
-          h('div', { style: { marginTop: '12px' } }, workspaces.map(function (ws) {
+          // ★大屏分列(2026-09-22):工作区卡片(已带 [data-dam-card])在宽屏排成多列。
+        h('div', { 'data-dam-flow': '', style: { marginTop: '12px' } }, workspaces.map(function (ws) {
             var open = collapsedByPath[ws.path] === false
             return h('div', { key: ws.path, 'data-dam-card': '', style: { marginBottom: '8px', padding: '0' } },
               h('button', { 'data-dam-btn': '', 'aria-expanded': open ? 'true' : 'false', onClick: function () { var n = Object.assign({}, collapsedByPath); n[ws.path] = !open; setCollapsedByPath(n); setSelected(ws) }, style: { width: '100%', textAlign: 'left', padding: '10px 12px', fontWeight: 650 } }, (open ? '▾ ' : '▸ ') + ws.name + (ws.dateRange ? ' · ' + ws.dateRange : '')),
@@ -3321,6 +4397,7 @@ window.__ModuleLoader__.load({
       '未分类': { color: 'var(--dsw-alias-label-secondary, #8a94a6)' },
     }
     function CalendarTab() {
+      var zh = (locale || 'zh').indexOf('zh') === 0
       var dataPair = useState(null)
       var data = dataPair[0]
       var setData = dataPair[1]
@@ -3447,16 +4524,61 @@ window.__ModuleLoader__.load({
       // 日期格先打开当天时间轴；点击某个时间槽才创建事件。
       if (dayView) {
         var timeline = []
-        for (var hourSlot = 7; hourSlot <= 22; hourSlot++) {
+        var dayAll = dayEntries(dayView)
+        // ★2026-09-20 修 bug: 旧实现把时间轴写死为 `for (hourSlot = 7; hourSlot <= 22; ...)`。
+        //   后果: 任何 23:00–06:59 或 time='--:--' 的事件**在当天视图里永不显示**——
+        //   而用户的真实数据里就有 7 条 23:59 截止的作业(AMA1751 / BME1D02)。
+        //   现改为**由数据驱动**: 先扫当天事件的真实小时, 用其 min/max 决定时间轴范围
+        //   (无事件时才回落到 07:00–22:00), 且任何落在范围外的事件单独成"时间轴外"一段。
+        var hourNums = []
+        var untimed = []
+        for (var di = 0; di < dayAll.length; di++) {
+          var tm = String(dayAll[di].time || '')
+          var hh = parseInt(tm.slice(0, 2), 10)
+          if (isNaN(hh)) { untimed.push(dayAll[di]); continue }
+          hourNums.push(hh)
+        }
+        var hFrom = hourNums.length ? Math.min.apply(null, hourNums) : 7
+        var hTo = hourNums.length ? Math.max.apply(null, hourNums) : 22
+        if (hFrom > 7) hFrom = 7
+        if (hTo < 22) hTo = 22
+        // 每个小时槽: 支持同名 key 去重(同小时多事件)
+        for (var hourSlot = hFrom; hourSlot <= hTo; hourSlot++) {
           (function (hourValue) {
             var hourText = String(hourValue).padStart(2, '0') + ':00'
-            var hourEvents = dayEntries(dayView).filter(function (en) { return String(en.time || '').slice(0, 2) === String(hourValue).padStart(2, '0') })
+            var pad = String(hourValue).padStart(2, '0')
+            var hourEvents = dayAll.filter(function (en) { return String(en.time || '').slice(0, 2) === pad })
             timeline.push(h('div', { key: hourText, 'data-dam-calendar-slot': '', onClick: function () { setDayView(null); setDraft({ date: dayView, time: hourText, quadrant: '重要不紧急', title: '', location: '', reminder: '', note: '' }) } },
               h('div', { style: { flex: '0 0 50px', fontSize: 'calc(11px * var(--dam-scale))', opacity: .65 } }, hourText),
-              h('div', { style: { minHeight: '34px', flex: 1, borderLeft: '2px solid color-mix(in srgb, var(--dam-accent, #1d4ed8) 24%, transparent)', paddingLeft: '9px' } }, hourEvents.length ? hourEvents.map(function (en) { var qs = QUADRANT_STYLE[en.quadrant] || QUADRANT_STYLE['未分类']; return h('div', { key: en.time + en.title, 'data-dam-calendar-event': '', onClick: function (ev) { ev.stopPropagation(); toggleDone(en) }, style: { marginBottom: '4px', padding: '4px 7px', borderRadius: 6, background: 'color-mix(in srgb, ' + qs.color + ' 18%, transparent)', color: qs.color, textDecoration: en.done ? 'line-through' : 'none' } }, (en.time || '') + '  ' + en.title + (en.note ? ' · ' + en.note : '')) }) : h('span', { 'data-dam-hint': '' }, locale === 'zh' ? '点击添加事件' : 'Click to add event'))))
+              h('div', { style: { minHeight: '34px', flex: 1, borderLeft: '2px solid color-mix(in srgb, var(--dam-accent, #1d4ed8) 24%, transparent)', paddingLeft: '9px' } }, hourEvents.length ? hourEvents.map(function (en, k) { var qs = QUADRANT_STYLE[en.quadrant] || QUADRANT_STYLE['未分类']; return h('div', { key: String(en.time) + '#' + k, 'data-dam-calendar-event': '', onClick: function (ev) { ev.stopPropagation(); toggleDone(en) }, style: { marginBottom: '4px', padding: '4px 7px', borderRadius: 6, background: 'color-mix(in srgb, ' + qs.color + ' 18%, transparent)', color: qs.color, textDecoration: en.done ? 'line-through' : 'none', opacity: en.done ? .55 : 1, cursor: 'pointer' } }, (en.time || '') + '  ' + en.title + (en.note ? ' · ' + en.note : '')) }) : h('span', { 'data-dam-hint': '' }, locale === 'zh' ? '点击添加事件' : 'Click to add event'))))
           })(hourSlot)
         }
-        rows.push(h('div', { 'data-dam-calendar-modal': '', style: { position: 'absolute', inset: 0, zIndex: 10, overflow: 'auto', borderRadius: '16px', background: 'color-mix(in srgb, var(--dsw-alias-bg-layer-2, rgba(255,255,255,.9)) 78%, transparent)', backdropFilter: 'blur(20px) saturate(1.4)', WebkitBackdropFilter: 'blur(20px) saturate(1.4)', padding: '16px' } }, h('div', { 'data-dam-row': '' }, h('div', { style: { fontWeight: 700, flex: 1 } }, dayView + ' · ' + (locale === 'zh' ? '当天安排' : 'Day schedule')), h('button', { 'data-dam-btn': '', onClick: function () { setDayView(null) } }, '✕')), timeline))
+        // 时间轴外(无 time 或 time 无法解析)的事件单独列出 —— 不再静默丢失
+        if (untimed.length) {
+          timeline.push(h('div', { key: '__untimed', 'data-dam-calendar-slot': '', onClick: function () { setDayView(null); setDraft({ date: dayView, time: '23:59', quadrant: '重要不紧急', title: '', location: '', reminder: '', note: '' }) } },
+            h('div', { style: { flex: '0 0 50px', fontSize: 'calc(11px * var(--dam-scale))', opacity: .65 } }, zh ? '未定时' : 'n/a'),
+            h('div', { style: { minHeight: '34px', flex: 1, borderLeft: '2px solid color-mix(in srgb, var(--dsw-alias-state-warn-primary, #d4a94f) 55%, transparent)', paddingLeft: '9px' } }, untimed.map(function (en, k) { var qs = QUADRANT_STYLE[en.quadrant] || QUADRANT_STYLE['未分类']; return h('div', { key: 'u' + k, 'data-dam-calendar-event': '', onClick: function (ev) { ev.stopPropagation(); toggleDone(en) }, style: { marginBottom: '4px', padding: '4px 7px', borderRadius: 6, background: 'color-mix(in srgb, ' + qs.color + ' 18%, transparent)', color: qs.color, textDecoration: en.done ? 'line-through' : 'none', opacity: en.done ? .55 : 1, cursor: 'pointer' } }, en.title + (en.note ? ' · ' + en.note : '')) }))))
+        }
+        // 当天前后翻页(原实现只能靠「先关掉浮层 → 再点另一个日期」, 多一次无效操作)
+        var dPrev = new Date(dayView + 'T00:00:00'); dPrev.setDate(dPrev.getDate() - 1)
+        var dNext = new Date(dayView + 'T00:00:00'); dNext.setDate(dNext.getDate() + 1)
+        var fmtD = function (dt) { return dt.getFullYear() + '-' + String(dt.getMonth() + 1).padStart(2, '0') + '-' + String(dt.getDate()).padStart(2, '0') }
+        var wk = (function (ds) {
+          // ISO-8601 周序号(周一为一周之始, 第 1 周含当年首个周四)
+          var dt = new Date(ds + 'T00:00:00')
+          var t = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate())
+          t.setDate(t.getDate() + 3 - ((t.getDay() + 6) % 7))
+          var ws = new Date(t.getFullYear(), 0, 4)
+          ws.setDate(ws.getDate() + 3 - ((ws.getDay() + 6) % 7))
+          return 1 + Math.round((t - ws) / 604800000)
+        })(dayView)
+        rows.push(h('div', { 'data-dam-calendar-modal': '', style: { position: 'absolute', inset: 0, zIndex: 10, overflow: 'auto', borderRadius: '16px', background: 'color-mix(in srgb, var(--dsw-alias-bg-layer-2, rgba(255,255,255,.9)) 78%, transparent)', backdropFilter: 'blur(20px) saturate(1.4)', WebkitBackdropFilter: 'blur(20px) saturate(1.4)', padding: '16px' } },
+          h('div', { 'data-dam-row': '' },
+            h('button', { 'data-dam-btn': '', title: zh ? '前一天' : 'previous day', onClick: function () { setDayView(fmtD(dPrev)) } }, '‹'),
+            h('div', { style: { fontWeight: 700, flex: 1, textAlign: 'center' } }, dayView + ' · ' + (zh ? '第 ' + wk + ' 周' : 'W' + wk) + ' · ' + dayAll.length + (zh ? ' 项' : ' items')),
+            h('button', { 'data-dam-btn': '', title: zh ? '后一天' : 'next day', onClick: function () { setDayView(fmtD(dNext)) } }, '›'),
+            h('button', { 'data-dam-btn': '', onClick: function () { setDayView(null) } }, '✕')),
+          timeline))
       }
       // 添加/编辑浮层(液态玻璃)
       if (draft) {
@@ -3607,7 +4729,9 @@ window.__ModuleLoader__.load({
               : null)))
         })(sources[i])
       }
-      return h('div', null,
+      // ★大屏分列(2026-09-22):本组件的 Card 由 `cards)` 直接铺进根节点 ⇒ 是根的**直接子元素**,
+      //   在根上打 [data-dam-flow] 即可生效(与日志/中枢页签同款)。非卡片子元素(hint/按钮行/msg/err)仍整行。
+      return h('div', { 'data-dam-flow': '' },
         h('div', { 'data-dam-hint': '' }, t('connectHint')),
         h('div', { 'data-dam-row': '' },
           h('button', { 'data-dam-btn': '', onClick: importAll }, t('importAll')),
@@ -3693,12 +4817,97 @@ window.__ModuleLoader__.load({
         h('button', { 'data-dam-tabs-arrow': '', title: locale === 'zh' ? '向右滚动模块' : 'Scroll modules right', 'aria-label': locale === 'zh' ? '向右滚动模块' : 'Scroll modules right', disabled: !canRight, onClick: function () { step(1) } }, '›'))
     }
 
+    // ══════════════════════════════════════════════════════════════════════════
+    // 共享渲染件(2026-09-21)：浮层与「记忆」会话页复用同一份页签表与内容体。
+    // 抽出来的动机：两种承载面必须"同内容、同页签、同数据"（用户要求同步），
+    //   若各写一份 body 分支，页签一多必然漂移 ⇒ 只留一处事实。
+    // ══════════════════════════════════════════════════════════════════════════
+    function MemoryTabBody(tab, nonce) {
+      if (tab === 'overview') return h(OverviewTab, { nonce: nonce })
+      if (tab === 'logs') return h(LogsTab)
+      if (tab === 'refine') return h(RefineTab)
+      if (tab === 'hub') return h(MemoryHubTab, { nonce: nonce })
+      if (tab === 'storage') return h(StorageTab, { nonce: nonce })
+      if (tab === 'notes') return h(NotesTab)
+      if (tab === 'plan') return h(PlanTab)
+      if (tab === 'reflections') return h(ReflectionsTab)
+      if (tab === 'connect') return h(ConnectTab)
+      if (tab === 'calendar') return h(CalendarTab)
+      if (tab === 'workspaces') return h(WorkspaceTab)
+      return h(SearchTab)
+    }
+    function MEMORY_TABS() {
+      return [['overview', t('overview')], ['logs', t('logs')], ['refine', t('refineTab')], ['hub', t('hubTab')], ['storage', t('storageTab')], ['notes', t('notes')], ['plan', t('planTab')], ['reflections', t('reflections')], ['connect', t('connect')], ['calendar', t('calendar')], ['search', t('search')], ['workspaces', t('workspaces')]]
+    }
+
+    // 「记忆」会话页(2026-09-21 二次修正) —— 注册在 conversation.view 槽位,与「对话轨迹」「上下文」「白板看板」并列。
+    // 用户诉求原话:「它现在是浮在整个页面上方的,而不是和对话轨迹、上下文、白板看板在一起,作为一个单独的一页」。
+    // 宿主只给 shell.overlay 这类"盖在界面上"的槽位,做不出并列页 ⇒ 必须走 conversation.view。
+    // 与浮层的关系:同一份 panelTab/数据/刷新 nonce,切页签两边同步;只在承载面上不同(页更宽)。
+    function MemoryPageView(props) {
+      var tick = useTick()
+      var tab = controller.panelTab()
+      var noncePair = useState(0)
+      var nonce = noncePair[0]
+      var setNonce = noncePair[1]
+      var verPair = useState(null)
+      var ver = verPair[0]
+      var setVer = verPair[1]
+      useEffect(function () { return controller.subscribe(tick[1]) }, [])
+      useEffect(function () {
+        var alive = true
+        apiGet(API.updateCheck).then(function (d) { if (alive && d && d.current) setVer(d.current) }).catch(function () {})
+        return function () { alive = false }
+      }, [])
+      var zh = locale === 'zh'
+      var verBadge = ver ? 'v' + ver + '-ui' : ''
+      var body = MemoryTabBody(tab, nonce)
+      // 浮层开关(page ↔ both 互切):两个方向都不注销本页签(修自毁按钮)。
+      var floatOn = controller.panelPos() === 'both'
+      var floatLabel = floatOn ? (zh ? '收起浮层' : 'Hide card') : (zh ? '打开浮层' : 'Open card')
+      var floatTitle = floatOn ? (zh ? '收起左下角浮层(保留本页)' : 'Hide bottom-left card (keep this page)') : (zh ? '同时打开左下角浮层(保留本页)' : 'Also open bottom-left card (keep this page)')
+      var onFloatToggle = function () { controller.setPanelPos(floatOn ? 'page' : 'both') }
+      var scaleAttr = fontScale in FONT_SCALES ? fontScale : 'md'
+      return h('div', {
+        'data-dam-page': '',
+        'data-scale': scaleAttr,
+        style: {
+          '--dam-user-scale': FONT_SCALE_VALUES[fontScale] || '1',
+          '--dam-accent': ACCENT_VALUES[accentTheme] || ACCENT_VALUES.deepseek,
+        },
+      },
+        h('header', { 'data-dam-page-head': '' },
+          h('strong', null, t('autoMemory')),
+          h('span', { 'data-dam-hint': '', style: { fontSize: '10px', opacity: .55 } }, verBadge),
+          h('span', { className: 'dam-spacer' }),
+          h('button', { 'data-dam-btn': '', title: t('refresh'), onClick: function () { setNonce(nonce + 1) } }, '⟳'),
+          // ★2026-09-22 修「自毁按钮」(方向文档 §3.1 硬性要求 1):原实现在 page 档点一下即把本页签注销
+          //   (conversation.view 仅在 page/both 档注册)⇒ 用户实测「上面的东西连按钮一起消失」。
+          //   现改为 page ↔ both 互切:both 档页签始终保留,两个方向都不注销当前页。
+          h('button', {
+            'data-dam-btn': '', 'data-dam-float-toggle': floatOn ? 'on' : 'off',
+            title: floatTitle,
+            onClick: onFloatToggle,
+          }, floatLabel)),
+        // ★2026-09-22 版式:顶部横向滚动页签 → 左侧固定侧栏(用户原话「把原本放在上面的那个切换横条
+        //   放到左侧,这样排版会更科学一点」)。浮层仍用 TabScroller(窄容器保持原版式),
+        //   两者共享同一份 panelTab 状态 ⇒ 切分区两边同步(既有契约不变)。
+        h('div', { 'data-dam-page-main': '' },
+          h('nav', { 'data-dam-page-nav': '', 'aria-label': zh ? '记忆分区' : 'Memory sections' },
+            MEMORY_TABS().map(function (item) {
+              return h('button', { key: item[0], 'data-dam-nav-item': '', 'data-active': tab === item[0] ? 'true' : undefined, onClick: function () { controller.setPanelTab(item[0]) } }, item[1])
+            })),
+          h('div', { 'data-dam-page-content': '' },
+            h('div', { 'data-dam-body': '' }, body))))
+    }
+
     function MemoryPanel() {
       var tick = useTick()
       var panelRef = useRef(null)
-      var tabPair = useState('overview')
-      var tab = tabPair[0]
-      var setTab = tabPair[1]
+      // 页签状态走模块级共享(2026-09-21):浮层与「记忆」会话页读同一个 panelTab ⇒ 两处切页互相同步。
+      // (用户诉求原话:「两者共存…要保证同步」。不用两份 useState,从根上杜绝状态漂移。)
+      var tab = controller.panelTab()
+      var setTab = controller.setPanelTab
       // 刷新 nonce:每次打开面板 / 点 ⟳ 时递增,驱动各页签重拉数据
       var noncePair = useState(0)
       var nonce = noncePair[0]
@@ -3707,6 +4916,7 @@ window.__ModuleLoader__.load({
       var ver = verPair[0]
       var setVer = verPair[1]
       var g = controller.geom()
+      var pos = controller.panelPos()
       useEffect(function () { return controller.subscribe(tick[1]) }, [])
       // 真实版本号(#15):面板头徽标不再硬编码,从 update-check 的 current(读包 version)取,失败留空
       useEffect(function () {
@@ -3718,81 +4928,91 @@ window.__ModuleLoader__.load({
       // 主题令牌 --dsw-alias-bg-layer-2 本身就是半透明的,面板文字几乎不可读。判别信号用
       // 「令牌自身的 alpha」(增强模式显著低于普通模式的 0.86-0.9):< 0.65 时把面板背景提升到
       // 0.96(保留色相)并弱化顶部高光。普通模式令牌不透明 → 不触发,液态玻璃观感零变化。
+      // 2026-09-21:两种形态(浮层/顶部停靠条)各查一次 —— panelRef 只绑浮层,停靠条用选择器兜底,
+      // 否则增强模式下顶栏模式会保持半透明、可读性退化。
       useEffect(function () {
         if (!panelOpen) return
-        var el = panelRef.current
-        if (!el) return
-        try {
-          var cs = getComputedStyle(el)
-          var token = cs.getPropertyValue('--dsw-alias-bg-layer-2')
-          var col = parseCssColor((token || '').trim() || cs.backgroundColor)
-          if (col && col.a < 0.65) {
-            el.style.background = 'rgba(' + col.r + ', ' + col.g + ', ' + col.b + ', 0.96)'
-            el.setAttribute('data-solid', 'true')
-          } else {
-            el.style.background = ''
-            el.removeAttribute('data-solid')
-          }
-        } catch (e) {}
+        // 2026-09-21 二次修正:原「顶部停靠条」第二形态已废弃(改走 conversation.view 会话页),
+        // 故此处只剩浮层一个元素需要兜底 —— 会话页在正常文档流里,背景由宿主给,无需提升不透明度。
+        var els = panelRef.current ? [panelRef.current] : []
+        for (var j = 0; j < els.length; j++) {
+          var el = els[j]
+          if (!el) continue
+          try {
+            var cs = getComputedStyle(el)
+            var token = cs.getPropertyValue('--dsw-alias-bg-layer-2')
+            var col = parseCssColor((token || '').trim() || cs.backgroundColor)
+            if (col && col.a < 0.65) {
+              el.style.background = 'rgba(' + col.r + ', ' + col.g + ', ' + col.b + ', 0.96)'
+              el.setAttribute('data-solid', 'true')
+            } else {
+              el.style.background = ''
+              el.removeAttribute('data-solid')
+            }
+          } catch (eEl) {}
+        }
       }, [panelOpen])
       if (!panelOpen && !panelClosing) return null
-      var body
-      if (tab === 'overview') body = h(OverviewTab, { nonce: nonce })
-      else if (tab === 'logs') body = h(LogsTab)
-      else if (tab === 'refine') body = h(RefineTab)
-      else if (tab === 'hub') body = h(MemoryHubTab, { nonce: nonce })
-      else if (tab === 'storage') body = h(StorageTab, { nonce: nonce })
-      else if (tab === 'notes') body = h(NotesTab)
-      else if (tab === 'plan') body = h(PlanTab)
-      else if (tab === 'reflections') body = h(ReflectionsTab)
-      else if (tab === 'connect') body = h(ConnectTab)
-      else if (tab === 'calendar') body = h(CalendarTab)
-      else if (tab === 'workspaces') body = h(WorkspaceTab)
-      else body = h(SearchTab)
-      var tabs = [['overview', t('overview')], ['logs', t('logs')], ['refine', t('refineTab')], ['hub', t('hubTab')], ['storage', t('storageTab')], ['notes', t('notes')], ['plan', t('planTab')], ['reflections', t('reflections')], ['connect', t('connect')], ['calendar', t('calendar')], ['search', t('search')], ['workspaces', t('workspaces')]]
-      var style = {
-        left: g.left + 'px',
-        top: g.top + 'px',
-        width: g.width + 'px',
-        height: g.height + 'px',
-        '--dam-scale': FONT_SCALE_VALUES[fontScale] || '1',
-        '--dam-accent': ACCENT_VALUES[accentTheme] || ACCENT_VALUES.deepseek,
-      }
+      var body = MemoryTabBody(tab, nonce)
+      var tabs = MEMORY_TABS()
+      // 承载面(2026-09-21):①左下角浮层(可拖拽/缩放) ②「记忆」会话页(conversation.view,与「对话轨迹」并列)。
+      // 两者共用同一份 tab(模块级 panelTab)/数据/刷新 nonce ⇒ 天然同步(用户要求);本函数只负责浮层节点。
       var dragMove = startPointerDrag(function (dx, dy) {
         controller.setGeom({ left: g.left + dx, top: g.top + dy })
       }, '[data-dam-btn], [data-dam-tab], [data-dam-input], [data-dam-select], textarea')
       var resizeMove = startPointerDrag(function (dx, dy) {
         controller.setGeom({ width: g.width + dx, height: g.height + dy })
       })
-      return h('div', {
-        'data-dam-panel': '',
-        'data-scale': fontScale in FONT_SCALES ? fontScale : 'md',
-        ref: panelRef,
-        style: style,
-        'data-closing': panelClosing ? 'true' : undefined,
-        'data-dragging': dragActive ? 'true' : undefined,
-      },
-        h('header', {
-          title: t('dragMove'),
-          onPointerDown: dragMove,
+      var scaleAttr = fontScale in FONT_SCALES ? fontScale : 'md'
+      var verBadge = ver ? 'v' + ver + '-ui' : ''
+      var nodes = []
+      if (pos === 'bottom-left' || pos === 'both') {
+        var floatStyle = {
+          left: g.left + 'px',
+          top: g.top + 'px',
+          width: g.width + 'px',
+          height: g.height + 'px',
+          '--dam-scale': FONT_SCALE_VALUES[fontScale] || '1',
+          '--dam-accent': ACCENT_VALUES[accentTheme] || ACCENT_VALUES.deepseek,
+        }
+        nodes.push(h('div', {
+          key: 'float',
+          'data-dam-panel': '',
+          'data-pos': 'float',
+          'data-scale': scaleAttr,
+          ref: panelRef,
+          style: floatStyle,
+          'data-closing': panelClosing ? 'true' : undefined,
+          'data-dragging': dragActive ? 'true' : undefined,
         },
-          h('strong', null, t('autoMemory')),
-          h('span', { 'data-dam-hint': '', style: { fontSize: '10px', opacity: .55 } }, ver ? 'v' + ver + '-ui' : ''),
-          h('span', { className: 'dam-spacer' }),
-          // 悬浮钉(2026-09-08):钉住后点面板外不再自动收起;图标为线描 SVG,与 ⤾ ⟳ ✕ 同画风
-          h('button', {
-            'data-dam-btn': '', 'data-pin': pinned ? 'on' : 'off',
-            title: pinned ? t('unpinPanel') : t('pinPanel'),
-            'aria-pressed': pinned ? 'true' : 'false',
-            style: { display: 'inline-flex', alignItems: 'center', justifyContent: 'center', padding: '4px 6px' },
-            onClick: function () { controller.togglePin() },
-          }, h(PinIcon, { filled: pinned })),
-          h('button', { 'data-dam-btn': '', title: t('resetPos'), onClick: function () { controller.resetGeom() } }, '⤾'),
-          h('button', { 'data-dam-btn': '', title: t('refresh'), onClick: function () { setNonce(nonce + 1) } }, '⟳'),
-          h('button', { 'data-dam-btn': '', title: t('close'), onClick: function () { controller.close() } }, '✕')),
-        h(TabScroller, { tabs: tabs, tab: tab, setTab: setTab }),
-        h('div', { 'data-dam-body': '' }, body),
-        h('div', { 'data-dam-resize': '', title: t('dragResize'), onPointerDown: resizeMove }))
+          h('header', {
+            title: t('dragMove'),
+            onPointerDown: dragMove,
+          },
+            h('strong', null, t('autoMemory')),
+            h('span', { 'data-dam-hint': '', style: { fontSize: '10px', opacity: .55 } }, verBadge),
+            h('span', { className: 'dam-spacer' }),
+            // 悬浮钉(2026-09-08):钉住后点面板外不再自动收起;图标为线描 SVG,与 ⤾ ⟳ ✕ 同画风
+            h('button', {
+              'data-dam-btn': '', 'data-pin': pinned ? 'on' : 'off',
+              title: pinned ? t('unpinPanel') : t('pinPanel'),
+              'aria-pressed': pinned ? 'true' : 'false',
+              style: { display: 'inline-flex', alignItems: 'center', justifyContent: 'center', padding: '4px 6px' },
+              onClick: function () { controller.togglePin() },
+            }, h(PinIcon, { filled: pinned })),
+            h('button', { 'data-dam-btn': '', title: t('resetPos'), onClick: function () { controller.resetGeom() } }, '⤾'),
+            h('button', { 'data-dam-btn': '', title: t('refresh'), onClick: function () { setNonce(nonce + 1) } }, '⟳'),
+            h('button', { 'data-dam-btn': '', title: t('close'), onClick: function () { controller.close() } }, '✕')),
+          h(TabScroller, { key: 'ftabs', tabs: tabs, tab: tab, setTab: setTab }),
+          h('div', { key: 'fbody', 'data-dam-body': '' }, body),
+          h('div', { 'data-dam-resize': '', title: t('dragResize'), onPointerDown: resizeMove })))
+      }
+      // ★2026-09-21 二次修正:「顶部通栏覆盖条」形态已**废弃**。
+      //   用户实测反馈原话:「它现在是浮在整个页面上方的,而不是和对话轨迹、上下文、白板看板在一起,作为一个单独的一页」。
+      //   根因:宿主只给插件 4 个槽位(sidebar/main/rightbar/shell.overlay),放在 overlay 里的东西**只能盖在界面上**,
+      //   做不出「并列的一页」;要成为并列页必须注册到 conversation.view(见下面 MemoryPageView + registerSurfaces)。
+      //   故此处只剩浮层一个节点;'page' / 'both' 档的「会话页」由 conversation.view 槽位承载。
+      return nodes.length === 1 ? nodes[0] : h('div', { 'data-dam-panel-host': '' }, nodes)
     }
 
     // ───────────────────────── 调试中心(为提 issue 提供诊断) ─────────────────────────
@@ -3855,6 +5075,100 @@ window.__ModuleLoader__.load({
       var hb = data.heartbeat || {}
       var hbAge = hb.exists && hb.heartbeatAt ? Math.round((Date.now() - hb.heartbeatAt) / 1000) : -1
       var apiBad = probes && Object.keys(probes).some(function (k) { return probes[k].status === 404 || probes[k].error })
+      // ★P0-2（2026-09-22）：hub 三层记忆（episodes/facts/procedures）落盘 IO 健康度。
+      //   宿主 debugInfo().associativeMemory.hubIo 早已产出（lib/index.js:6959 → _hubIoViewSnapshot），
+      //   但前端零消费者 ⇒ save 失败被静默吞掉时，面板/日志/返回值三处都看不出「记忆到底写进磁盘了没有」。
+      //   防御式取值：宿主未升级 / 字段缺失时整行不渲染，绝不因此报错。
+      var am = data.associativeMemory && typeof data.associativeMemory === 'object' ? data.associativeMemory : {}
+      var hubIo = am.hubIo && typeof am.hubIo === 'object' ? am.hubIo : null
+      var hubIoWarn = false
+      var hubIoText = ''
+      if (hubIo) {
+        var hubErrs = Number(hubIo.errors) || 0
+        var hubLoads = Number(hubIo.loads) || 0
+        var hubSaves = Number(hubIo.saves) || 0
+        var hubClears = Number(hubIo.clears) || 0
+        hubIoWarn = hubErrs > 0 || hubIo.verdict === 'io-error'
+        if (hubErrs > 0) {
+          hubIoText = (locale === 'zh' ? '⚠ 累计失败 ' + hubErrs + ' 次 · 最近: ' : '⚠ ' + hubErrs + ' failure(s) · latest: ') +
+            (hubIo.lastError || t('unknown')) +
+            (hubIo.lastErrorAt ? ' (' + new Date(hubIo.lastErrorAt).toLocaleTimeString() + ')' : '')
+        } else if (hubLoads + hubSaves + hubClears > 0) {
+          hubIoText = locale === 'zh'
+            ? '✓ 正常（读 ' + hubLoads + ' · 写 ' + hubSaves + ' · 清 ' + hubClears + '，共 ' + (hubLoads + hubSaves + hubClears) + ' 次落盘操作无失败）'
+            : '✓ healthy (load ' + hubLoads + ' · save ' + hubSaves + ' · clear ' + hubClears + ', ' + (hubLoads + hubSaves + hubClears) + ' ops, 0 failures)'
+        } else {
+          hubIoText = locale === 'zh' ? '尚无落盘动作（本次运行还没有写入/读取）' : 'no disk activity yet this run'
+        }
+        // 无失败时优先采用宿主给出的中文整句 summary（如「三层记忆已正常落盘（本轮无写入失败）」）——
+        // 不在前端重拼一遍人话,避免两侧口径分叉。有失败时保留上面的详细行（含条数与人话原因 + 时间）。
+        if (hubErrs === 0 && hubIo.summary) hubIoText = String(hubIo.summary)
+      }
+      var hubIoByFile = hubIo && hubIoWarn && hubIo.byFile && typeof hubIo.byFile === 'object'
+        ? Object.keys(hubIo.byFile).map(function (k) {
+            var rec = hubIo.byFile[k] || {}
+            return k + ' × ' + (Number(rec.count) || 0)
+          }).join('   ')
+        : ''
+      // ★P0-3（2026-09-22）：事实保留上限淘汰台账。
+      //   getLastPrune()/retentionLimit()（fact-store.js:830/834）此前在宿主与前端**双侧**零调用方，
+      //   「事实被淘汰了」无处可查。只展示聚合数（条数/上限/超额/最旧时间），不展示任何事实正文。
+      var fp = am.factsPrune && typeof am.factsPrune === 'object' ? am.factsPrune : null
+      var fpWarn = false
+      var fpText = ''
+      if (fp) {
+        var fpPruned = Number(fp.pruned) || 0
+        var fpLimit = fp.limit === undefined || fp.limit === null ? '—' : fp.limit
+        fpWarn = fpPruned > 0
+        if (fpPruned > 0) {
+          fpText = locale === 'zh'
+            ? '上次淘汰 ' + fpPruned + ' 条（上限 ' + fpLimit + (fp.over ? '，超出 ' + fp.over : '') + '）' +
+              (fp.protected ? ' · 另有 ' + fp.protected + ' 条重要/未撤销条目受保护未删' : '') +
+              (fp.at ? ' · ' + new Date(fp.at).toLocaleTimeString() : '')
+            : 'last prune removed ' + fpPruned + ' (cap ' + fpLimit + (fp.over ? ', over ' + fp.over : '') + ')' +
+              (fp.protected ? ' · ' + fp.protected + ' protected (important/unrevoked) kept' : '') +
+              (fp.at ? ' · ' + new Date(fp.at).toLocaleTimeString() : '')
+        } else {
+          fpText = locale === 'zh'
+            ? '✓ 本次运行未发生淘汰（上限 ' + fpLimit + '）'
+            : '✓ no eviction yet this run (cap ' + fpLimit + ')'
+        }
+      }
+      // ★P1-1 补接线(2026-09-22)：Python 语义侧车看门狗 + stderr 尾部。
+      //   宿主 debugInfo().associativeMemory.pythonBackend 早已产出（lib/index.js:6944 →
+      //   Object.assign({ enabled }, client.debugView())），前端此前零渲染 ⇒ 侧车被看门狗
+      //   击杀/重生、以及 Python traceback 原文，用户一概看不到；现象只剩「语义唤回突然不好使了」，
+      //   无法归因。★铁律：Python 档是可选进阶项，未启用**不影响** JS 端语义 —— 文案必须写明，
+      //   否则用户会误判成「记忆坏了」。防御式取值：宿主未升级/字段缺失时整块不渲染，绝不报错。
+      var pySide = am.pythonBackend && typeof am.pythonBackend === 'object' ? am.pythonBackend : null
+      var pySideWarn = false
+      var pySideState = ''
+      var pySideWd = ''
+      var pySideTail = ''
+      var pySideHasTail = false
+      var pySideTrunc = false
+      if (pySide) {
+        var pyKills = Number(pySide.watchdog && pySide.watchdog.kills) || 0
+        var pyRespawns = Number(pySide.watchdog && pySide.watchdog.respawns) || 0
+        var pyGen = Number(pySide.generation) || 0
+        var pyReason = pySide.watchdog && pySide.watchdog.lastReason ? String(pySide.watchdog.lastReason) : ''
+        var pyBytes = Number(pySide.stderrTailBytes) || 0
+        pySideWarn = pyKills > 0
+        pySideState = pySide.enabled !== true
+          ? t('kvPyOff')
+          : (pySide.started === true
+            ? t('kvPyAlive') + (pyGen > 0 ? (locale === 'zh' ? '（第 ' + pyGen + ' 代）' : ' (gen ' + pyGen + ')') : '')
+            : (locale === 'zh' ? '未运行（惰性启动：首次请求才拉起进程）' : 'not running (lazy: spawned on first request)'))
+        pySideWd = pyKills === 0
+          ? (locale === 'zh' ? '无（未触发）' : 'none')
+          : (locale === 'zh'
+            ? '击杀 ' + pyKills + ' 次 · 重生 ' + pyRespawns + ' 次' + (pyReason ? '（最近：' + pyReason + '）' : '')
+            : 'kills ' + pyKills + ' · respawns ' + pyRespawns + (pyReason ? ' (latest: ' + pyReason + ')' : ''))
+        if (pySide.lastStderrTail) { pySideTail = String(pySide.lastStderrTail); pySideHasTail = true }
+        else if (pyBytes === 0) pySideTail = locale === 'zh' ? '确实没有输出（不是被截断）' : 'no output at all (not truncated)'
+        else pySideTail = locale === 'zh' ? '有 stderr 输出但无可显示行（全为空白行）' : 'stderr output present but no printable line (blank only)'
+        pySideTrunc = pySide.lastStderrTailTruncated === true
+      }
       return h('div', null,
         h('div', { 'data-dam-row': '' },
           h('button', { 'data-dam-btn': '', onClick: refresh, disabled: busy }, busy ? t('dbgRefreshing') : t('dbgRefresh')),
@@ -3871,6 +5185,18 @@ window.__ModuleLoader__.load({
         kv(t('kvMem'), t('kvMemUser') + ' ' + (data.memoryFiles.user.exists ? fmtSize(data.memoryFiles.user.size) : t('kvMemMissing')) + ' · ' + t('kvMemNotes') + ' ' + (data.memoryFiles.notes.exists ? fmtSize(data.memoryFiles.notes.size) : t('kvMemMissing')) + ' · ' + t('kvMemLog') + ' ' + (data.memoryFiles.log.exists ? fmtSize(data.memoryFiles.log.size) : t('kvMemMissing')), !data.memoryFiles.log.exists),
         kv(t('kvWs'), currentWs() || t('kvWsUnknown'), false),
         kv(t('kvApi'), probes ? Object.keys(probes).map(function (k) { return k + '=' + (probes[k].status !== undefined ? probes[k].status : probes[k].error) }).join('  ') : '…', apiBad),
+        hubIo ? kv(t('dbgHubIo'), hubIoText, hubIoWarn) : null,
+        hubIoByFile ? h('div', { 'data-dam-hint': '', style: { marginLeft: '140px', wordBreak: 'break-all' } },
+          (locale === 'zh' ? '按层拆分（失败次数）：' : 'per-store failures: ') + hubIoByFile) : null,
+        fp ? kv(t('dbgPrune'), fpText, fpWarn) : null,
+        pySide ? h('div', { 'data-dam-row': '', style: { marginTop: '3px', flexDirection: 'column', alignItems: 'stretch' } },
+          kv(t('kvPyTitle'), pySideState, false),
+          kv(t('kvPyWatchdog'), pySideWd, pySideWarn),
+          h('div', { 'data-dam-hint': '', style: { marginTop: '3px' } },
+            t('kvPyStderr') + (pySideTrunc ? t('kvPyStderrTrunc') : '') + '：' + pySideTail,
+            pySideHasTail
+              ? h('pre', { style: { margin: '3px 0 0 0', padding: '6px 8px', maxHeight: '200px', overflow: 'auto', whiteSpace: 'pre-wrap', wordBreak: 'break-all', background: 'rgba(127,127,127,.10)', borderRadius: '6px', fontSize: 'calc(11px * var(--dam-scale))' } }, pySideTail)
+              : null)) : null,
         h('div', { 'data-dam-row': '', style: { marginTop: '6px', alignItems: 'flex-start', flexDirection: 'column' } },
           h('div', { 'data-dam-row': '' },
             h('button', { 'data-dam-btn': '', title: 'prion-scan 式四类启发式,只报位置不含正文', onClick: runScan, disabled: scanBusy }, scanBusy ? (locale === 'zh' ? '扫描中…' : 'Scanning…') : (locale === 'zh' ? '扫描脏 token' : 'Scan dirty tokens')),
@@ -4047,7 +5373,15 @@ window.__ModuleLoader__.load({
             toggles: [
               { key: 'activationEmitMode', name: locale === 'zh' ? '记忆唤起（链中检测→插入）' : 'Memory recall (detect → inject)', sub: locale === 'zh' ? '开=canary 档（显式回忆注入，推荐）/ 关=shadow 档（只记录不注入）' : 'On = canary (inject on explicit recall, recommended) / Off = shadow (record only)', mode: true, rec: true, where: locale === 'zh' ? '自动记忆引擎' : 'Semantic engine' },
               { key: 'autoConsolidate', name: locale === 'zh' ? '记忆固化（自动沉淀）' : 'Memory consolidation', sub: locale === 'zh' ? '每轮对话结束自动把结论沉淀进每日日志与记忆店（推荐开）' : 'Consolidate conclusions into the log & stores each turn (recommended)', rec: true, where: locale === 'zh' ? '自动化' : 'Automation' },
-              { key: 'procedurePromotionEnabled', name: locale === 'zh' ? '技能固化与晋升' : 'Skill crystallization', sub: locale === 'zh' ? '重复流程固化为 checklist 自动附上；跨会话验证后晋升（「记忆中枢」页审批）' : 'Turn repeated flows into auto-attached checklists; promote after validation (Memory Hub tab)', where: locale === 'zh' ? '记忆中枢' : 'Memory Hub' },
+              // ★2026-09-22 改键(设置页缺口审计 P0-2):旧键 procedurePromotionEnabled 因 DEFAULT_CONFIG
+              //   恒供给布尔 procedureInjectEnabled 而**结构性不可达** ⇒ 该开关此前是摆设(会翻面、写盘成功、宿主读不到)。
+              { key: 'procedureInjectEnabled', name: locale === 'zh' ? '技能固化与注入' : 'Skill crystallization', sub: locale === 'zh' ? '重复流程固化为 checklist 自动附上；跨会话验证后晋升（「记忆中枢」页审批）' : 'Turn repeated flows into auto-attached checklists; promote after validation (Memory Hub tab)', where: locale === 'zh' ? '记忆中枢' : 'Memory Hub' },
+              // ★T10（2026-09-20）：机械 procedure 切片开关。
+              //   背景：`crossFeed()` 会把 episode 意图**机械截断**成技能名与步骤（无模型介入），
+              //   产出的观察行「既不像技能名也不像步骤」——用户报「审批里看不懂」的来源。
+              //   默认关：procedural 线只留模型直写（memory_procedure）与人工两条正经通路。
+              //   ⚠️ 解耦：本项**只**影响 procedure 切片，fact 分支/episode 巩固/judgement 消费不动。
+              { key: 'hubMechanicalProcedureFeedEnabled', name: locale === 'zh' ? '机械流程切片（不推荐）' : 'Mechanical flow slicing (not recommended)', sub: locale === 'zh' ? '把情节意图截断成"技能"，无模型介入、可读性差；关=只保留模型自己写的技能（推荐关）' : 'Truncates episode intent into "skills" with no model involvement; off = only model-authored skills (recommended)', where: locale === 'zh' ? '记忆中枢' : 'Memory Hub' },
             ] },
           { art: 'rocket', core: '', kicker: locale === 'zh' ? '完成' : 'READY', final: true,
             title: locale === 'zh' ? '一切就绪' : 'All set',
@@ -4443,7 +5777,8 @@ window.__ModuleLoader__.load({
               // ring/wall 必须一起带进来:卡片读的是 acConfirm.ring / acConfirm.wall,
               // 宿主透出了但这里不拷 → 双口径那行永远不渲染(2026-09-10 自查发现)
               setAcConfirm({ ratio: Number(arm.ratio) || 0, tokens: Number(arm.tokens) || 0, window: Number(arm.window) || 0, ring: Number(arm.ring) || 0, wall: Number(arm.wall) || 0, edgeAt: Number(arm.edgeAt) || 0 })
-              setAcCd(Math.max(0, Math.ceil((Number(arm.expiresAt) || 0) - Date.now()) / 1000))
+              // ★2026-09-20 移植（issue #94⑦ / PR #100）：ceil 作用于**毫秒**再除 1000 ⇒ 显示小数秒。
+              setAcCd(Math.max(0, Math.ceil(((Number(arm.expiresAt) || 0) - Date.now()) / 1000)))
             } else {
               setAcConfirm(null)
               setAcCd(0)
@@ -4516,7 +5851,7 @@ window.__ModuleLoader__.load({
       var dbgOpenPair = useState(false)
       var dbgOpen = dbgOpenPair[0]
       var setDbgOpen = dbgOpenPair[1]
-      var settingsSectionPair = useState('appearance')
+      var settingsSectionPair = useState('engine')
       var settingsSection = settingsSectionPair[0]
       var setSettingsSection = settingsSectionPair[1]
       var browseOpenPair = useState(false)
@@ -4797,12 +6132,15 @@ window.__ModuleLoader__.load({
         } catch (_) {}
       }
       var sectionLabels = {
-        semantic: locale === 'zh' ? '自动记忆引擎' : 'Semantic engine',
-        memoryHub: locale === 'zh' ? '记忆中枢' : 'Memory Hub',
-        appearance: locale === 'zh' ? '外观' : 'Appearance', storage: locale === 'zh' ? '存储' : 'Storage',
-        injection: locale === 'zh' ? '记忆窗口' : 'Memory window', automation: locale === 'zh' ? '自动化' : 'Automation',
-        context: locale === 'zh' ? '上下文管理' : 'Context management',
-        maintenance: locale === 'zh' ? '维护' : 'Maintenance'
+        engine: locale === 'zh' ? '语义记忆总开关' : 'Memory engine',
+        window: locale === 'zh' ? '记忆窗口（注入什么）' : 'Memory window',
+        capacity: locale === 'zh' ? '记忆容量与归档' : 'Capacity & retention',
+        skills: locale === 'zh' ? '自动沉淀成技能' : 'Skills & promotion',
+        handoff: locale === 'zh' ? '长会话接续' : 'Handoff & continuation',
+        auto: locale === 'zh' ? '自动化与免打扰' : 'Automation',
+        store: locale === 'zh' ? '存储与外部记忆' : 'Storage',
+        look: locale === 'zh' ? '外观与交互' : 'Appearance',
+        about: locale === 'zh' ? '关于与诊断' : 'About',
       }
       function section(key, title, content) { return h('section', { id: 'dam-settings-' + key, 'data-dam-settings-group': '' }, h('h3', null, title), content) }
       function jumpToSection(key) {
@@ -4814,7 +6152,7 @@ window.__ModuleLoader__.load({
           return h('button', { key: key, 'data-dam-btn': '', 'data-active': settingsSection === key ? 'true' : undefined, onClick: function () { jumpToSection(key) } }, sectionLabels[key])
         })),
         h('div', { 'data-dam-settings-content': '' },
-        section('semantic', sectionLabels.semantic, [
+        section('engine', sectionLabels.engine, [
           field(t('fAssocEngine'), h('input', { type: 'checkbox', checked: !!cfg.associativeMemoryEnabled, onChange: function (e) { set('associativeMemoryEnabled', e.target.checked) } }), t('fAssocEngineHint')),
           field(t('fAnchorIndex'), h('input', { type: 'checkbox', checked: !!cfg.memoryAnchorEnabled, onChange: function (e) { set('memoryAnchorEnabled', e.target.checked) } }), t('fAnchorIndexHint')),
           field(t('fJsCooldown'), h('input', { 'data-dam-input': '', type: 'number', min: 0, max: 60, value: cfg.jsDecideCooldownRounds === undefined ? 1 : cfg.jsDecideCooldownRounds, onChange: function (e) { set('jsDecideCooldownRounds', (function () { var v = Number(e.target.value); return (Number.isFinite(v) && v >= 0) ? v : 1 })())  /* #19: 0=不冷却 是合法值,|| 1 会吃掉 0 */ } }), t('fJsCooldownHint')),
@@ -4849,6 +6187,109 @@ window.__ModuleLoader__.load({
             locale === 'zh' ? '⚠ 已选 JS 引擎,但本地模型未就绪——当前实际生效:词法兜底。下方安装引导卡可下载模型(约130MB),完成后自动启用。' : '⚠ JS engine selected but the local model is not ready — lexical fallback is active. Use the setup card below to download the model (~130MB); it engages automatically when done.') : null,
           (sem.loaded && cfg.semanticEngineMode === 'python' && sem.pythonInt8Present === false) ? h('div', { 'data-dam-error': '', style: { marginTop: '-4px', marginBottom: '8px' } },
             locale === 'zh' ? '⚠ 已选 Python 引擎,但 BGE-M3 int8 模型未就绪——当前实际生效:词法兜底。下方安装向导可引导安装;若本机无法安装(如架构不支持),请改用 JS 引擎或 auto。' : '⚠ Python engine selected but the BGE-M3 int8 model is not ready — lexical fallback is active. Use the wizard below; if this machine cannot install it, switch to the JS engine or auto.') : null,
+          field(t('fReasoning'), h('input', { type: 'checkbox', checked: !!cfg.reasoningObserverEnabled, onChange: function (e) { set('reasoningObserverEnabled', e.target.checked) } }), t('fReasoningHint')),
+          field(locale === 'zh' ? '唤起阈值（校准策略）' : 'Activation thresholds (calibrated)', h('div', null,
+            h('span', null, 'tauHi 0.45 · tauLo 0.35 · deltaExp 0.03 · deltaPro 0.05' + (sem.loaded ? ((locale === 'zh' ? ' · 发射模式:' : ' · emit: ') + (sem.activationEmitMode || 'shadow')) : ''))),
+            t('fTuningHint')),
+        ]),
+        section('window', sectionLabels.window, [
+  field(t('fInject'), h('input', { type: 'checkbox', checked: !!cfg.injectEnabled, onChange: function (e) { set('injectEnabled', e.target.checked) } }), t('fInjectHint')),
+          field(t('fBudget'), h('input', { 'data-dam-input': '', type: 'number', min: 400, value: cfg.injectBudgetChars, onChange: function (e) { set('injectBudgetChars', Number(e.target.value) || 2400) } }), t('fBudgetHint')),
+          // 2026-09-22 补接线(设置页缺口审计 P0-3/P0-4/P0-6):目录层与规则分层此前只有后端实现。
+          field(t('fTier0Catalog'), h('input', { type: 'checkbox', 'data-dam-key': 'tier0CatalogEnabled', checked: cfg.tier0CatalogEnabled !== false, onChange: function (e) { set('tier0CatalogEnabled', e.target.checked) } }), t('fTier0CatalogHint')),
+          field(t('fTier0Max'), h('input', { 'data-dam-input': '', type: 'number', min: 100, value: cfg.tier0MaxTokens === undefined ? 400 : cfg.tier0MaxTokens, onChange: function (e) { set('tier0MaxTokens', Math.max(100, Number(e.target.value) || 400)) } }), t('fTier0MaxHint')),
+          field(t('fRulesLayering'), h('input', { type: 'checkbox', 'data-dam-key': 'rulesLayeringMode', checked: String(cfg.rulesLayeringMode || 'self').toLowerCase() !== 'off', onChange: function (e) { set('rulesLayeringMode', e.target.checked ? 'self' : 'off') } }), t('fRulesLayeringHint')),
+          field(t('fDays'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 14, value: cfg.recentDaysInjected, onChange: function (e) { set('recentDaysInjected', Number(e.target.value) || 1) } }), t('fDaysHint')),
+          field(t('fExtBudget'), h('input', { 'data-dam-input': '', type: 'number', min: 200, value: cfg.externalInjectionChars === undefined ? 1400 : cfg.externalInjectionChars, onChange: function (e) { set('externalInjectionChars', Number(e.target.value) || 1400) } }), t('fExtBudgetHint')),
+          field(t('fSnapGap'), h('input', { 'data-dam-input': '', type: 'number', min: 0, max: 50, value: cfg.snapshotMinGapRounds === undefined ? 5 : cfg.snapshotMinGapRounds, onChange: function (e) { set('snapshotMinGapRounds', Number(e.target.value) || 5) } }), t('fSnapGapHint')),
+          field(t('fReinjectOnCompact'), h('input', { type: 'checkbox', checked: cfg.snapshotReinjectOnCompact !== false, onChange: function (e) { set('snapshotReinjectOnCompact', e.target.checked) } }), t('fReinjectOnCompactHint')),
+          field(t('fPromptCustom'), h('button', { 'data-dam-btn': '', onClick: function () { setPromptEditOpen(!promptEditOpen) } }, (promptEditOpen ? (locale === 'zh' ? '收起' : 'Collapse') : (locale === 'zh' ? '编辑 prompt 层' : 'Edit prompt layers'))), t('fPromptCustomHint')),
+          promptEditOpen ? [
+            h('div', { key: '__layers', style: { padding: '6px 0 2px', width: '100%' } },
+            (Object.keys(DEFAULT_PROMPT_LAYERS_CLIENT)).map(function (k) {
+              return h('div', { key: k, style: { marginBottom: '6px' } },
+                h('div', { 'data-dam-hint': '', style: { fontWeight: 700, marginBottom: '2px' } }, k),
+                h('textarea', { 'data-dam-input': '', rows: 2, style: { width: '100%', fontFamily: 'monospace', fontSize: 'calc(11px * var(--dam-scale))' }, value: (cfg.promptLayerOverrides || {})[k] || '', placeholder: DEFAULT_PROMPT_LAYERS_CLIENT[k] || '(默认文案)', onChange: function (e) { var ov = Object.assign({}, cfg.promptLayerOverrides || {}); if (e.target.value.trim() === '') delete ov[k]; else ov[k] = e.target.value; set('promptLayerOverrides', ov) } }))
+            })),
+            h('div', { key: '__reset', 'data-dam-row': '', style: { marginTop: '6px' } },
+              h('button', { 'data-dam-btn': '', onClick: function () { set('promptLayerOverrides', {}) } }, locale === 'zh' ? '一键恢复默认' : 'Reset to defaults'))
+          ] : null,
+        ]),
+        section('capacity', sectionLabels.capacity, [
+          field(t('fChildObs'), h('input', { type: 'checkbox', checked: !!cfg.contextBridgeObserveChildSessions, onChange: function (e) { set('contextBridgeObserveChildSessions', e.target.checked) } }), t('fChildObsHint')),
+          field(t('fEpisodicRet'), h('input', { 'data-dam-input': '', type: 'number', min: 16, max: 4096, value: cfg.episodicRetention === undefined ? 256 : cfg.episodicRetention, onChange: function (e) { set('episodicRetention', Math.max(16, Math.min(4096, Number(e.target.value) || 256))) } }), t('fEpisodicRetHint')),
+          // 2026-09-22 补接线(P0-4):facts 淘汰上限(fact-store.js pruneIfNeeded)。
+          field(t('fFactRetention'), h('input', { 'data-dam-input': '', type: 'number', min: 10, value: cfg.factRetentionMax === undefined ? 1000 : cfg.factRetentionMax, onChange: function (e) { set('factRetentionMax', Math.max(10, Number(e.target.value) || 1000)) } }), t('fFactRetentionHint')),
+          field(t('fNoteCap'), h('input', { 'data-dam-input': '', type: 'number', min: 500, value: cfg.noteCapacityChars === undefined ? 24000 : cfg.noteCapacityChars, onChange: function (e) { set('noteCapacityChars', Number(e.target.value) || 24000) } }), t('fNoteCapHint')),
+          field(t('fUserCap'), h('input', { 'data-dam-input': '', type: 'number', min: 500, value: cfg.userCapacityChars === undefined ? 24000 : cfg.userCapacityChars, onChange: function (e) { set('userCapacityChars', Number(e.target.value) || 24000) } }), t('fUserCapHint')),
+  field(t('fConsolidateMin'), h('input', { 'data-dam-input': '', type: 'number', min: 80, value: cfg.autoConsolidateMinChars === undefined ? 240 : cfg.autoConsolidateMinChars, onChange: function (e) { set('autoConsolidateMinChars', Number(e.target.value) || 240) } }), t('fConsolidateMinHint')),
+          field(t('fAutoConsolidate'), h('input', { type: 'checkbox', checked: cfg.autoConsolidate !== false, onChange: function (e) { set('autoConsolidate', e.target.checked) } }), t('fAutoConsolidateHint')),
+          field(t('fConsolidate'), h('input', { 'data-dam-input': '', type: 'number', min: 5, value: cfg.autoConsolidateCooldownMinutes === undefined ? 30 : cfg.autoConsolidateCooldownMinutes, onChange: function (e) { set('autoConsolidateCooldownMinutes', Number(e.target.value) || 30) } }), t('fConsolidateHint')),
+          field(t('fConsolidateMax'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 50, value: cfg.autoConsolidateDailyMax === undefined ? 8 : cfg.autoConsolidateDailyMax, onChange: function (e) { set('autoConsolidateDailyMax', Number(e.target.value) || 8) } }), t('fConsolidateMaxHint')),
+          field(t('fMemFileIndex'), h('input', { type: 'checkbox', 'data-dam-key': 'memoryFileIndexEnabled', checked: cfg.memoryFileIndexEnabled === true, onChange: function (e) { set('memoryFileIndexEnabled', e.target.checked) } }), t('fMemFileIndexHint')),
+          // 2026-09-14 解耦:交接白板与自动接续各自独立成项(旧实现只在白板页有接续按钮,且 enabled 还被
+          // handoffEnabled 二次与运算)。两者出厂默认均为 false(功能仍在测试期),这里与白板页读写完全相同的配置键。
+        ]),
+        section('skills', sectionLabels.skills, [
+          h('div', { 'data-dam-hint': '' }, t('secMemoryHubHint')),
+          field(t('fMemoryHub'), h('input', { type: 'checkbox', checked: !!cfg.memoryHubEnabled, onChange: function (e) { set('memoryHubEnabled', e.target.checked) } }), t('fMemoryHubHint')),
+          field(t('fEpisodicMin'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 16, value: cfg.episodicMinSegments === undefined ? 2 : cfg.episodicMinSegments, onChange: function (e) { set('episodicMinSegments', Math.max(1, Math.min(16, Number(e.target.value) || 2))) } }), t('fEpisodicMinHint')),
+          field(t('fProcSessions'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 20, value: cfg.procedureMinSessions === undefined ? 3 : cfg.procedureMinSessions, onChange: function (e) { set('procedureMinSessions', Math.max(1, Math.min(20, Number(e.target.value) || 3))) } }), t('fProcSessionsHint')),
+          field(t('fProcSuccess'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 20, value: cfg.procedureMinSuccess === undefined ? 2 : cfg.procedureMinSuccess, onChange: function (e) { set('procedureMinSuccess', Math.max(1, Math.min(20, Number(e.target.value) || 2))) } }), t('fProcSuccessHint')),
+          field(t('fProcCorr'), h('input', { 'data-dam-input': '', type: 'number', min: 0, max: 1, step: 0.05, value: cfg.procedureCorrectionCap === undefined ? 0.3 : cfg.procedureCorrectionCap, onChange: function (e) { set('procedureCorrectionCap', Math.max(0, Math.min(1, Number(e.target.value) || 0.3))) } }), t('fProcCorrHint')),
+          field(t('fProcRisk'), h('input', { type: 'checkbox', checked: cfg.procedureHighRiskApproval !== false, onChange: function (e) { set('procedureHighRiskApproval', e.target.checked) } }), t('fProcRiskHint')),
+          // 2026-09-22 补接线(设置页缺口审计 P0-1):procedureInjectEnabled 才是宿主真读的总闸
+          //   (procedure-switch.js 先判它);此前设置页只有旧键 ⇒ 用户改了也无效(灰控件)。
+          field(t('fProcInject'), h('input', { type: 'checkbox', 'data-dam-key': 'procedureInjectEnabled', checked: cfg.procedureInjectEnabled !== false, onChange: function (e) { set('procedureInjectEnabled', e.target.checked) } }), t('fProcInjectHint')),
+          field(t('fProcLevel'), h('select', { 'data-dam-select': '', value: cfg.procedureActiveLevel || 'checklist', onChange: function (e) { set('procedureActiveLevel', e.target.value) } },
+            h('option', { value: 'checklist' }, locale === 'zh' ? 'checklist 完整步骤' : 'checklist (full steps)'),
+            h('option', { value: 'excerpt' }, locale === 'zh' ? 'excerpt 摘要' : 'excerpt (summary)'),
+            h('option', { value: 'hint' }, locale === 'zh' ? 'hint 仅提示' : 'hint (hint only)')), t('fProcLevelHint')),
+          h('div', { 'data-dam-hint': '', style: { marginTop: '4px' } }, t('memoryHubViewHint')),
+        ]),
+        section('handoff', sectionLabels.handoff, [
+  field(t('fHandoff'), h('input', { type: 'checkbox', 'data-dam-key': 'handoffEnabled', checked: cfg.handoffEnabled !== false, onChange: function (e) { set('handoffEnabled', e.target.checked) } }), t('fHandoffHint')),
+          field(t('fAutoContinue'), h('input', { type: 'checkbox', 'data-dam-key': 'autoContinueEnabled', checked: cfg.autoContinueEnabled !== false, onChange: function (e) { set('autoContinueEnabled', e.target.checked) } }), t('fAutoContinueHint')),
+          field(t('fHandoffPlan'), h('input', { 'data-dam-input': '', type: 'number', min: 200, value: cfg.handoffPlanChars === undefined ? 1200 : cfg.handoffPlanChars, onChange: function (e) { set('handoffPlanChars', Number(e.target.value) || 1200) } }), t('fHandoffPlanHint')),
+          // 2026-09-22 补接线(设置页缺口审计 P0-5):criteriaGate 此前只能改文件才能退。
+          field(t('fCriteriaGate'), h('input', { type: 'checkbox', 'data-dam-key': 'criteriaGate', checked: cfg.criteriaGate !== false, onChange: function (e) { set('criteriaGate', e.target.checked) } }), t('fCriteriaGateHint')),
+          field(t('fHandoffLedger'), h('input', { 'data-dam-input': '', type: 'number', min: 100, value: cfg.handoffLedgerChars === undefined ? 800 : cfg.handoffLedgerChars, onChange: function (e) { set('handoffLedgerChars', Number(e.target.value) || 800) } }), t('fHandoffLedgerHint')),
+          field(t('fWaterWindow'), h('input', { 'data-dam-input': '', type: 'number', min: 0, value: cfg.waterLevelWindowTokens === undefined ? 65536 : cfg.waterLevelWindowTokens, onChange: function (e) { set('waterLevelWindowTokens', Number(e.target.value) || 0) } }), t('fWaterWindowHint')),
+          field(t('fWaterThreshold'), h('input', { 'data-dam-input': '', type: 'number', min: 0.1, max: 1.5, step: 0.05, value: cfg.waterLevelThreshold === undefined ? 0.75 : cfg.waterLevelThreshold, onChange: function (e) { set('waterLevelThreshold', Number(e.target.value) || 0.75) } }), t('fWaterThresholdHint')),
+          field(t('fWaterAdvisory'), h('input', { type: 'checkbox', checked: cfg.waterLevelAdvisory !== false, onChange: function (e) { set('waterLevelAdvisory', e.target.checked) } }), t('fWaterAdvisoryHint')),
+          field(t('fWaterAuto'), h('input', { type: 'checkbox', checked: cfg.waterLevelAutoHandoff !== false, onChange: function (e) { set('waterLevelAutoHandoff', e.target.checked) } }), t('fWaterAutoHint')),
+          field(locale === 'zh' ? '子代理痕迹回收' : 'Subagent trace recycle', h('input', { type: 'checkbox', checked: cfg.subagentGcEnabled !== false, onChange: function (e) { set('subagentGcEnabled', e.target.checked) } }),
+            locale === 'zh' ? '本插件的一次性子代理(自动沉淀 / 时段总结 / 问候 / 蒸馏)每跑一次都会在 ~/.dsh/sessions 留下一个持久化会话;数量上千后会话列表会明显变慢。开启后任务一结束就把这些痕迹移入 ~/.dsh/subagent-gc-backup 备份(可回滚),不影响子代理结果。默认开。' : 'Every one-shot subagent this plugin spawns (auto-consolidation, scheduled summary, greeting, distillation) leaves a persisted session under ~/.dsh/sessions; hundreds of them slow the session list down. When on, each trace is moved into ~/.dsh/subagent-gc-backup right after the task ends (reversible), never affecting the subagent result. On by default.'),
+          field(locale === 'zh' ? '兜底回收保留天数' : 'Fallback recycle keep days', h('input', { 'data-dam-input': '', type: 'number', min: 0, value: cfg.subagentGcKeepDays === undefined ? 3 : cfg.subagentGcKeepDays, onChange: function (e) { set('subagentGcKeepDays', Number(e.target.value) || 0) } }),
+            locale === 'zh' ? '每天巡检一次,回收超过该天数仍残留的痕迹(比如任务异常中断没删掉的);0 = 不按时间,只靠任务结束即删。' : 'A daily sweep recycles traces older than this many days (e.g. leftovers from interrupted tasks); 0 = rely on the end-of-task recycle only.'),
+        ]),
+        section('auto', sectionLabels.auto, [
+          // 欢迎向导:开关(首启自动播放)+ 立即重看按钮(闭包内直调 openDialog——同一作用域,点击立即弹;
+          // 不走 window 全局入口,避免多实例时序导致"点了没反应要刷新")+ 查看更新日志(走 update 弹窗,
+          // 带 Logo 开场动画;versions 取 CHANGELOG 最新一条)
+          field(t('fWelcomeTour'), h('div', { 'data-dam-row': '' },
+            h('input', { type: 'checkbox', checked: cfg.welcomeTourEnabled !== false, onChange: function (e) { set('welcomeTourEnabled', e.target.checked) } }),
+            h('button', { 'data-dam-btn': '', onClick: function () { try { openDialog({ kind: 'welcomeTour' }) } catch (eTour) {} } }, t('tourReplay')),
+            h('button', { 'data-dam-btn': '', onClick: function () {
+              try {
+                var keys = Object.keys(CHANGELOG)
+                if (!keys.length) return
+                var latest = keys.sort(cmpVersion)[keys.length - 1]
+                openDialog({ kind: 'update', versions: [{ version: latest, items: CHANGELOG[latest] }], currentVersion: latest })
+              } catch (eLog) {}
+            } }, locale === 'zh' ? '查看更新日志' : 'View changelog')), t('fWelcomeTourHint')),
+          field(t('fAutoPopup'), h('input', { type: 'checkbox', checked: cfg.autoPopupEnabled !== false, onChange: function (e) { set('autoPopupEnabled', e.target.checked) } }), t('fAutoPopupHint')),
+          field(t('fUnattended'), h('input', { type: 'checkbox', checked: !!cfg.unattendedMode, onChange: function (e) { set('unattendedMode', e.target.checked) } }), t('fUnattendedHint')),
+          field(t('fUnattendedAuto'), h('input', { type: 'checkbox', checked: !!cfg.unattendedAuto, onChange: function (e) { set('unattendedAuto', e.target.checked) } }), t('fUnattendedAutoHint')),
+          field(t('fAway'), h('input', { 'data-dam-input': '', type: 'number', min: 0, value: (Number(cfg.awayMinutes) === 0 ? 0 : (cfg.awayMinutes || 60)), onChange: function (e) { var v = Number(e.target.value); set('awayMinutes', Number.isFinite(v) && v >= 0 ? v : 60) } }), t('fAwayHint')),
+          field(t('fAutoSum'), h('input', { 'data-dam-input': '', value: (cfg.autoSummaryTimes || []).join(','), onChange: function (e) { set('autoSummaryTimes', String(e.target.value || '').split(',').map(function (s) { return s.trim() }).filter(Boolean)) } }), t('fAutoSumHint')),
+          field(t('fConsSchedule'), h('input', { type: 'checkbox', checked: cfg.consolidateScheduleEnabled !== false, onChange: function (e) { set('consolidateScheduleEnabled', e.target.checked) } }), t('fConsScheduleHint')),
+          field(t('fConsScheduleTime'), h('input', { 'data-dam-input': '', placeholder: '09:30', value: cfg.consolidateScheduleTime === undefined ? '09:30' : cfg.consolidateScheduleTime, onChange: function (e) { set('consolidateScheduleTime', String(e.target.value || '').trim()) } }), t('fConsScheduleTimeHint')),
+          field(t('fConsScheduleDays'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 60, value: cfg.consolidateScheduleDays === undefined ? 7 : cfg.consolidateScheduleDays, onChange: function (e) { set('consolidateScheduleDays', Number(e.target.value) || 7) } }), t('fConsScheduleDaysHint')),
+          field(t('fMaintSchedule'), h('input', { type: 'checkbox', checked: cfg.maintainScheduleEnabled !== false, onChange: function (e) { set('maintainScheduleEnabled', e.target.checked) } }), t('fMaintScheduleHint')),
+          field(t('fMaintScheduleTime'), h('input', { 'data-dam-input': '', placeholder: '10:00', value: cfg.maintainScheduleTime === undefined ? '10:00' : cfg.maintainScheduleTime, onChange: function (e) { set('maintainScheduleTime', String(e.target.value || '').trim()) } }), t('fMaintScheduleTimeHint')),
+        ]),
+        section('store', sectionLabels.store, [
           // M-CM6-B v3·环境检测面板:⟳ 按钮触发,自动检索环境(快检+深扫+热接入),联动安装助手;美学对齐安装向导卡
           detOpen ? (function () {
             var panelStyle = { border: '1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(128,128,128,.25)) 60%, transparent)', borderRadius: '10px', padding: '12px', marginBottom: '10px', background: 'color-mix(in srgb, var(--dsw-alias-bg-layer-1, rgba(128,128,128,.06)) 55%, transparent)', backdropFilter: 'blur(14px) saturate(1.3)', WebkitBackdropFilter: 'blur(14px) saturate(1.3)' }
@@ -4909,6 +6350,9 @@ window.__ModuleLoader__.load({
             else if (dl.phase === 'error') { stateTxt = t('dlError'); stateBg = 'rgba(196,74,74,.22)' }
             else if (dl.phase === 'cancelled') { stateTxt = t('dlCancelled'); stateBg = 'rgba(196,138,42,.2)' }
             else if (isJs && dlActive) { stateTxt = dl.phase === 'verifying' ? t('dlVerifying') : t('dlDownloading'); stateBg = 'rgba(36,86,196,.2)' }
+            // ★ issue #70（2026-09-19）：资产齐备但引擎**已降级** —— 必须与「未下载」区分开。
+            //   旧实现只看文件存在性 ⇒ 这种状态会显示「已就绪 ✓」而实际每次检索都在词法兜底。
+            else if (isJs && sem.degraded) { stateTxt = locale === 'zh' ? ('引擎降级（词法兜底）— ' + String(sem.degraded).slice(0, 60)) : ('Engine degraded (lexical fallback) — ' + String(sem.degraded).slice(0, 60)); stateBg = 'rgba(196,74,74,.22)' }
             else if (isJs && sem.assetPresent && !sem.peerPresent) { stateTxt = locale === 'zh' ? '模型已存在,缺推理库——pnpm approve-builds 后 pnpm add @huggingface/transformers' : 'Model present, runtime missing — pnpm approve-builds && pnpm add @huggingface/transformers'; stateBg = 'rgba(196,138,42,.2)' }
             else { stateTxt = locale === 'zh' ? '未下载' : 'Not downloaded'; stateBg = 'rgba(196,138,42,.2)' }
             var progress = dlActive || (isJs && dl.phase === 'done')
@@ -4922,14 +6366,17 @@ window.__ModuleLoader__.load({
                 : (dl.phase === 'cancelled' ? t('dlCancelled')
                   : (isJs && dl.phase === 'done' && !ready ? t('dlDone') + (locale === 'zh' ? '（缺运行库时需安装 @huggingface/transformers）' : ' (install @huggingface/transformers if runtime missing)')
                     : (locale === 'zh' ? '下载进度' : 'Download progress'))))
-            var refreshSem = function () {
+            // ★2026-09-20 移植（issue #89 / PR #95）：局部 var refreshSem 遮蔽模块级
+            //   refreshSem(apply, onError) ⇒ 自递归爆栈被 .catch 吞 ⇒ 点「开始下载/取消」后
+            //   sem 永不刷新、轮询闸也永不启动。改名引用模块级函数。
+            var refreshSemNow = function () {
               refreshSem(setSem)
             }
             var startDl = function () {
-              apiPost(API.semanticDownload, { action: 'start', mirror: mirror }).then(refreshSem).catch(function () {})
+              apiPost(API.semanticDownload, { action: 'start', mirror: mirror }).then(refreshSemNow).catch(function () {})
             }
             var cancelDl = function () {
-              apiPost(API.semanticDownload, { action: 'cancel', mirror: mirror }).then(refreshSem).catch(function () {})
+              apiPost(API.semanticDownload, { action: 'cancel', mirror: mirror }).then(refreshSemNow).catch(function () {})
             }
             return h('div', { style: { border: '1px solid color-mix(in srgb, var(--dam-accent, #2456c4) 40%, transparent)', borderRadius: '10px', padding: '10px 12px', marginBottom: '8px', fontSize: 'calc(11.5px * var(--dam-scale))', lineHeight: 1.6 } },
               h('div', { 'data-dam-row': '', style: { alignItems: 'center' } },
@@ -4950,175 +6397,102 @@ window.__ModuleLoader__.load({
                   h('option', { value: 'auto' }, t('mAuto')),
                   h('option', { value: 'cn' }, t('mCn')),
                   h('option', { value: 'intl' }, t('mIntl'))) : null,
-                ready ? h('button', { 'data-dam-btn': '', onClick: function () { setGuide(''); var n2 = Object.assign({}, cfg); n2.semanticEngineMode = guide; if (guide === 'js') { n2.activationSource = 'js'; n2.contextSinkMode = 'null' } else if (guide === 'python') { n2.activationSource = 'python'; n2.contextSinkMode = 'python'; try { var gp = localStorage.getItem('dsh-auto-memory.pyGpu'); if (gp === '1') n2.pythonGpu = true } catch (eL) {} } setCfg(n2); setDirty(true) } }, locale === 'zh' ? '启用并继续' : 'Enable & continue') : null,
+                // ★2026-09-22 删死键(设置页缺口审计 P0-7):pythonGpu 不在 DEFAULT_CONFIG 白名单,
+                //   /config 会静默丢弃、宿主 lib/ 零读取 ⇒ 写入无任何效果,故移除该段(行为零变化)。
+                ready ? h('button', { 'data-dam-btn': '', onClick: function () { setGuide(''); var n2 = Object.assign({}, cfg); n2.semanticEngineMode = guide; if (guide === 'js') { n2.activationSource = 'js'; n2.contextSinkMode = 'null' } else if (guide === 'python') { n2.activationSource = 'python'; n2.contextSinkMode = 'python' } setCfg(n2); setDirty(true) } }, locale === 'zh' ? '启用并继续' : 'Enable & continue') : null,
                 !ready && isJs && !dlActive ? h('button', { 'data-dam-btn': '', onClick: startDl }, (dl.phase === 'error' || dl.phase === 'cancelled') ? t('semDlRetry') : t('semDlStart')) : null,
                 !ready && isJs && dlActive ? h('button', { 'data-dam-btn': '', onClick: cancelDl }, t('semDlCancel')) : null,
                 h('button', { 'data-dam-btn': '', onClick: function () { setGuide('') } }, t('gotIt'))))
           })()
             : null,
-          field(t('fReasoning'), h('input', { type: 'checkbox', checked: !!cfg.reasoningObserverEnabled, onChange: function (e) { set('reasoningObserverEnabled', e.target.checked) } }), t('fReasoningHint')),
-          field(t('fChildObs'), h('input', { type: 'checkbox', checked: !!cfg.contextBridgeObserveChildSessions, onChange: function (e) { set('contextBridgeObserveChildSessions', e.target.checked) } }), t('fChildObsHint')),
-          field(locale === 'zh' ? '唤起阈值（校准策略）' : 'Activation thresholds (calibrated)', h('div', null,
-            h('span', null, 'tauHi 0.45 · tauLo 0.35 · deltaExp 0.03 · deltaPro 0.05' + (sem.loaded ? ((locale === 'zh' ? ' · 发射模式:' : ' · emit: ') + (sem.activationEmitMode || 'shadow')) : ''))),
-            t('fTuningHint')),
-        ]),
-        section('memoryHub', sectionLabels.memoryHub, [
-          h('div', { 'data-dam-hint': '' }, t('secMemoryHubHint')),
-          field(t('fMemoryHub'), h('input', { type: 'checkbox', checked: !!cfg.memoryHubEnabled, onChange: function (e) { set('memoryHubEnabled', e.target.checked) } }), t('fMemoryHubHint')),
-          field(t('fEpisodicMin'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 16, value: cfg.episodicMinSegments === undefined ? 2 : cfg.episodicMinSegments, onChange: function (e) { set('episodicMinSegments', Math.max(1, Math.min(16, Number(e.target.value) || 2))) } }), t('fEpisodicMinHint')),
-          field(t('fEpisodicRet'), h('input', { 'data-dam-input': '', type: 'number', min: 16, max: 4096, value: cfg.episodicRetention === undefined ? 256 : cfg.episodicRetention, onChange: function (e) { set('episodicRetention', Math.max(16, Math.min(4096, Number(e.target.value) || 256))) } }), t('fEpisodicRetHint')),
-          field(t('fProcSessions'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 20, value: cfg.procedureMinSessions === undefined ? 3 : cfg.procedureMinSessions, onChange: function (e) { set('procedureMinSessions', Math.max(1, Math.min(20, Number(e.target.value) || 3))) } }), t('fProcSessionsHint')),
-          field(t('fProcSuccess'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 20, value: cfg.procedureMinSuccess === undefined ? 2 : cfg.procedureMinSuccess, onChange: function (e) { set('procedureMinSuccess', Math.max(1, Math.min(20, Number(e.target.value) || 2))) } }), t('fProcSuccessHint')),
-          field(t('fProcCorr'), h('input', { 'data-dam-input': '', type: 'number', min: 0, max: 1, step: 0.05, value: cfg.procedureCorrectionCap === undefined ? 0.3 : cfg.procedureCorrectionCap, onChange: function (e) { set('procedureCorrectionCap', Math.max(0, Math.min(1, Number(e.target.value) || 0.3))) } }), t('fProcCorrHint')),
-          field(t('fProcRisk'), h('input', { type: 'checkbox', checked: cfg.procedureHighRiskApproval !== false, onChange: function (e) { set('procedureHighRiskApproval', e.target.checked) } }), t('fProcRiskHint')),
-          field(t('fProcLevel'), h('select', { 'data-dam-select': '', value: cfg.procedureActiveLevel || 'checklist', onChange: function (e) { set('procedureActiveLevel', e.target.value) } },
-            h('option', { value: 'checklist' }, locale === 'zh' ? 'checklist 完整步骤' : 'checklist (full steps)'),
-            h('option', { value: 'excerpt' }, locale === 'zh' ? 'excerpt 摘要' : 'excerpt (summary)'),
-            h('option', { value: 'hint' }, locale === 'zh' ? 'hint 仅提示' : 'hint (hint only)')), t('fProcLevelHint')),
-          h('div', { 'data-dam-hint': '', style: { marginTop: '4px' } }, t('memoryHubViewHint')),
+  field(t('fUserDir'), h('input', { 'data-dam-input': '', value: cfg.userMemoryDir, onChange: function (e) { set('userMemoryDir', e.target.value) } }), t('fUserDirHint')),
+          field(t('fProjectDir'), h('input', { 'data-dam-input': '', value: cfg.projectMemoryDir, onChange: function (e) { set('projectMemoryDir', e.target.value) } }), t('fProjectDirHint')),
+          field(t('fMemoryRoot'), h('div', { 'data-dam-row': '', style: { flex: 1 } },
+            h('input', { 'data-dam-input': '', style: { flex: 1 }, value: cfg.memoryRoot || '', onChange: function (e) { set('memoryRoot', e.target.value) } }),
+            h('button', { 'data-dam-btn': '', onClick: function () { openBrowser() } }, t('fBrowse'))), t('fMemoryRootHint')),
+          browseOpen ? h('div', { style: { border: '1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(128,128,128,.25)) 60%, transparent)', borderRadius: '8px', padding: '8px', marginBottom: '8px', background: 'color-mix(in srgb, var(--dsw-alias-bg-layer-1, rgba(128,128,128,.06)) 40%, transparent)' } },
+            h('div', { 'data-dam-row': '' },
+              h('b', { style: { fontSize: 'calc(12px * var(--dam-scale))', wordBreak: 'break-all', flex: 1 } }, browsePath || '…'),
+              h('button', { 'data-dam-btn': '', onClick: function () { browseTo(browseParent) }, disabled: browseParent === browsePath }, t('fUp'))),
+            h('div', { style: { maxHeight: '160px', overflow: 'auto', marginTop: '4px' } },
+              (browseDirs || []).map(function (d) {
+                return h('button', { key: d.path, 'data-dam-btn': '', style: { display: 'block', width: '100%', textAlign: 'left', padding: '3px 6px' }, onClick: function () { browseTo(d.path) } }, '📁 ' + d.name)
+              }).concat(browseDirs && !browseDirs.length ? [h('div', { key: 'e', 'data-dam-hint': '' }, t('empty'))] : [])),
+            h('div', { 'data-dam-row': '', style: { marginTop: '6px' } },
+              h('button', { 'data-dam-btn': '', onClick: function () { set('memoryRoot', browsePath); setBrowseOpen(false) } }, t('fSelectDir')),
+              h('button', { 'data-dam-btn': '', onClick: function () { setBrowseOpen(false) } }, t('close'))))
+            : null,
+          field(t('fDayBoundary'), h('input', { 'data-dam-input': '', type: 'number', min: 0, max: 1439, value: (cfg.dayBoundaryMinutes === undefined ? 450 : cfg.dayBoundaryMinutes), onChange: function (e) { set('dayBoundaryMinutes', parseInt(e.target.value || '0', 10)) } }), t('fDayBoundaryHint')),
+          field(t('fReflect'), h('input', { type: 'checkbox', checked: !!cfg.reflectEnabled, onChange: function (e) { set('reflectEnabled', e.target.checked) } }), t('fReflectHint')),
+          field(t('fStyle'), h('select', { 'data-dam-select': '', value: cfg.reflectStyle, onChange: function (e) { set('reflectStyle', e.target.value) } },
+            STYLE_IDS.map(function (id) { return h('option', { key: id, value: id }, t('style' + id.charAt(0).toUpperCase() + id.slice(1))) })), t('fStyleHint')),
+          // 2026-09-22 补接线(设置页缺口审计 P1/P2):扫描上限与索引快照前端零命中。
+          field(t('fWsDiscover'), h('input', { 'data-dam-input': '', type: 'number', min: 5, max: 2000, value: cfg.workspaceDiscoverMax === undefined ? 200 : cfg.workspaceDiscoverMax, onChange: function (e) { set('workspaceDiscoverMax', Math.max(5, Math.min(2000, Number(e.target.value) || 200))) } }), t('fWsDiscoverHint')),
         ]),
-        section('appearance', sectionLabels.appearance, [
+        section('look', sectionLabels.look, [
           h('div', { 'data-dam-hint': '' }, t('settingsHeader')),
-          // 欢迎向导:开关(首启自动播放)+ 立即重看按钮(闭包内直调 openDialog——同一作用域,点击立即弹;
-          // 不走 window 全局入口,避免多实例时序导致"点了没反应要刷新")+ 查看更新日志(走 update 弹窗,
-          // 带 Logo 开场动画;versions 取 CHANGELOG 最新一条)
-          field(t('fWelcomeTour'), h('div', { 'data-dam-row': '' },
-            h('input', { type: 'checkbox', checked: cfg.welcomeTourEnabled !== false, onChange: function (e) { set('welcomeTourEnabled', e.target.checked) } }),
-            h('button', { 'data-dam-btn': '', onClick: function () { try { openDialog({ kind: 'welcomeTour' }) } catch (eTour) {} } }, t('tourReplay')),
-            h('button', { 'data-dam-btn': '', onClick: function () {
-              try {
-                var keys = Object.keys(CHANGELOG)
-                if (!keys.length) return
-                var latest = keys.sort(cmpVersion)[keys.length - 1]
-                openDialog({ kind: 'update', versions: [{ version: latest, items: CHANGELOG[latest] }], currentVersion: latest })
-              } catch (eLog) {}
-            } }, locale === 'zh' ? '查看更新日志' : 'View changelog')), t('fWelcomeTourHint')),
           field(t('fLocale'), h('select', { 'data-dam-select': '', value: cfg.locale || 'system', onChange: function (e) { set('locale', e.target.value) } },
             LOCALE_IDS_LIST.map(function (id) { return h('option', { key: id, value: id }, id === 'system' ? t('followSystem') : t(id)) })), t('fLocaleHint')),
           field(t('fFontSize'), h('select', { 'data-dam-select': '', value: fontScale, onChange: function (e) { fontScale = e.target.value; try { localStorage.setItem('dsh-auto-memory.fontScale.v2', fontScale) } catch (ee) {}; try { var pp = document.querySelector('[data-dam-panel]'); if (pp) pp.style.setProperty('--dam-scale', FONT_SCALE_VALUES[fontScale] || '1') } catch (ee2) {}; emit() } },
             Object.keys(FONT_SCALES).map(function (k) { return h('option', { key: k, value: k }, t('fs' + k.charAt(0).toUpperCase() + k.slice(1))) })), t('fFontSizeHint')),
+          // 面板位置(2026-09-21):左下角 / 顶部 / 两者共存。改动立即生效并同步两处形态(用户硬规则:即时回显)。
+          field(t('fPanelPos'), h('select', { 'data-dam-select': '', value: controller.panelPos(), onChange: function (e) { controller.setPanelPos(e.target.value) } },
+            h('option', { value: 'bottom-left' }, t('posBottomLeft')), h('option', { value: 'page' }, t('posPage')), h('option', { value: 'both' }, t('posBoth'))), t('fPanelPosHint')),
           field(locale === 'zh' ? '强调色' : 'Accent color', h('select', { 'data-dam-select': '', value: accentTheme, onChange: function (e) { setAccent(e.target.value) } },
             h('option', { value: 'deepseek' }, locale === 'zh' ? 'DeepSeek 蓝' : 'DeepSeek blue'), h('option', { value: 'graphite' }, locale === 'zh' ? '石墨灰' : 'Graphite'), h('option', { value: 'violet' }, locale === 'zh' ? '雾紫' : 'Violet')), locale === 'zh' ? '默认使用 DeepSeek 蓝；日历与状态颜色保持语义色。' : 'DeepSeek blue by default; calendar and status colors stay semantic.'),
           field(locale === 'zh' ? '关系图密度' : 'Graph density', h('select', { 'data-dam-select': '', value: graphDensity, onChange: function (e) { setDensity(e.target.value) } },
-            h('option', { value: 'relaxed' }, locale === 'zh' ? '舒展' : 'Relaxed'), h('option', { value: 'compact' }, locale === 'zh' ? '紧凑' : 'Compact')), locale === 'zh' ? '影响工作区关系图的节点间距和显示数量。' : 'Controls node spacing and detail in the workspace graph.')
-        ]),
-        section('storage', sectionLabels.storage, [field(t('fUserDir'), h('input', { 'data-dam-input': '', value: cfg.userMemoryDir, onChange: function (e) { set('userMemoryDir', e.target.value) } }), t('fUserDirHint')),
-        field(t('fProjectDir'), h('input', { 'data-dam-input': '', value: cfg.projectMemoryDir, onChange: function (e) { set('projectMemoryDir', e.target.value) } }), t('fProjectDirHint')),
-        field(t('fMemoryRoot'), h('div', { 'data-dam-row': '', style: { flex: 1 } },
-          h('input', { 'data-dam-input': '', style: { flex: 1 }, value: cfg.memoryRoot || '', onChange: function (e) { set('memoryRoot', e.target.value) } }),
-          h('button', { 'data-dam-btn': '', onClick: function () { openBrowser() } }, t('fBrowse'))), t('fMemoryRootHint')),
-        browseOpen ? h('div', { style: { border: '1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(128,128,128,.25)) 60%, transparent)', borderRadius: '8px', padding: '8px', marginBottom: '8px', background: 'color-mix(in srgb, var(--dsw-alias-bg-layer-1, rgba(128,128,128,.06)) 40%, transparent)' } },
-          h('div', { 'data-dam-row': '' },
-            h('b', { style: { fontSize: 'calc(12px * var(--dam-scale))', wordBreak: 'break-all', flex: 1 } }, browsePath || '…'),
-            h('button', { 'data-dam-btn': '', onClick: function () { browseTo(browseParent) }, disabled: browseParent === browsePath }, t('fUp'))),
-          h('div', { style: { maxHeight: '160px', overflow: 'auto', marginTop: '4px' } },
-            (browseDirs || []).map(function (d) {
-              return h('button', { key: d.path, 'data-dam-btn': '', style: { display: 'block', width: '100%', textAlign: 'left', padding: '3px 6px' }, onClick: function () { browseTo(d.path) } }, '📁 ' + d.name)
-            }).concat(browseDirs && !browseDirs.length ? [h('div', { key: 'e', 'data-dam-hint': '' }, t('empty'))] : [])),
-          h('div', { 'data-dam-row': '', style: { marginTop: '6px' } },
-            h('button', { 'data-dam-btn': '', onClick: function () { set('memoryRoot', browsePath); setBrowseOpen(false) } }, t('fSelectDir')),
-            h('button', { 'data-dam-btn': '', onClick: function () { setBrowseOpen(false) } }, t('close'))))
-          : null]),
-        section('injection', sectionLabels.injection, [field(t('fInject'), h('input', { type: 'checkbox', checked: !!cfg.injectEnabled, onChange: function (e) { set('injectEnabled', e.target.checked) } }), t('fInjectHint')),
-        field(t('fBudget'), h('input', { 'data-dam-input': '', type: 'number', min: 400, value: cfg.injectBudgetChars, onChange: function (e) { set('injectBudgetChars', Number(e.target.value) || 2400) } }), t('fBudgetHint')),
-        // 群反馈第 4 条:排除来源(每行一条)。textarea 便于粘贴多行路径;
-        // 空行/纯空白在写回时被过滤,避免"看起来配了其实没配"。
-        field(t('fExclude'), h('textarea', {
-          'data-dam-input': '', rows: 3,
-          style: { width: '100%', resize: 'vertical', fontFamily: 'inherit' },
-          value: (Array.isArray(cfg.injectExcludeSources) ? cfg.injectExcludeSources : []).join('\n'),
-          placeholder: 'mem_0123456789abcdef0123456789abcdef\nD:\\ws\\.dsh-memory\\archive\\\nlog',
-          onChange: function (e) {
-            var lines = String(e.target.value || '').split('\n').map(function (x) { return x.trim() }).filter(Boolean)
-            set('injectExcludeSources', lines)
-          },
-        }), t('fExcludeHint')),
-        field(t('fNoteCap'), h('input', { 'data-dam-input': '', type: 'number', min: 500, value: cfg.noteCapacityChars === undefined ? 12000 : cfg.noteCapacityChars, onChange: function (e) { set('noteCapacityChars', Number(e.target.value) || 12000) } }), t('fNoteCapHint')),
-        field(t('fUserCap'), h('input', { 'data-dam-input': '', type: 'number', min: 500, value: cfg.userCapacityChars === undefined ? 12000 : cfg.userCapacityChars, onChange: function (e) { set('userCapacityChars', Number(e.target.value) || 12000) } }), t('fUserCapHint')),
-        field(t('fDays'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 14, value: cfg.recentDaysInjected, onChange: function (e) { set('recentDaysInjected', Number(e.target.value) || 1) } }), t('fDaysHint')),
-        field(t('fExtBudget'), h('input', { 'data-dam-input': '', type: 'number', min: 200, value: cfg.externalInjectionChars === undefined ? 1400 : cfg.externalInjectionChars, onChange: function (e) { set('externalInjectionChars', Number(e.target.value) || 1400) } }), t('fExtBudgetHint')),
-        field(t('fSnapGap'), h('input', { 'data-dam-input': '', type: 'number', min: 0, max: 50, value: cfg.snapshotMinGapRounds === undefined ? 5 : cfg.snapshotMinGapRounds, onChange: function (e) { set('snapshotMinGapRounds', Number(e.target.value) || 5) } }), t('fSnapGapHint')),
-        field(t('fReinjectOnCompact'), h('input', { type: 'checkbox', checked: cfg.snapshotReinjectOnCompact !== false, onChange: function (e) { set('snapshotReinjectOnCompact', e.target.checked) } }), t('fReinjectOnCompactHint')),
-        field(t('fPromptCustom'), h('button', { 'data-dam-btn': '', onClick: function () { setPromptEditOpen(!promptEditOpen) } }, (promptEditOpen ? (locale === 'zh' ? '收起' : 'Collapse') : (locale === 'zh' ? '编辑 prompt 层' : 'Edit prompt layers'))), t('fPromptCustomHint')),
-        promptEditOpen ? [
-          h('div', { key: '__layers', style: { padding: '6px 0 2px', width: '100%' } },
-          (Object.keys(DEFAULT_PROMPT_LAYERS_CLIENT)).map(function (k) {
-            return h('div', { key: k, style: { marginBottom: '6px' } },
-              h('div', { 'data-dam-hint': '', style: { fontWeight: 700, marginBottom: '2px' } }, k),
-              h('textarea', { 'data-dam-input': '', rows: 2, style: { width: '100%', fontFamily: 'monospace', fontSize: 'calc(11px * var(--dam-scale))' }, value: (cfg.promptLayerOverrides || {})[k] || '', placeholder: DEFAULT_PROMPT_LAYERS_CLIENT[k] || '(默认文案)', onChange: function (e) { var ov = Object.assign({}, cfg.promptLayerOverrides || {}); if (e.target.value.trim() === '') delete ov[k]; else ov[k] = e.target.value; set('promptLayerOverrides', ov) } }))
-          })),
-          h('div', { key: '__reset', 'data-dam-row': '', style: { marginTop: '6px' } },
-            h('button', { 'data-dam-btn': '', onClick: function () { set('promptLayerOverrides', {}) } }, locale === 'zh' ? '一键恢复默认' : 'Reset to defaults'))
-        ] : null]),
-        section('automation', sectionLabels.automation, [field(t('fConsolidateMin'), h('input', { 'data-dam-input': '', type: 'number', min: 80, value: cfg.autoConsolidateMinChars === undefined ? 240 : cfg.autoConsolidateMinChars, onChange: function (e) { set('autoConsolidateMinChars', Number(e.target.value) || 240) } }), t('fConsolidateMinHint')),
-        field(t('fAutoConsolidate'), h('input', { type: 'checkbox', checked: cfg.autoConsolidate !== false, onChange: function (e) { set('autoConsolidate', e.target.checked) } }), t('fAutoConsolidateHint')),
-        field(t('fConsolidate'), h('input', { 'data-dam-input': '', type: 'number', min: 5, value: cfg.autoConsolidateCooldownMinutes === undefined ? 30 : cfg.autoConsolidateCooldownMinutes, onChange: function (e) { set('autoConsolidateCooldownMinutes', Number(e.target.value) || 30) } }), t('fConsolidateHint')),
-        field(t('fConsolidateMax'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 50, value: cfg.autoConsolidateDailyMax === undefined ? 8 : cfg.autoConsolidateDailyMax, onChange: function (e) { set('autoConsolidateDailyMax', Number(e.target.value) || 8) } }), t('fConsolidateMaxHint')),
-        field(t('fAutoPopup'), h('input', { type: 'checkbox', checked: cfg.autoPopupEnabled !== false, onChange: function (e) { set('autoPopupEnabled', e.target.checked) } }), t('fAutoPopupHint')),
-        field(t('fUnattended'), h('input', { type: 'checkbox', checked: !!cfg.unattendedMode, onChange: function (e) { set('unattendedMode', e.target.checked) } }), t('fUnattendedHint')),
-        field(t('fUnattendedAuto'), h('input', { type: 'checkbox', checked: !!cfg.unattendedAuto, onChange: function (e) { set('unattendedAuto', e.target.checked) } }), t('fUnattendedAutoHint')),
-        field(t('fAway'), h('input', { 'data-dam-input': '', type: 'number', min: 0, value: (Number(cfg.awayMinutes) === 0 ? 0 : (cfg.awayMinutes || 60)), onChange: function (e) { var v = Number(e.target.value); set('awayMinutes', Number.isFinite(v) && v >= 0 ? v : 60) } }), t('fAwayHint')),
-        field(t('fAutoSum'), h('input', { 'data-dam-input': '', value: (cfg.autoSummaryTimes || []).join(','), onChange: function (e) { set('autoSummaryTimes', String(e.target.value || '').split(',').map(function (s) { return s.trim() }).filter(Boolean)) } }), t('fAutoSumHint')),
-        field(t('fDayBoundary'), h('input', { 'data-dam-input': '', type: 'number', min: 0, max: 1439, value: (cfg.dayBoundaryMinutes === undefined ? 450 : cfg.dayBoundaryMinutes), onChange: function (e) { set('dayBoundaryMinutes', parseInt(e.target.value || '0', 10)) } }), t('fDayBoundaryHint')),
-        field(t('fReflect'), h('input', { type: 'checkbox', checked: !!cfg.reflectEnabled, onChange: function (e) { set('reflectEnabled', e.target.checked) } }), t('fReflectHint')),
-        field(t('fConsSchedule'), h('input', { type: 'checkbox', checked: cfg.consolidateScheduleEnabled !== false, onChange: function (e) { set('consolidateScheduleEnabled', e.target.checked) } }), t('fConsScheduleHint')),
-        field(t('fConsScheduleTime'), h('input', { 'data-dam-input': '', placeholder: '09:30', value: cfg.consolidateScheduleTime === undefined ? '09:30' : cfg.consolidateScheduleTime, onChange: function (e) { set('consolidateScheduleTime', String(e.target.value || '').trim()) } }), t('fConsScheduleTimeHint')),
-        field(t('fConsScheduleDays'), h('input', { 'data-dam-input': '', type: 'number', min: 1, max: 60, value: cfg.consolidateScheduleDays === undefined ? 7 : cfg.consolidateScheduleDays, onChange: function (e) { set('consolidateScheduleDays', Number(e.target.value) || 7) } }), t('fConsScheduleDaysHint')),
-        field(t('fMaintSchedule'), h('input', { type: 'checkbox', checked: cfg.maintainScheduleEnabled !== false, onChange: function (e) { set('maintainScheduleEnabled', e.target.checked) } }), t('fMaintScheduleHint')),
-        field(t('fMaintScheduleTime'), h('input', { 'data-dam-input': '', placeholder: '10:00', value: cfg.maintainScheduleTime === undefined ? '10:00' : cfg.maintainScheduleTime, onChange: function (e) { set('maintainScheduleTime', String(e.target.value || '').trim()) } }), t('fMaintScheduleTimeHint')),
-        field(t('fStyle'), h('select', { 'data-dam-select': '', value: cfg.reflectStyle, onChange: function (e) { set('reflectStyle', e.target.value) } },
-          STYLE_IDS.map(function (id) { return h('option', { key: id, value: id }, t('style' + id.charAt(0).toUpperCase() + id.slice(1))) })), t('fStyleHint')),
-        field(locale === 'zh' ? '子代理模型 / 思考强度' : 'Subagent model & reasoning effort', h('div', { 'data-dam-row': '', style: { flex: 1 } },
-          h('span', { style: { flex: 1, fontSize: 'calc(12px * var(--dam-scale))', wordBreak: 'break-all', opacity: cfg.subagentModel ? 1 : 0.6 } }, (cfg.subagentModel || (locale === 'zh' ? '跟随路由默认' : 'routing default')) + (String(cfg.subagentReasoningEffort || '') ? ' · ' + String(cfg.subagentReasoningEffort) : '')),
-          h('button', { 'data-dam-btn': '', onClick: openModels }, locale === 'zh' ? '选择模型 / 强度' : 'Pick model / effort')),
-          locale === 'zh' ? '用于时段总结、问候语、自动沉淀、蒸馏等 subagent 功能;模型与思考强度(off/low/high/max)都经 DSH 的 agentOptions 下发,留空跟随路由与模型默认。保存后生效。' : 'For scheduled summaries, greetings, auto-consolidation and distillation subagents; model and reasoning effort (off/low/high/max) are delivered via DSH agentOptions. Empty follows routing and model defaults. Applies after saving.'),
-        mdlOpen ? buildModelDrawer() : null,
+            h('option', { value: 'relaxed' }, locale === 'zh' ? '舒展' : 'Relaxed'), h('option', { value: 'compact' }, locale === 'zh' ? '紧凑' : 'Compact')), locale === 'zh' ? '影响工作区关系图的节点间距和显示数量。' : 'Controls node spacing and detail in the workspace graph.'),
+          // 群反馈第 4 条:排除来源(每行一条)。textarea 便于粘贴多行路径;
+          // 空行/纯空白在写回时被过滤,避免"看起来配了其实没配"。
+          field(t('fExclude'), h('textarea', {
+            'data-dam-input': '', rows: 3,
+            style: { width: '100%', resize: 'vertical', fontFamily: 'inherit' },
+            value: (Array.isArray(cfg.injectExcludeSources) ? cfg.injectExcludeSources : []).join('\n'),
+            placeholder: 'mem_0123456789abcdef0123456789abcdef\nD:\\ws\\.dsh-memory\\archive\\\nlog',
+            onChange: function (e) {
+              var lines = String(e.target.value || '').split('\n').map(function (x) { return x.trim() }).filter(Boolean)
+              set('injectExcludeSources', lines)
+            },
+          }), t('fExcludeHint')),
+          field(locale === 'zh' ? '子代理模型 / 思考强度' : 'Subagent model & reasoning effort', h('div', { 'data-dam-row': '', style: { flex: 1 } },
+            h('span', { style: { flex: 1, fontSize: 'calc(12px * var(--dam-scale))', wordBreak: 'break-all', opacity: cfg.subagentModel ? 1 : 0.6 } }, (cfg.subagentModel || (locale === 'zh' ? '跟随路由默认' : 'routing default')) + (String(cfg.subagentReasoningEffort || '') ? ' · ' + String(cfg.subagentReasoningEffort) : '')),
+            h('button', { 'data-dam-btn': '', onClick: openModels }, locale === 'zh' ? '选择模型 / 强度' : 'Pick model / effort')),
+            locale === 'zh' ? '用于时段总结、问候语、自动沉淀、蒸馏等 subagent 功能;模型与思考强度(off/low/high/max)都经 DSH 的 agentOptions 下发,留空跟随路由与模型默认。保存后生效。' : 'For scheduled summaries, greetings, auto-consolidation and distillation subagents; model and reasoning effort (off/low/high/max) are delivered via DSH agentOptions. Empty follows routing and model defaults. Applies after saving.'),
+          mdlOpen ? buildModelDrawer() : null,
         ]),
-        // 2026-09-14 解耦:交接白板与自动接续各自独立成项(旧实现只在白板页有接续按钮,且 enabled 还被
-        // handoffEnabled 二次与运算)。两者出厂默认均为 false(功能仍在测试期),这里与白板页读写完全相同的配置键。
-        section('context', sectionLabels.context, [field(t('fHandoff'), h('input', { type: 'checkbox', 'data-dam-key': 'handoffEnabled', checked: cfg.handoffEnabled !== false, onChange: function (e) { set('handoffEnabled', e.target.checked) } }), t('fHandoffHint')),
-        field(t('fAutoContinue'), h('input', { type: 'checkbox', 'data-dam-key': 'autoContinueEnabled', checked: cfg.autoContinueEnabled !== false, onChange: function (e) { set('autoContinueEnabled', e.target.checked) } }), t('fAutoContinueHint')),
-        field(t('fHandoffPlan'), h('input', { 'data-dam-input': '', type: 'number', min: 200, value: cfg.handoffPlanChars === undefined ? 1200 : cfg.handoffPlanChars, onChange: function (e) { set('handoffPlanChars', Number(e.target.value) || 1200) } }), t('fHandoffPlanHint')),
-        field(t('fHandoffLedger'), h('input', { 'data-dam-input': '', type: 'number', min: 100, value: cfg.handoffLedgerChars === undefined ? 800 : cfg.handoffLedgerChars, onChange: function (e) { set('handoffLedgerChars', Number(e.target.value) || 800) } }), t('fHandoffLedgerHint')),
-        field(t('fWaterWindow'), h('input', { 'data-dam-input': '', type: 'number', min: 0, value: cfg.waterLevelWindowTokens === undefined ? 65536 : cfg.waterLevelWindowTokens, onChange: function (e) { set('waterLevelWindowTokens', Number(e.target.value) || 0) } }), t('fWaterWindowHint')),
-        field(t('fWaterThreshold'), h('input', { 'data-dam-input': '', type: 'number', min: 0.1, max: 1.5, step: 0.05, value: cfg.waterLevelThreshold === undefined ? 0.75 : cfg.waterLevelThreshold, onChange: function (e) { set('waterLevelThreshold', Number(e.target.value) || 0.75) } }), t('fWaterThresholdHint')),
-        field(t('fWaterAdvisory'), h('input', { type: 'checkbox', checked: cfg.waterLevelAdvisory !== false, onChange: function (e) { set('waterLevelAdvisory', e.target.checked) } }), t('fWaterAdvisoryHint')),
-        field(t('fWaterAuto'), h('input', { type: 'checkbox', checked: cfg.waterLevelAutoHandoff !== false, onChange: function (e) { set('waterLevelAutoHandoff', e.target.checked) } }), t('fWaterAutoHint')),
-        // WB-GRAPH 白板线一键切换(2026-09-16, board_mode_v1): 旧版白板(默认) / 新版看板(dsh-graph vendor
-        // + sidecar + 遍历工具, 工具数 14→16)。开关解耦: 只管白板线; 切换需重启 dsh web 生效(工具注册在启动期)。
-        field(locale === 'zh' ? '白板模式（旧版白板 / 新版看板）' : 'Board mode (legacy / graph)', (function () {
-          var cur = cfg.boardMode === 'graph' ? 'graph' : 'legacy'
-          // ★2026-09-16 修 BUG-3(设置页切换不落盘): 旧实现 `set('boardMode', m)` 只改**本地 React 态**
-          // 然后 reload —— 配置从未写到服务端, 刷新后仍是旧值(界面回跳原档), 用户会判定"开关坏了"。
-          // 正解: 走与接续面板同一个写入路径 `saveConfigPatch(API.config, patch)`(见 :999 定义),
-          // 写盘成功后再 reload; 失败则在界面提示, 不静默假装成功。
-          // 同时满足用户硬性偏好: 开关类改动必须**即时回显**(写盘后立即 reload 呈现新档)。
-          function pick(m) {
-            set('boardMode', m) // 先本地回显(即时反馈)
-            saveConfigPatch({ boardMode: m }, {
-              onSaved: function () { window.setTimeout(function () { window.location.reload() }, 350) },
-              onError: function (e) { setErr(String((e && e.message) || e || 'save failed')) },
-            })
-          }
-          return h('div', { 'data-dam-row': '' },
-            h('button', { 'data-dam-btn': '', 'data-dam-key': 'boardMode', style: { fontWeight: cur === 'legacy' ? 700 : 400, opacity: cur === 'legacy' ? 1 : 0.65 }, onClick: function () { if (cur !== 'legacy') pick('legacy') } }, locale === 'zh' ? '旧版白板' : 'Legacy board'),
-            h('button', { 'data-dam-btn': '', 'data-dam-key': 'boardModeGraph', style: { marginLeft: '6px', fontWeight: cur === 'graph' ? 700 : 400, opacity: cur === 'graph' ? 1 : 0.65 }, onClick: function () { if (cur !== 'graph') pick('graph') } }, locale === 'zh' ? '新版看板（dsh-graph）' : 'Graph board (dsh-graph)'))
-        })(),
-          locale === 'zh' ? '一键切换白板形态。默认「旧版白板」=一切行为不变；切到「新版看板」后启用 dsh-graph 看板、白板结构化索引（handoff/index.json）与两个遍历工具（memory_expand_pre / memory_trace_pre，工具数 14→16）。切换后需重启 dsh web 生效；再点回旧版即完全回滚。' : 'One-click switch for the board form. Default "Legacy board" keeps everything unchanged; "Graph board" enables the dsh-graph kanban, the structured handoff index (handoff/index.json) and two traversal tools (memory_expand_pre / memory_trace_pre, tool count 14→16). Restart dsh web after switching; switch back to fully roll back.'),
-        field(locale === 'zh' ? '子代理痕迹回收' : 'Subagent trace recycle', h('input', { type: 'checkbox', checked: cfg.subagentGcEnabled !== false, onChange: function (e) { set('subagentGcEnabled', e.target.checked) } }),
-          locale === 'zh' ? '本插件的一次性子代理(自动沉淀 / 时段总结 / 问候 / 蒸馏)每跑一次都会在 ~/.dsh/sessions 留下一个持久化会话;数量上千后会话列表会明显变慢。开启后任务一结束就把这些痕迹移入 ~/.dsh/subagent-gc-backup 备份(可回滚),不影响子代理结果。默认开。' : 'Every one-shot subagent this plugin spawns (auto-consolidation, scheduled summary, greeting, distillation) leaves a persisted session under ~/.dsh/sessions; hundreds of them slow the session list down. When on, each trace is moved into ~/.dsh/subagent-gc-backup right after the task ends (reversible), never affecting the subagent result. On by default.'),
-        field(locale === 'zh' ? '兜底回收保留天数' : 'Fallback recycle keep days', h('input', { 'data-dam-input': '', type: 'number', min: 0, value: cfg.subagentGcKeepDays === undefined ? 3 : cfg.subagentGcKeepDays, onChange: function (e) { set('subagentGcKeepDays', Number(e.target.value) || 0) } }),
-          locale === 'zh' ? '每天巡检一次,回收超过该天数仍残留的痕迹(比如任务异常中断没删掉的);0 = 不按时间,只靠任务结束即删。' : 'A daily sweep recycles traces older than this many days (e.g. leftovers from interrupted tasks); 0 = rely on the end-of-task recycle only.')]),
-        section('maintenance', sectionLabels.maintenance, [field(t('fVersion'), h('div', { 'data-dam-row': '' },
-          h('span', { style: { flex: 1 } }, verInfo ? (verInfo.current || '?') + (verInfo.latest ? ' → ' + verInfo.latest + (verInfo.upToDate ? ' ' + t('upToDate') : ' ' + t('hasUpdate')) : '') : (checkingUpdate ? t('checking') : '—')),
-          h('button', { 'data-dam-btn': '', onClick: checkUpdate, disabled: checkingUpdate }, checkingUpdate ? t('checking') : t('checkUpdate')),
-          (verInfo && verInfo.latest && !verInfo.upToDate && verInfo.installKind === 'registry') ? h('button', { 'data-dam-btn': '', onClick: doUpdate, disabled: upBusy, style: { marginLeft: '4px' } }, upBusy ? t('updating') : t('updateNow')) : null,
-          upMsg ? h('span', { 'data-dam-hint': '' }, upMsg) : null),
-          t('versionCmdHint') + (verInfo && verInfo.error ? ' ' + t('versionError') + verInfo.error : '') + (verInfo && verInfo.installKind === 'dev-link' ? ' ' + t('devLinkHint') : '') + (verInfo && !verInfo.installKind ? ' ' + t('noProfileHint') : '')),
+        section('about', sectionLabels.about, [
+          // WB-GRAPH 白板线一键切换(2026-09-16, board_mode_v1): 旧版白板(默认) / 新版看板(dsh-graph vendor
+          // + sidecar + 遍历工具, 工具数 14→16)。开关解耦: 只管白板线; 切换需重启 dsh web 生效(工具注册在启动期)。
+          field(locale === 'zh' ? '白板模式（旧版白板 / 新版看板）' : 'Board mode (legacy / graph)', (function () {
+            var cur = cfg.boardMode === 'graph' ? 'graph' : 'legacy'
+            // ★2026-09-16 修 BUG-3(设置页切换不落盘): 旧实现 `set('boardMode', m)` 只改**本地 React 态**
+            // 然后 reload —— 配置从未写到服务端, 刷新后仍是旧值(界面回跳原档), 用户会判定"开关坏了"。
+            // 正解: 走与接续面板同一个写入路径 `saveConfigPatch(API.config, patch)`(见 :999 定义),
+            // 写盘成功后再 reload; 失败则在界面提示, 不静默假装成功。
+            // 同时满足用户硬性偏好: 开关类改动必须**即时回显**(写盘后立即 reload 呈现新档)。
+            function pick(m) {
+              set('boardMode', m) // 先本地回显(即时反馈)
+              saveConfigPatch({ boardMode: m }, {
+                onSaved: function () { window.setTimeout(function () { window.location.reload() }, 350) },
+                onError: function (e) { setErr(String((e && e.message) || e || 'save failed')) },
+              })
+            }
+            return h('div', { 'data-dam-row': '' },
+              h('button', { 'data-dam-btn': '', 'data-dam-key': 'boardMode', style: { fontWeight: cur === 'legacy' ? 700 : 400, opacity: cur === 'legacy' ? 1 : 0.65 }, onClick: function () { if (cur !== 'legacy') pick('legacy') } }, locale === 'zh' ? '旧版白板' : 'Legacy board'),
+              h('button', { 'data-dam-btn': '', 'data-dam-key': 'boardModeGraph', style: { marginLeft: '6px', fontWeight: cur === 'graph' ? 700 : 400, opacity: cur === 'graph' ? 1 : 0.65 }, onClick: function () { if (cur !== 'graph') pick('graph') } }, locale === 'zh' ? '新版看板（dsh-graph）' : 'Graph board (dsh-graph)'))
+          })(),
+            locale === 'zh' ? '一键切换白板形态。默认「旧版白板」=一切行为不变；切到「新版看板」后启用 dsh-graph 看板、白板结构化索引（handoff/index.json）与两个遍历工具（memory_expand / memory_trace，工具数 14→16）。切换后需重启 dsh web 生效；再点回旧版即完全回滚。' : 'One-click switch for the board form. Default "Legacy board" keeps everything unchanged; "Graph board" enables the dsh-graph kanban, the structured handoff index (handoff/index.json) and two traversal tools (memory_expand / memory_trace, tool count 14→16). Restart dsh web after switching; switch back to fully roll back.'),
+  field(t('fVersion'), h('div', { 'data-dam-row': '' },
+            h('span', { style: { flex: 1 } }, verInfo ? (verInfo.current || '?') + (verInfo.latest ? ' → ' + verInfo.latest + (verInfo.upToDate ? ' ' + t('upToDate') : ' ' + t('hasUpdate')) : '') : (checkingUpdate ? t('checking') : '—')),
+            h('button', { 'data-dam-btn': '', onClick: checkUpdate, disabled: checkingUpdate }, checkingUpdate ? t('checking') : t('checkUpdate')),
+            (verInfo && verInfo.latest && !verInfo.upToDate && verInfo.installKind === 'registry') ? h('button', { 'data-dam-btn': '', onClick: doUpdate, disabled: upBusy, style: { marginLeft: '4px' } }, upBusy ? t('updating') : t('updateNow')) : null,
+            upMsg ? h('span', { 'data-dam-hint': '' }, upMsg) : null),
+            t('versionCmdHint') + (verInfo && verInfo.error ? ' ' + t('versionError') + verInfo.error : '') + (verInfo && verInfo.installKind === 'dev-link' ? ' ' + t('devLinkHint') : '') + (verInfo && !verInfo.installKind ? ' ' + t('noProfileHint') : '')),
           field(locale === 'zh' ? '交流群' : 'Community', h('div', { 'data-dam-row': '' },
             h('span', { style: { flex: 1 } }, locale === 'zh' ? '反馈问题、交流使用技巧——加群响应比 issue 更快。' : 'Share feedback and tips with other users — the group responds faster than GitHub issues.'),
             h('a', { href: 'https://qm.qq.com/q/v7Asxn6vPa', target: '_blank', rel: 'noreferrer', style: { textDecoration: 'none', color: 'var(--dam-accent, #4f7cff)' } }, locale === 'zh' ? '点击加入 QQ 交流群' : 'Join the QQ community group')),
-            locale === 'zh' ? '点击链接一键加群。' : 'One-click join via the QQ invite link.')]),
+            locale === 'zh' ? '点击链接一键加群。' : 'One-click join via the QQ invite link.'),
+        ]),
         h('div', { 'data-dam-savebar': '' },
           h('button', { 'data-dam-btn': '', 'data-dirty': dirty ? 'true' : undefined, onClick: save, disabled: busy }, busy ? t('saving') : (dirty ? (locale === 'zh' ? '保存更改' : 'Save changes') : t('saveSettings'))),
           dirty ? h('span', { 'data-dam-hint': '' }, locale === 'zh' ? '有未保存的更改' : 'Unsaved changes') : null,
@@ -5392,6 +6766,19 @@ window.__ModuleLoader__.load({
           surfaceDisposers.push(slots.inject('settings.section', function () {
             return slots.register({ name: 'settings.section', id: 'auto-memory', order: 25, label: t('autoMemory') + ' (pre)' }, function (props) { return h(SettingsPage, { close: props && props.close }) })
           }))
+          // ★2026-09-21 二次修正:「记忆」会话页 —— 与「对话轨迹」「上下文」「白板看板」并列的一页。
+          // 用户实测反馈:「它现在是浮在整个页面上方的,而不是和对话轨迹、上下文、白板看板在一起,作为一个单独的一页」。
+          // 根因:宿主只给 4 个槽位(sidebar/main/rightbar/shell.overlay),overlay 里的东西只能"盖"在界面上;
+          //   要成为并列页必须走 conversation.view(官方对话轨迹与本插件白板看板都注册在这里)。
+          // 出现条件:承载面 = 会话页 / 两者共存;切回「左下角浮层」时移除该页签(由 refreshSurfaces 重注册)。
+          if (controller.panelPos() === 'page' || controller.panelPos() === 'both') {
+            surfaceDisposers.push(slots.inject('conversation.view', function () {
+              return slots.register(
+                { name: 'conversation.view', id: 'auto-memory-panel', order: 78, label: function () { return locale === 'zh' ? '记忆' : 'Memory' } },
+                function (props) { return h(MemoryPageView, props || {}) },
+              )
+            }))
+          }
           // 2026-09-16「双承载面」: 会话页顶栏再挂一个**整页白板看板**(与侧边面板共存)。
           // 面板 440px 装不下矩阵, 整页 ~1000px+ 可以 ⇒ 两者按容器宽度各用其形态。
           // 与 boardMode 闸门解耦: 组件内部自己取数, 非 graph 档拿到 enabled:false 就显示提示,
@@ -5402,6 +6789,27 @@ window.__ModuleLoader__.load({
               function (props) { return h(KanbanView, props || {}) },
             )
           }))
+          // 2026-09-21「白板画布」**暂时隐藏**（用户拍板：功能未达可用标准，先发版收尾）。
+          //
+          // 为什么不删代码: 画布本身是完整实现(清洗层 + 分列布局 + 平移缩放 + 侧栏),
+          //   只是**数据源受限** —— 实测 D:\dsh-auto-memory 下 880 张卡、189 篇文档,
+          //   当前布局是「泳道分列 + 每列上限 14 + 折叠」, 但它依赖 kanban-board 在当前
+          //   会话下能解析出**正确的工作区**; 实测 sessionId 解析失败时 API 返回
+          //   enabled:true 但 **ws 为空 + 0 张卡** ⇒ 画布显示"暂无内容"。
+          //   ⇒ 保留代码 + 默认关闭, 待工作区解析路径稳定后一行开启。
+          //
+          // 开启方式: 把下面的 false 改成 true(或设为 localStorage['dam-wbg-enabled']='1')。
+          var WBG_ENABLED = (function () {
+            try { return localStorage.getItem('dam-wbg-enabled') === '1' } catch (e) { return false }
+          })()
+          if (WBG_ENABLED) {
+            surfaceDisposers.push(slots.inject('conversation.view', function () {
+              return slots.register(
+                { name: 'conversation.view', id: 'auto-memory-graph', order: 81, label: function () { return locale === 'zh' ? '白板画布' : 'Graph' } },
+                function (props) { return h(WhiteboardGraphView, props || {}) },
+              )
+            }))
+          }
         } catch (e) {
           console.warn('[dsh-auto-memory] slot registration failed', e)
         }
@@ -5411,8 +6819,12 @@ window.__ModuleLoader__.load({
         surfaceDisposers = []
         registerSurfaces()
       }
+      // 把「重注册承载面」暴露给模块作用域:设置页切换承载面时,「记忆」会话页签要当场增/删(见 setSurfacesRefreshHook)
+      setSurfacesRefreshHook(refreshSurfaces)
+      // ★2026-09-21 二次修正:syncTitlebarVar() 及其调用点已一并删除 —— 它只为「顶部通栏覆盖条」让位 Windows
+      // 自绘标题栏而存在,该形态废弃后无消费者(会话页在正常文档流里,由宿主布局负责)。
       registerSurfaces()
-      console.log('[dsh-auto-memory] client ready: sidebar entry + panel + settings page')
+      console.log('[dsh-auto-memory] client ready: sidebar entry + floating card / memory session page (switchable) + settings page')
     }
 
     exports.inject = ['slots', 'sessions', 'remote', 'remote.session']