dsh-session-flow 1.1.0 → 1.3.0

package/lib/client.js

@@ -13,7 +13,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
   var module = { exports: {} }; var exports = module.exports;
 
   const React = require('react')
-  const { useState, useEffect, useMemo, useRef } = React
+  const { useState, useEffect, useMemo, useRef, useSyncExternalStore } = React
   const h = React.createElement
   const { createRoot } = require('react-dom/client')
 
@@ -24,7 +24,10 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
   const OTHER_ACTIVE_ATTRS = ['data-dsh-taskboard-active', 'data-dsh-ssh-active']
   const ACTIVATE_EVENT = 'dsh-panel-activate'
   const PANEL_NAME = 'sessionflow'
-  const CONVERSATION_SELECTOR = '[data-pane="conversation"]'
+  // 会话面板容器选择器：dsh v0.1.2 起官方移除 data-pane="conversation"（会话流
+  // 重构进 dsh-client-ui-chat），兜底命中布局中栏（CenterColumn，类名含 centerCol
+  // 哈希后缀稳定片段）。工作台/标签切换/钢琴键定位共用此锚。
+  const CONVERSATION_SELECTOR = '[data-pane="conversation"], [class*=centerCol]'
   const SIDEBAR_ROW_SELECTOR = '[class*="sessionRow"], [class*="projectRow"], [class*="searchResultRow"], [class*="searchResultWorkspace"], [class*="newSession"]'
   const ACTIVE_WINDOW_MS = 15 * 60 * 1000 // 最近 15 分钟有事件 → 视为进行中（归档/总览徽标用）
 
@@ -40,6 +43,8 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     pianoJumpFail: '该轮次尚未加载：请在会话区向上滚动加载历史后再点击',
     fullText: '全文检索', fullTextSearching: '搜索中…', fullTextPartial: '已扫描 {N}/{M} 个会话（结果未完整）', fullTextNone: '全文无命中', fullTextFail: '全文检索失败',
     dock: '并入右栏', dockExit: '退出并入', dockHint: '会话流已并入右侧栏 · 随当前会话切换', dockEmpty: '打开会话后可在此查看会话流',
+    dockLiveHint: '实时：只显示开播后的对话，不加载历史回合', dockLiveEmpty: '实时中 · 等待新对话…', dockLiveEnterFail: '当前会话已结束或不可实时',
+    dockPinNotice: '📌 直播已钉住原会话（当前已切换会话）', dockPinRebind: '转播当前会话',
     rename: '重命名', renamePlaceholder: '输入新标题…', renameFail: '重命名失败', origTitle: '原名',
     search: '搜索标题/工具/文件… 支持 tool: pwsh · file: src · err:', allWorkspaces: '全部工作区',
     sortRecent: '最近运行', sortNewest: '最近创建', sortOldest: '最早创建', sortTools: '工具最多', sortLongest: '耗时最长',
@@ -72,16 +77,35 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     summaryStale: '⚠ 摘要生成后有新对话，内容可能已不准确，建议重新生成',
     llmSummary: '生成 LLM 摘要', llmGenerating: '生成中…', llmFail: '生成失败', summaryRuleTag: '规则', summaryLlmTag: 'LLM',
     cacheHint: '仅清理本插件的缓存（可自动重建），不影响 DSH 会话存档与任何其他数据', cacheLimit: '时间线缓存上限',
-    healthActive: '活跃', healthToolWait: '工具执行中', healthQuiet: '静默中', healthStalled: '疑似卡死',
+    healthActive: '活跃', healthToolWait: '工具执行中', healthQuiet: '静默中', healthStalled: '疑似卡死', healthIdle: '空闲',
+    agoJustNow: '刚刚', agoMin: '{N} 分钟前', agoHour: '{N} 小时前', agoDay: '{N} 天前',
     healthSilentMin: '静默 {N} 分钟', healthSilentSec: '静默 {N} 秒',
     healthChipTitle: '会话健康状态（会话流）· 点击打开详情',
     renameClearBlocked: '该会话标题由官方会话管理：请输入新标题（不支持清空）',
+    settingsTitle: '会话流', settingsDesc: '调整轮次导航、实时跟踪与健康监控的行为参数。保存后立即生效（轮次悬浮条行数在重进会话页后完全生效）。',
+    setGroupPiano: '轮次悬浮条', setGroupLive: '实时跟踪', setGroupHealth: '健康监控', setGroupNav: '轮次导航（v0.1.2+）',
+    setPianoWindow: '可见行数', setPianoWindowHint: '悬浮条同时显示的轮次条数（6–18）',
+    setPianoWheelSpeed: '滚轮灵敏度', setPianoWheelSpeedHint: '每像素滚动的行数（0.005–0.03），越大滚得越快',
+    setPianoSnapMs: '静止吸附延迟（ms）', setPianoSnapMsHint: '滚轮停止多少毫秒后吸附到整行（100–400）',
+    setLivePollMs: '轮询间隔（ms）', setLivePollMsHint: '实时模式的刷新间隔（1500–10000），下次开播生效',
+    setLiveFollowPx: '吸底阈值（px）', setLiveFollowPxHint: '距底部多少像素内视为「在底部」并跟随滚动（20–120）',
+    setLiveHistoryTurns: '保留历史回合', setLiveHistoryTurnsHint: '实时模式下保留的历史回合数（0–10），下次开播生效',
+    setStallThresholdMin: '卡死阈值（分钟）', setStallThresholdMinHint: '运行中但静默超过该时长判定为疑似卡死（1–10）',
+    setRailEnhance: '官方轮次导航增强', setRailEnhanceHint: '在官方右侧轮次导航上叠加：预览卡内追加结论摘要、右键唤起工作台',
+    setPianoClassic: '经典左侧悬浮条', setPianoClassicHint: '插件自带的左侧轮次悬浮条（默认开，与官方右侧导航并存；点击未载入轮次可委托官方引擎自动加载跳转）',
+    setRailHide: '隐藏官方轮次导航', setRailHideHint: '完全屏蔽官方右侧刻度条，只保留我们的悬浮条（开启后「官方轮次导航增强」自动不生效）',
+    railMetaCalls: '{tools} 次工具', railMetaErrors: '{errors} 错误', railThinking: '含思考',
+    setSave: '保存', setDiscard: '放弃更改', setSaveFail: '部分设置未保存成功，请检查后重试',
+    setReset: '恢复默认', setOverridden: '已修改', setInvalid: '超出范围或格式无效',
+    setUnavailable: '当前环境未暴露设置服务，无法编辑（请升级 dsh 后重试）',
   } : {
     entry: 'Session Flow', title: 'Session Flow', rescan: 'Rescan', scanning: 'Scanning…',
     pianoTitle: 'Turns', pianoNew: 'New session', pianoFav: 'Favorite', pianoUnfav: 'Unfavorite', pianoFavs: 'Favorites', pianoOpenInFlow: 'Open in Session Flow',
     pianoJumpFail: 'Turn not loaded — scroll up in the conversation to load history, then retry',
     fullText: 'Full-text', fullTextSearching: 'Searching…', fullTextPartial: 'Scanned {N}/{M} sessions (partial)', fullTextNone: 'No full-text matches', fullTextFail: 'Full-text search failed',
     dock: 'Dock right', dockExit: 'Undock', dockHint: 'Session Flow docked · follows current session', dockEmpty: 'Open a session to view its flow here',
+    dockLiveHint: 'Live: only the conversation since enabled, no history', dockLiveEmpty: 'Live · waiting for new turns…', dockLiveEnterFail: 'Session ended or not live-capable',
+    dockPinNotice: '📌 Live pinned to previous session (session switched)', dockPinRebind: 'Follow current session',
     rename: 'Rename', renamePlaceholder: 'New title…', renameFail: 'Rename failed', origTitle: 'Original',
     search: 'Search title / tools / files… use tool: · file: · err:', allWorkspaces: 'All workspaces',
     sortRecent: 'Recently run', sortNewest: 'Recently created', sortOldest: 'Oldest first', sortTools: 'Most tools', sortLongest: 'Longest',
@@ -115,12 +139,238 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     summaryStale: '⚠ New conversation since summary was generated; content may be outdated — regenerate',
     llmSummary: 'Generate LLM summary', llmGenerating: 'Generating…', llmFail: 'Failed', summaryRuleTag: 'rule', summaryLlmTag: 'LLM',
     cacheHint: "Only this plugin's cache (auto-rebuilds); never touches DSH session archives or other data", cacheLimit: 'Timeline cache limit',
-    healthActive: 'Active', healthToolWait: 'Tool running', healthQuiet: 'Quiet', healthStalled: 'Likely stalled',
+    healthActive: 'Active', healthToolWait: 'Tool running', healthQuiet: 'Quiet', healthStalled: 'Likely stalled', healthIdle: 'Idle',
+    agoJustNow: 'just now', agoMin: '{N}m ago', agoHour: '{N}h ago', agoDay: '{N}d ago',
     healthSilentMin: 'silent {N} min', healthSilentSec: 'silent {N} s',
     healthChipTitle: 'Session health (Session Flow) · click to open detail',
     renameClearBlocked: 'Title is managed by the official session: enter a new title (clearing unsupported)',
+    settingsTitle: 'Session Flow', settingsDesc: 'Tune turn navigation, live-tracking, and health-monitor behavior. Applies on save (strip row count fully applies after re-entering a session page).',
+    setGroupPiano: 'Turn strip', setGroupLive: 'Live tracking', setGroupHealth: 'Health monitor', setGroupNav: 'Turn navigation (v0.1.2+)',
+    setPianoWindow: 'Visible rows', setPianoWindowHint: 'How many turn keys the strip shows at once (6–18)',
+    setPianoWheelSpeed: 'Wheel speed', setPianoWheelSpeedHint: 'Rows scrolled per pixel (0.005–0.03); larger scrolls faster',
+    setPianoSnapMs: 'Snap delay (ms)', setPianoSnapMsHint: 'Delay after the wheel stops before snapping to a whole row (100–400)',
+    setLivePollMs: 'Poll interval (ms)', setLivePollMsHint: 'Live refresh interval (1500–10000); applies to the next live session',
+    setLiveFollowPx: 'Follow threshold (px)', setLiveFollowPxHint: 'Distance from the bottom that still counts as "at bottom" and follows (20–120)',
+    setLiveHistoryTurns: 'History turns kept', setLiveHistoryTurnsHint: 'History turns kept in live mode (0–10); applies to the next live session',
+    setStallThresholdMin: 'Stall threshold (min)', setStallThresholdMinHint: 'Running but silent beyond this counts as likely stalled (1–10)',
+    setRailEnhance: 'Enhance official turn navigator', setRailEnhanceHint: 'Overlay on the official right-side rail: conclusion section inside its preview card, right-click to open the workbench',
+    setPianoClassic: 'Classic left strip', setPianoClassicHint: 'The plugin\'s own left turn strip (on by default, coexists with the official right rail; clicking an unloaded turn delegates to the official auto-load navigation)',
+    setRailHide: 'Hide official turn navigator', setRailHideHint: 'Fully hide the official right-side rail and keep only our strip (the rail enhancement is inert while this is on)',
+    railMetaCalls: '{tools} tools', railMetaErrors: '{errors} errors', railThinking: 'thinking',
+    setSave: 'Save', setDiscard: 'Discard', setSaveFail: 'Some settings were not saved — check and retry',
+    setReset: 'Reset', setOverridden: 'Modified', setInvalid: 'Out of range or invalid format',
+    setUnavailable: 'The settings service is not exposed in this environment (upgrade dsh and retry)',
   }
 
+  // ── 插件设置（settings.section 独立 tab）──────────────────────────
+  // Host 注册 settings 命名空间 'session-flow'（lib/host.js SETTINGS_DEFAULTS 同源）；
+  // client 经 settingsScope 读写（pet 同款：优先 webUiSettings 桥，回退 ctx.settingsScope）。
+  // 全部消费点读 sfSettings.current.xxx，缺省 = 原硬编码值——无设置时行为零变化。
+  const SETTINGS_DEFAULTS = { pianoWindow: 12, pianoWheelSpeed: 0.012, pianoSnapMs: 170, livePollMs: 3000, liveFollowPx: 40, liveHistoryTurns: 3, stallThresholdMin: 3, railEnhance: true, railHideOfficial: false, pianoClassicStrip: true }
+  const sfSettings = { current: { ...SETTINGS_DEFAULTS } }
+  const SETTING_GROUPS = [
+    { titleKey: 'setGroupPiano', fields: ['pianoWindow', 'pianoWheelSpeed', 'pianoSnapMs'] },
+    { titleKey: 'setGroupLive', fields: ['livePollMs', 'liveFollowPx', 'liveHistoryTurns'] },
+    { titleKey: 'setGroupHealth', fields: ['stallThresholdMin'] },
+    { titleKey: 'setGroupNav', fields: ['railEnhance', 'railHideOfficial', 'pianoClassicStrip'] },
+  ]
+  const SETTING_FIELD_SPECS = {
+    pianoWindow: { min: 6, max: 18, integer: true, labelKey: 'setPianoWindow', hintKey: 'setPianoWindowHint' },
+    pianoWheelSpeed: { min: 0.005, max: 0.03, integer: false, labelKey: 'setPianoWheelSpeed', hintKey: 'setPianoWheelSpeedHint' },
+    pianoSnapMs: { min: 100, max: 400, integer: true, labelKey: 'setPianoSnapMs', hintKey: 'setPianoSnapMsHint' },
+    livePollMs: { min: 1500, max: 10000, integer: true, labelKey: 'setLivePollMs', hintKey: 'setLivePollMsHint' },
+    liveFollowPx: { min: 20, max: 120, integer: true, labelKey: 'setLiveFollowPx', hintKey: 'setLiveFollowPxHint' },
+    liveHistoryTurns: { min: 0, max: 10, integer: true, labelKey: 'setLiveHistoryTurns', hintKey: 'setLiveHistoryTurnsHint' },
+    stallThresholdMin: { min: 1, max: 10, integer: true, labelKey: 'setStallThresholdMin', hintKey: 'setStallThresholdMinHint' },
+    railEnhance: { kind: 'bool', labelKey: 'setRailEnhance', hintKey: 'setRailEnhanceHint' },
+    pianoClassicStrip: { kind: 'bool', labelKey: 'setPianoClassic', hintKey: 'setPianoClassicHint' },
+    railHideOfficial: { kind: 'bool', labelKey: 'setRailHide', hintKey: 'setRailHideHint' },
+  }
+  function formatSettingValue(v) { return v === undefined || v === null ? '' : String(v) }
+  function parseSettingValue(spec, text) {
+    if (spec.kind === 'bool') {
+      const t = String(text).trim()
+      return t === 'true' ? true : t === 'false' ? false : undefined
+    }
+    const n = Number(String(text).trim())
+    if (!Number.isFinite(n) || n < spec.min || n > spec.max) return undefined
+    if (spec.integer && !Number.isInteger(n)) return undefined
+    return n
+  }
+
+  // 设置表单控制器：草稿（staged edits）+ scope 读写（pet CardForm 简化版——
+  // 同样是「保存才落盘」语义；getSnapshot 缓存快照供 useSyncExternalStore）。
+  class SfSettingsController {
+    constructor(scope) {
+      this.scope = scope
+      this.listeners = new Set()
+      this.draft = new Map() // key -> { text, clear }
+      this.saving = false
+      this.failed = false
+      this.cached = null
+      this.unsubscribe = scope.subscribe(() => this.notify())
+      this.notify()
+    }
+    dispose() {
+      try { if (this.unsubscribe) this.unsubscribe() } catch (e) {}
+      this.unsubscribe = null
+      this.listeners.clear()
+    }
+    subscribe(fn) { this.listeners.add(fn); return () => this.listeners.delete(fn) }
+    // 快照值合并进模块级桥（所有功能代码的消费点；settings 变化即时下发）。
+    applySnapshotToBridge() {
+      try {
+        const snap = this.scope.getSnapshot()
+        if (snap && snap.status === 'ready' && snap.value && typeof snap.value === 'object') {
+          sfSettings.current = { ...SETTINGS_DEFAULTS, ...snap.value }
+        }
+      } catch (e) {}
+    }
+    notify() {
+      this.applySnapshotToBridge()
+      this.cached = this.buildSnapshot()
+      for (const fn of this.listeners) fn()
+    }
+    getSnapshot() {
+      if (this.cached === null) this.cached = this.buildSnapshot()
+      return this.cached
+    }
+    buildSnapshot() {
+      let snap = null
+      try { snap = this.scope.getSnapshot() } catch (e) {}
+      const status = snap ? String(snap.status || 'unavailable') : 'unavailable'
+      const value = { ...SETTINGS_DEFAULTS, ...(snap && snap.value ? snap.value : {}) }
+      const user = (snap && snap.user && typeof snap.user === 'object') ? snap.user : {}
+      const fields = {}
+      for (const key of Object.keys(SETTING_FIELD_SPECS)) {
+        const spec = SETTING_FIELD_SPECS[key]
+        const staged = this.draft.get(key)
+        const stored = Object.prototype.hasOwnProperty.call(user, key)
+        if (staged === undefined) {
+          fields[key] = { text: formatSettingValue(value[key]), overridden: stored, invalid: false, clear: false }
+        } else {
+          fields[key] = { text: staged.text, overridden: !staged.clear, invalid: !staged.clear && parseSettingValue(spec, staged.text) === undefined, clear: staged.clear }
+        }
+      }
+      return {
+        status,
+        writable: snap ? snap.writable !== false : false,
+        fields,
+        dirty: this.draft.size > 0,
+        invalid: Object.keys(fields).some((k) => fields[k].invalid),
+        saving: this.saving,
+        failed: this.failed,
+      }
+    }
+    edit(key, text) { this.draft.set(key, { text, clear: false }); this.failed = false; this.notify() }
+    resetField(key) {
+      // 恢复默认 = 清除 user 层覆盖（草稿显示 base 值，保存时 unset）。
+      let baseText = formatSettingValue(SETTINGS_DEFAULTS[key])
+      try {
+        const snap = this.scope.getSnapshot()
+        if (snap && snap.base && snap.base[key] !== undefined) baseText = formatSettingValue(snap.base[key])
+      } catch (e) {}
+      this.draft.set(key, { text: baseText, clear: true })
+      this.failed = false
+      this.notify()
+    }
+    discard() { this.draft.clear(); this.failed = false; this.notify() }
+    async save() {
+      const snap = this.getSnapshot()
+      if (this.draft.size === 0 || this.saving || snap.invalid) return
+      const pending = new Map(this.draft)
+      this.saving = true
+      this.failed = false
+      this.notify()
+      const landed = new Set()
+      for (const [key, staged] of pending) {
+        try {
+          if (staged.clear) { await this.scope.unset(key); landed.add(key); continue }
+          const v = parseSettingValue(SETTING_FIELD_SPECS[key], staged.text)
+          if (v === undefined) continue
+          await this.scope.set(key, v)
+          landed.add(key)
+        } catch (e) {}
+      }
+      for (const [key, before] of pending) if (landed.has(key) && this.draft.get(key) === before) this.draft.delete(key)
+      this.saving = false
+      this.failed = landed.size !== pending.size
+      this.notify()
+    }
+  }
+
+  // 设置弹窗「会话流」分节：分组表单（左标签+说明，右数字输入），底部保存/放弃。
+  function SessionFlowSettingsSection(props) {
+    const controller = props.controller
+    const state = useSyncExternalStore((fn) => controller.subscribe(fn), () => controller.getSnapshot())
+    if (state.status !== 'ready') {
+      return h('div', { className: 'sfset-root' }, h('p', { className: 'sfset-unavailable' }, STR.setUnavailable))
+    }
+    const disabled = !state.writable || state.saving
+    const rows = []
+    for (const group of SETTING_GROUPS) {
+      rows.push(h('div', { key: group.titleKey, className: 'sfset-groupTitle' }, STR[group.titleKey]))
+      for (const key of group.fields) {
+        const spec = SETTING_FIELD_SPECS[key]
+        const field = state.fields[key]
+        rows.push(h('div', { key, className: 'sfset-row' + (field.invalid ? ' sfset-invalid' : '') },
+          h('div', { className: 'sfset-meta' },
+            h('div', { className: 'sfset-label' }, STR[spec.labelKey],
+              field.overridden ? h('span', { className: 'sfset-overridden' }, STR.setOverridden) : null),
+            h('div', { className: 'sfset-hint' }, STR[spec.hintKey])),
+          h('div', { className: 'sfset-controls' },
+            spec.kind === 'bool'
+              ? h('input', {
+                  className: 'sfset-check', type: 'checkbox',
+                  checked: field.text === 'true', disabled,
+                  onChange: (e) => controller.edit(key, String(e.target.checked)),
+                })
+              : h('input', {
+                  className: 'sfset-input', type: 'number',
+                  min: spec.min, max: spec.max, step: spec.integer ? 1 : 0.001,
+                  value: field.text, disabled,
+                  onChange: (e) => controller.edit(key, e.target.value),
+                }),
+            h('button', { type: 'button', className: 'sfset-reset', disabled, onClick: () => controller.resetField(key) }, STR.setReset))))
+      }
+    }
+    return h('div', { className: 'sfset-root' },
+      h('p', { className: 'sfset-desc' }, STR.settingsDesc),
+      rows,
+      h('div', { className: 'sfset-footer' },
+        h('button', { type: 'button', className: 'sfset-save', disabled: disabled || !state.dirty || state.invalid, onClick: () => { controller.save() } }, STR.setSave),
+        h('button', { type: 'button', className: 'sfset-discard', disabled: disabled || !state.dirty, onClick: () => controller.discard() }, STR.setDiscard),
+        state.invalid ? h('span', { className: 'sfset-error' }, STR.setInvalid) : null,
+        state.failed ? h('span', { className: 'sfset-error' }, STR.setSaveFail) : null))
+  }
+
+  // 取色对齐宠物设置卡（同一弹窗内经真机明暗/皮肤验证）：纯 dsw-alias 变量、
+  // 不写 hex 兜底——变量缺失时继承弹窗上下文色，硬编码兜底在皮肤主题下反而会撞色。
+  const SETTINGS_STYLE = [
+    `.sfset-root{padding:4px 2px;display:flex;flex-direction:column;max-width:560px}`,
+    `.sfset-desc{margin:0 0 10px;font-size:13px;line-height:1.5;color:var(--dsw-alias-label-tertiary)}`,
+    `.sfset-groupTitle{margin:14px 0 4px;font-size:13px;font-weight:600;line-height:1.5;color:var(--dsw-alias-label-primary);border-bottom:1px solid var(--dsw-alias-border-l2);padding-bottom:4px}`,
+    `.sfset-row{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:10px 0}`,
+    `.sfset-meta{min-width:0;flex:1}`,
+    `.sfset-label{font-size:13px;font-weight:500;line-height:1.5;color:var(--dsw-alias-label-primary);display:flex;align-items:center;gap:8px}`,
+    `.sfset-overridden{white-space:nowrap;background:var(--dsw-alias-bg-module-platform);color:var(--dsw-alias-label-secondary);border-radius:999px;padding:1px 8px;font-size:11px;font-weight:500;line-height:17px}`,
+    `.sfset-hint{font-size:12px;line-height:1.5;color:var(--dsw-alias-label-tertiary);margin-top:2px}`,
+    `.sfset-controls{flex:none;display:flex;align-items:center;gap:8px}`,
+    `.sfset-input{width:110px;height:34px;box-sizing:border-box;padding:0 12px;font:inherit;font-size:13px;line-height:1.5;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-3);color:var(--dsw-alias-label-primary)}`,
+    `.sfset-row.sfset-invalid .sfset-input{border-color:var(--dsw-alias-label-error)}`,
+    `.sfset-reset{font:inherit;font-size:12px;line-height:1.5;color:var(--dsw-alias-label-secondary);cursor:pointer;background:0 0;border:none;padding:0}`,
+    `.sfset-reset:hover:not(:disabled){color:var(--dsw-alias-label-primary)}`,
+    `.sfset-footer{display:flex;align-items:center;gap:8px;margin-top:16px;border-top:1px solid var(--dsw-alias-border-l2);padding-top:12px}`,
+    `.sfset-save{appearance:none;font:inherit;font-size:13px;line-height:1.5;cursor:pointer;border:1px solid #0000;border-radius:8px;padding:5px 14px;background:var(--dsw-alias-label-primary);color:var(--dsw-alias-bg-layer-3)}`,
+    `.sfset-save:disabled{opacity:.4;cursor:default}`,
+    `.sfset-discard{appearance:none;font:inherit;font-size:13px;line-height:1.5;cursor:pointer;border-radius:8px;padding:5px 14px;border:1px solid var(--dsw-alias-border-l2);background:0 0;color:var(--dsw-alias-label-secondary)}`,
+    `.sfset-discard:hover:not(:disabled){color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-label-dimmed)}`,
+    `.sfset-discard:disabled{opacity:.4;cursor:default}`,
+    `.sfset-error{font-size:12px;line-height:1.5;color:var(--dsw-alias-label-error)}`,
+    `.sfset-check{width:16px;height:16px;accent-color:var(--dsw-alias-label-primary);cursor:pointer}`,
+    `.sfset-unavailable{font-size:13px;line-height:1.5;color:var(--dsw-alias-state-warn-primary)}`,
+  ].join('\n')
+
   // ── 右侧导航图标（组件级共享，定义在顶层避免作用域问题）───────────
   // feather 风格线条，currentColor 自适应明暗主题、与文字同色。
   const NAV_ICON_USER = `<svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/><circle cx="12" cy="7" r="4"/></svg>`
@@ -136,6 +386,13 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
   // 这样 top 栏（flex:none + sticky）天然固定，不会随内容滚出视口。
   const STYLE = [
     `[data-pane=conversation]{position:relative}`,
+    `[class*=centerCol]{position:relative}`,
+    `.sf-rail-conclusion{margin-top:8px;padding-top:8px;border-top:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.25));font-size:12px;line-height:1.5;color:var(--dsw-alias-label-primary,#222)}`,
+    `.sf-turnMeta{display:flex;flex-wrap:wrap;gap:3px 10px;font-size:11px;font-weight:600;color:var(--dsw-alias-label-secondary,#555)}`,
+    `.sf-turnMetaChip{display:inline-flex;align-items:center;gap:3px}`,
+    `.sf-turnMetaChip.err{color:var(--dsw-alias-label-error,#d43b3b)}`,
+    `.sf-ico{display:inline-flex}`,
+    `.sf-rail-conclusionTools{margin-top:3px;font-size:11px;color:var(--dsw-alias-label-tertiary,#999);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}`,
     `${VIEW_SELECTOR}{z-index:60;background:var(--dsw-alias-bg-base,#fff);display:none!important;position:absolute;inset:0;overflow:hidden}`,
     `html[${ACTIVE_ATTR}]:not([data-dsh-taskboard-active]):not([data-dsh-ssh-active]) ${VIEW_SELECTOR}{display:block!important}`,
     `html[${ACTIVE_ATTR}]:not([data-dsh-taskboard-active]):not([data-dsh-ssh-active]) [data-pane=conversation]>:not(${VIEW_SELECTOR}),html[${ACTIVE_ATTR}]:not([data-dsh-taskboard-active]):not([data-dsh-ssh-active]) [class*=centerCol]>:not(${VIEW_SELECTOR}){display:none!important}`,
@@ -148,7 +405,13 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     `[data-dsh-frame][data-sidebar-collapsed] .sf-entryLabel{display:none}`,
     // box-sizing:border-box 必须：height:100% + padding 在 content-box 下会溢出容器，
     // 产生多余的整页滚动条，导致 top 栏随滚动消失（用户实测反馈）。
-    `.sf-view{box-sizing:border-box;background:var(--dsw-alias-bg-base,#fff);min-width:0;height:100%;min-height:0;color:var(--dsw-alias-label-primary,#222);font-family:var(--dsw-font-family,inherit);flex-direction:column;gap:10px;padding:14px 16px 16px;display:flex;overflow:hidden}`,
+    // T2 修复：flex:1 1 0（flex-basis 用绝对 0 长度，非 flex:1 的 0% 百分比）。
+    // 根因（诊断数据 d47b82bf 实测）：官方 viewArea 是 min-height:auto（聊天视图靠它
+    // 撑开内容 + 粘性输入框，不可全局强改）；flex:1 的 0% 基准在父级高度不定时被
+    // Chrome 按 content 处理 → .sf-view 假设尺寸=内容高 → viewArea 内容下限被顶高 →
+    // 溢出 scrollBody → 整块滚动。基准用绝对 0 → 假设尺寸=0 → viewArea 下限=0 →
+    // 回到 flex 分配空间，两列各自内部滚动。工作台模式父容器非 flex，flex 无效无害。
+    `.sf-view{box-sizing:border-box;background:var(--dsw-alias-bg-base,#fff);min-width:0;height:100%;flex:1 1 0;min-height:0;color:var(--dsw-alias-label-primary,#222);font-family:var(--dsw-font-family,inherit);flex-direction:column;gap:10px;padding:14px 16px 16px;display:flex;overflow:hidden}`,
     // top 栏悬浮固定：flex:none 在布局上已固定；再加 sticky + 背景双保险。
     `.sf-viewHeader{flex:none;position:sticky;top:0;z-index:1;background:var(--dsw-alias-bg-base,#fff);align-items:center;gap:10px;display:flex;flex-wrap:wrap}`,
     `.sf-viewTitle{color:var(--dsw-alias-label-primary,#222);white-space:nowrap;margin:0;font-size:16px;font-weight:700}`,
@@ -210,6 +473,9 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     `.sf-healthChip.hc-wait .sf-hcLabel{color:#a87b00}`,
     `.sf-healthChip.hc-stall .sf-hcBar{background:#d43b3b;animation:sfBadgePulse 2.8s ease-in-out infinite}`,
     `.sf-healthChip.hc-stall .sf-hcLabel{color:#d43b3b}`,
+    `.sf-healthChip.hc-idle .sf-hcBar{background:var(--dsw-alias-label-tertiary,#b8bcc4);opacity:.55}`,
+    `.sf-healthChip.hc-idle .sf-hcLabel{color:var(--dsw-alias-label-tertiary,#999)}`,
+    `.sf-healthChip.hc-idle:hover,.sf-healthChip.hc-idle:focus-visible{background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 72%,rgba(128,128,128,.12));border-color:color-mix(in srgb,var(--dsw-alias-border-l2,#e4e6eb) 60%,#9aa0a8)}`,
     `.sf-statsRow{display:flex;gap:12px;flex-wrap:wrap;margin-top:3px}`,
     `.sf-hint{color:var(--dsw-alias-label-secondary,#888);font-size:12px;padding:2px 2px 0}`,
     // ── 工作区筛选 tabs（独立一行，醒目）──
@@ -338,17 +604,26 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     `.sf-fulltextCount{flex:none;border-radius:999px;background:rgba(90,140,255,.15);color:#4a7dff;font-size:10px;line-height:15px;min-width:18px;text-align:center;padding:0 5px;font-weight:700}`,
     `.sf-fulltext .sf-muted{font-size:11px;color:var(--dsw-alias-label-secondary,#666)}`,
     // M12：详情并入右侧栏（details 槽位轻量视图）。
+    // 头部布局：标题+按钮**聚左**，spacer 吃掉右侧余量——彻底规避右上角
+    // dsh-better-sidebar toggleCluster（视口级常驻浮钮，压过官方 details 列右缘，
+    // 实测「退出并入」被压）。按钮不再进右上角浮动图标区，任何第三方浮钮都压不到。
     `.dk-root{box-sizing:border-box;height:100%;min-height:0;display:flex;flex-direction:column;gap:8px;padding:10px 12px;overflow:hidden;color:var(--dsw-alias-label-primary,#222);font-family:var(--dsw-font-family,inherit)}`,
-    `.dk-head{flex:none;display:flex;align-items:center;gap:8px;min-width:0}`,
-    `.dk-title{flex:1;min-width:0;font-size:13px;font-weight:700;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}`,
-    `.dk-btn{flex:none;border:1px solid var(--dsw-alias-border-l2,#ddd);background:var(--dsw-alias-bg-layer-1,#f5f5f5);color:var(--dsw-alias-label-primary,#222);border-radius:7px;padding:3px 9px;font-size:11px;cursor:pointer}`,
+    `.dk-head{flex:none;display:flex;align-items:center;flex-wrap:wrap;gap:8px;min-width:0}`,
+    `.dk-title{flex:none;min-width:0;font-size:13px;font-weight:700;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:40%}`,
+    `.dk-headSpacer{flex:1 1 auto;min-width:0;align-self:stretch;pointer-events:none}`,
+    `.dk-btn{flex:none;border:1px solid var(--dsw-alias-border-l2,#ddd);background:var(--dsw-alias-bg-layer-1,#f5f5f5);color:var(--dsw-alias-label-primary,#222);border-radius:7px;padding:3px 9px;font-size:11px;cursor:pointer;white-space:nowrap}`,
     `.dk-btn:hover{border-color:var(--dsw-alias-brand-primary,#4a7dff);color:var(--dsw-alias-brand-primary,#4a7dff)}`,
+    // T6：dock 实时开关激活态（绿色语义，与详情页 sf-liveBar 同色系）。
+    `.dk-btn.dk-btnLive{border-color:rgba(28,158,90,.5);background:rgba(28,158,90,.08);color:#1c9e5a;font-weight:600}`,
     `.dk-body{flex:1;min-height:0;overflow:auto;display:flex;flex-direction:column;gap:6px}`,
     `.dk-summary{border:1px solid var(--dsw-alias-border-l2,#e4e6eb);border-radius:10px;padding:8px 10px;background:var(--dsw-alias-bg-layer-1,#f8f9fa);flex:none;display:flex;flex-direction:column;gap:4px}`,
     `.dk-summaryRow{display:flex;gap:6px;font-size:11.5px;line-height:1.5;color:var(--dsw-alias-label-secondary,#666);min-width:0}`,
     `.dk-summaryTag{flex:none;border-radius:5px;padding:0 5px;font-size:10px;line-height:16px;font-weight:700;background:rgba(90,140,255,.12);color:#4a7dff}`,
     `.dk-summaryText{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}`,
     `.dk-summaryFull{font-size:12px;line-height:1.6;color:var(--dsw-alias-label-primary,#222);white-space:pre-wrap;word-break:break-word;max-height:140px;overflow:auto}`,
+    // T8-B 钉住提示条：琥珀色警示（直播会话 ≠ 当前会话）。
+    `.dk-pinBar{flex:none;display:flex;align-items:center;gap:8px;padding:5px 8px;border:1px solid rgba(224,150,63,.45);background:rgba(224,150,63,.08);border-radius:8px}`,
+    `.dk-pinText{flex:1;min-width:0;font-size:12px;color:#c07a2a}`,
     // M12：并入期间禁用 layout grid 列宽过渡——官方会话切换会 closeDetails（宽 360→0），
     // 守护重开（0→360）若带过渡动画会产生「关→开」闪烁；禁用后切换直接刷新内容（实测踩坑）。
     `html[data-dsh-dock-active] [class*=frame],html[data-dsh-dock-active] [data-side=details]{transition:none!important}`,
@@ -393,41 +668,80 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     // 垂直居中悬浮于会话内容区中间（top 由组件算区中心 + translateY(-50%)）。
     // 动画体系：一切组件的产生/消失都有「来源与目标」——display 硬切全部改为
     // transform/opacity/max-height 过渡（实测踩坑：display 切换无动画、视觉突兀）。
-    `[data-dsh-piano-keys]{position:fixed;left:0;top:50%;width:32px;max-height:60vh;z-index:15;display:flex;flex-direction:column;font-family:var(--dsw-font-family,inherit);transition:width .26s cubic-bezier(.3,1.15,.4,1) .22s}`,
-    // 收拢时序：离开时宽度过渡延迟 .22s——信息面板先滑出（.24s），悬浮条主体再收拢
-    // （用户要求：收拢第一步先收起详情信息框）；进入（hover/focus）无延迟即时展开。
-    `[data-dsh-piano-keys]:hover,[data-dsh-piano-keys]:focus-within{width:200px;transition-delay:0s}`,
+    `[data-dsh-piano-keys]{position:fixed;left:0;top:50%;width:32px;max-height:60vh;z-index:15;display:flex;flex-direction:column;padding:0 0 8px;font-family:var(--dsw-font-family,inherit);transition:width .26s cubic-bezier(.3,1.15,.4,1)}`,
+    // 收拢时序（T4）：宽度与条目高度（.pk-key .22s）**同时起跑**——用户要求纵向横向
+    // 同时收拢（此前宽度延迟 .22s 造成「先纵后横」两段式）；详情信息框仍先行立即
+    // 滑出（.pk-detail.hidden 无延迟），不参与纵向节奏。进入（hover/focus）同态：
+    // 无延迟即时展开，收拢=展开的倒放。
+    // 收拢锁（collapse-lock）：pointerleave 后 300ms 内抑制 :hover 展开（focus-within 不受影响）。
+    // 日志实锤的几何自反馈回路：展开态越界 → 整条收拢（几何瞬变）→ 收拢后的胶囊条
+    // 「弹到」静止鼠标下方 → 合成 mouseenter → :hover 重新展开 → 再越界……每 300-500ms
+    // 一个来回（「横条反复出现消失」）。锁窗内 :hover 不展开，回路断开；真实驻留 300ms
+    // 后正常展开（顺带构成驻留去抖：快速掠过不再闪开）。
+    `[data-dsh-piano-keys]:not([data-collapse-lock]):hover,[data-dsh-piano-keys]:focus-within{width:200px;transition-delay:0s}`,
     `html[${ACTIVE_ATTR}] [data-dsh-piano-keys]{display:none!important}`,
-    `.pk-strip{flex:1;min-height:0;max-height:calc(60vh - 60px);overflow-y:auto;overflow-x:hidden;display:flex;flex-direction:column;gap:5px;padding:8px 4px;scrollbar-width:none;outline:none}`,
-    `.pk-strip::-webkit-scrollbar{display:none}`,
+    // T5：strip 高度 JS 显式管理（setStripHeight：可见行数 × 实测行距 + 上下内边距
+    // 16 − 间隙 5；收拢/展开键高动画期间 RO 逐帧跟随）——clipper 是 absolute 脱流，
+    // strip 不能再靠内容撑高（实测塌缩整条消失）。**必须 flex:1 1 auto**（basis:auto
+    // 时 height 属性才是弹性基准；flex:1 = basis 0% 会架空 JS height——实测踩坑）。
+    // shrink 保留配合 60vh 硬上限压缩。裁剪面=pk-clip（absolute inset:0 = strip
+    // 【内容盒】）：CSS overflow 裁剪在内边距盒——上下缓冲键各露 3px 进内边距带
+    // （「上面会话的下边框露出一点点」实测踩坑）；clipper 把可见区收到恰好 12 行。
+    // 垂直呼吸全部移出 strip：标题行下边距 8 + 根容器下内边距 8（均静止件）；
+    // strip 零 padding——绝对定位 clipper 的 inset:0 解析的是【padding box】而非
+    // 内容盒，padding 留在 strip 上不参与裁剪、键却从 y=0 起排画进 padding 带
+    // （顶键贴死标题行、底部框线被裁——实测踩坑）。strip 高度=纯内容 rows×pitch−5。
+    `.pk-strip{flex:1 1 auto;min-height:0;max-height:calc(60vh - 60px);position:relative;outline:none}`,
+    `.pk-clip{position:absolute;inset:0;overflow:hidden}`,
+    // 键挂 pk-list 上；transform 由 JS 逐帧驱动（rAF 追逐 scrollPos + 实测行距，
+    // renderStart 离散跳变时同步重设——CSS transition 会把内容重排的跳变也做成
+    // 动画，每滚一行顿一次，实测踩坑）。
+    // 垂直内边距在 strip（静止件）不在 list（移动件）：padding 挂移动件会随
+    // transform 平移，键从 y=8 起排 → 缓冲键底边 +3px 露出裁剪线（实测踩坑）。
+    `.pk-list{display:flex;flex-direction:column;gap:5px;padding:0 4px;will-change:transform}`,
     // 收拢态：短横条（胶囊线）；overflow:hidden 使 label 文字被高度裁剪（来源=胶囊）；
     // ::before 延伸命中区（±4px，点击/悬浮无死区）。
-    `.pk-key{position:relative;flex:none;height:4px;min-height:4px;border-radius:99px;border:none;cursor:pointer;padding:0;margin:0 4px;background:var(--dsw-alias-border-l2,#d7dae0);color:var(--dsw-alias-label-primary,#222);overflow:hidden;transition:height .22s ease,padding .22s ease,margin .22s ease,border-radius .22s ease,background .14s ease,border-color .14s ease,box-shadow .18s ease;outline:none;min-width:0}`,
+    // T4 二阶段：box-sizing:border-box + 确定高度（4px↔30px）——原展开态 height:auto
+    // 不可插值（日志实锤：全程无 height 过渡事件），高度在两态间瞬移 120↔408px，
+    // 收拢条边缘 hover 进出即整条几何反复跳变（用户实测「闪烁抽搐」）。
+    `.pk-key{position:relative;flex:none;box-sizing:border-box;height:4px;min-height:4px;border-radius:99px;border:none;cursor:pointer;padding:0;margin:0 4px;background:var(--dsw-alias-border-l2,#d7dae0);color:var(--dsw-alias-label-primary,#222);overflow:hidden;transition:height .22s ease,padding .22s ease,margin .22s ease,border-radius .22s ease,background .14s ease,border-color .14s ease,box-shadow .18s ease;outline:none;min-width:0}`,
     `.pk-key::before{content:'';position:absolute;left:0;right:0;top:-4px;bottom:-4px}`,
+    // 热区填满死区（三日志轮实锤症状一）：strip 上下内边距 8px 只有 ::before ±4px 覆盖，
+    // 标题行/首键之间残留 4px 死区——鼠标停进去 key[0] 高亮+详情面板熄灭，跨出又点亮，
+    // 窄带内反复横跳=「横条出现消失」。首/末键 ::before 精确补到 strip 边缘（-8px），
+    // 带内任意位置都算 hover 该键，高亮/面板稳定常驻；键间隙 5px 由相邻 ±4px 互叠已全覆盖。
+    `.pk-key:first-child::before{top:-8px}`,
+    `.pk-key:last-child::before{bottom:-8px}`,
     `.pk-key:hover{background:var(--dsw-alias-brand-primary,#4a7dff)}`,
     `.pk-key:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#4a7dff);outline-offset:-1px}`,
     `.pk-keyActive{background:var(--dsw-alias-brand-primary,#4a7dff)}`,
     `.pk-keyFocus{background:var(--dsw-alias-brand-primary,#4a7dff)}`,
     // 展开态（悬浮/聚焦）：条目变文字卡片；label 常驻（缩略态被条目高度裁剪），
     // 展开时随高度过渡露出文字（来源=胶囊内部，目标=卡片全文）。
-    `[data-dsh-piano-keys]:hover .pk-key,[data-dsh-piano-keys]:focus-within .pk-key{display:flex;align-items:center;gap:6px;height:auto;min-height:28px;border-radius:10px;border:1px solid var(--dsw-alias-border-l2,#e4e6eb);padding:5px 8px;margin:0;background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 80%,transparent);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);box-shadow:0 1px 3px rgba(0,0,0,.07)}`,
-    `[data-dsh-piano-keys]:hover .pk-key:hover,[data-dsh-piano-keys]:focus-within .pk-key:hover{background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 96%,transparent);border-color:var(--dsw-alias-brand-primary,#4a7dff)}`,
-    `[data-dsh-piano-keys]:hover .pk-keyActive,[data-dsh-piano-keys]:focus-within .pk-keyActive{border-color:var(--dsw-alias-brand-primary,#4a7dff);background:color-mix(in srgb,var(--dsw-alias-brand-primary,#4a7dff) 10%,var(--dsw-alias-bg-base,#fff))}`,
+    // T4 二阶段：height:auto → height:30px（label 18 + padding 10 + border 2 = 原自然
+    // 高度，最终几何不变）——确定长度可插值，与收拢态 4px 平滑互转（倒放对称）。
+    `[data-dsh-piano-keys]:not([data-collapse-lock]):hover .pk-key,[data-dsh-piano-keys]:focus-within .pk-key{display:flex;align-items:center;gap:6px;height:30px;min-height:30px;border-radius:10px;border:1px solid var(--dsw-alias-border-l2,#e4e6eb);padding:5px 8px;margin:0;background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 80%,transparent);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);box-shadow:0 1px 3px rgba(0,0,0,.07)}`,
+    // 热区链（四日志轮定位症状一）：head↔gap↔首键 必须连续同态，否则边界 1px 晃动
+    // 即反复点亮/熄灭首键高亮（横条出现消失）。gap 由首键 ::before 覆盖（上文），
+    // head 由下行选择器链到首键：hover 标题行 ≡ hover 第一个键。
+    `[data-dsh-piano-keys]:not([data-collapse-lock]):hover .pk-key:hover,[data-dsh-piano-keys]:focus-within .pk-key:hover,[data-dsh-piano-keys]:not([data-collapse-lock]):hover .pk-head:hover ~ .pk-strip .pk-key:first-child{background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 96%,transparent);border-color:var(--dsw-alias-brand-primary,#4a7dff)}`,
+    `[data-dsh-piano-keys]:not([data-collapse-lock]):hover .pk-keyActive,[data-dsh-piano-keys]:focus-within .pk-keyActive{border-color:var(--dsw-alias-brand-primary,#4a7dff);background:color-mix(in srgb,var(--dsw-alias-brand-primary,#4a7dff) 10%,var(--dsw-alias-bg-base,#fff))}`,
     `.pk-label{flex:1;min-width:0;font-size:12px;line-height:18px;max-height:18px;color:var(--dsw-alias-label-primary,#222);overflow:hidden;text-overflow:ellipsis;white-space:nowrap;user-select:none;opacity:0;transition:opacity .18s ease .06s}`,
-    `[data-dsh-piano-keys]:hover .pk-label,[data-dsh-piano-keys]:focus-within .pk-label{opacity:1}`,
+    `[data-dsh-piano-keys]:not([data-collapse-lock]):hover .pk-label,[data-dsh-piano-keys]:focus-within .pk-label{opacity:1}`,
     // 轮次序号：缩略态折叠（宽度 0 + 透明），展开态从左侧展开露出（来源=左缘）。
     `.pk-turnNo{flex:none;width:0;min-width:0;overflow:hidden;opacity:0;text-align:left;font-size:9.5px;line-height:16px;font-weight:600;color:var(--dsw-alias-label-tertiary,#999);font-family:ui-monospace,Consolas,monospace;user-select:none;white-space:nowrap;transition:width .22s ease,opacity .16s ease .04s}`,
-    `[data-dsh-piano-keys]:hover .pk-turnNo,[data-dsh-piano-keys]:focus-within .pk-turnNo{width:28px;min-width:28px;opacity:1}`,
+    `[data-dsh-piano-keys]:not([data-collapse-lock]):hover .pk-turnNo,[data-dsh-piano-keys]:focus-within .pk-turnNo{width:28px;min-width:28px;opacity:1}`,
     // hover 条目：在【该条目右侧】展开信息面板（.pk-detail）——absolute 相对悬浮条容器，
     // 坐标按条目位置换算为容器内偏移（注意：容器有 transform:translateY(-50%)，fixed 子元素
     // 会被 transform 祖先劫持成相对容器定位——用视口坐标会双重偏移，实测踩坑）。
-    `[data-dsh-piano-keys]:hover .pk-key:hover,[data-dsh-piano-keys]:focus-within .pk-key.pk-keyFocus{position:relative;z-index:2;box-shadow:0 4px 16px rgba(0,0,0,.18)}`,
+    `[data-dsh-piano-keys]:not([data-collapse-lock]):hover .pk-key:hover,[data-dsh-piano-keys]:focus-within .pk-key.pk-keyFocus,[data-dsh-piano-keys]:not([data-collapse-lock]):hover .pk-head:hover ~ .pk-strip .pk-key:first-child{position:relative;z-index:2;box-shadow:0 4px 16px rgba(0,0,0,.18)}`,
     // 展开时序：详情框延迟 .28s 再滑入——等悬浮条展开动画完成、条目就位后，
     // 位置才准确（第一次展开时条目仍在变形，立即计算会错位，实测踩坑）；
     // 隐藏则立即（无延迟）。
     `.pk-detail{position:absolute;left:0;top:0;width:264px;max-height:calc(60vh - 40px);display:flex;flex-direction:column;gap:6px;background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 76%,transparent);backdrop-filter:blur(14px);-webkit-backdrop-filter:blur(14px);border:1px solid var(--dsw-alias-border-l2,#e4e6eb);border-radius:12px;box-shadow:0 8px 28px rgba(0,0,0,.18);padding:10px 12px;z-index:6;overflow:hidden;opacity:1;transform:translateX(0);transition:opacity .18s ease .28s,transform .24s cubic-bezier(.25,1.1,.4,1) .28s,visibility .24s .28s}`,
     `.pk-detail.hidden{opacity:0;transform:translateX(14px);visibility:hidden;pointer-events:none;transition:opacity .18s ease,transform .24s cubic-bezier(.25,1.1,.4,1),visibility .24s}`,
     `.pk-detailHead{flex:none;font-size:10.5px;font-weight:700;color:var(--dsw-alias-label-secondary,#666);font-family:ui-monospace,Consolas,monospace;letter-spacing:.2px}`,
+    `.pk-detailMeta{flex:none;margin:3px 0 2px}`,
     // 面板内容随条目切换：新内容从右轻滑入（key 变化重新挂载触发 animation）。
     `.pk-detailBody{min-height:0;font-size:12.5px;line-height:1.6;color:var(--dsw-alias-label-primary,#222);white-space:pre-wrap;word-break:break-word;overflow-y:auto;max-height:320px;animation:pkSlideIn .22s ease}`,
     `@keyframes pkSlideIn{from{opacity:0;transform:translateX(10px)}to{opacity:1;transform:translateX(0)}}`,
@@ -436,14 +750,10 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     `.pk-status{position:absolute;left:0;right:0;top:calc(100% + 4px);padding:7px 10px;border-radius:8px;background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 82%,transparent);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border:1px solid var(--dsw-alias-border-l2,#e4e6eb);font-size:11px;line-height:1.5;color:var(--dsw-alias-label-secondary,#666);box-shadow:0 4px 14px rgba(0,0,0,.12);z-index:6;text-align:center;white-space:normal;word-break:break-word;opacity:1;transform:translateY(0);transition:opacity .18s ease,transform .22s ease,visibility .22s}`,
     `.pk-status.hidden{opacity:0;transform:translateY(8px);visibility:hidden;pointer-events:none}`,
     `.pk-status.warn{color:#d97706;border-color:rgba(217,119,6,.4)}`,
-    // 展开态显示悬浮条细滚动条（缩略态保持无滚动条）。
-    `[data-dsh-piano-keys]:hover .pk-strip,[data-dsh-piano-keys]:focus-within .pk-strip{scrollbar-width:thin;scrollbar-color:var(--dsw-alias-border-l2,#d7dae0) transparent}`,
-    `[data-dsh-piano-keys]:hover .pk-strip::-webkit-scrollbar,[data-dsh-piano-keys]:focus-within .pk-strip::-webkit-scrollbar{width:6px;display:block}`,
-    `[data-dsh-piano-keys]:hover .pk-strip::-webkit-scrollbar-thumb{background:var(--dsw-alias-border-l2,#d7dae0);border-radius:3px}`,
     // 头部：从上方滑入（来源=悬浮条顶缘）——max-height/padding/opacity/transform 过渡，
     // 不占缩略态布局。内容「标题 + ▲▼ 按钮组（并排右上）」。
-    `.pk-head{display:flex;flex:none;align-items:center;gap:4px;padding:0 6px;color:var(--dsw-alias-label-secondary,#666);font-size:10px;line-height:1.2;border-bottom:1px solid var(--dsw-alias-border-l2,#e5e5e5);max-height:0;overflow:hidden;opacity:0;transform:translateY(-6px);transition:max-height .24s ease,padding .24s ease,opacity .18s ease,transform .24s ease}`,
-    `[data-dsh-piano-keys]:hover .pk-head,[data-dsh-piano-keys]:focus-within .pk-head{max-height:30px;padding-top:5px;padding-bottom:5px;opacity:1;transform:translateY(0)}`,
+    `.pk-head{display:flex;flex:none;align-items:center;gap:4px;padding:0 6px;margin-bottom:8px;color:var(--dsw-alias-label-secondary,#666);font-size:10px;line-height:1.2;border-bottom:1px solid var(--dsw-alias-border-l2,#e5e5e5);max-height:0;overflow:hidden;opacity:0;transform:translateY(-6px);transition:max-height .24s ease,padding .24s ease,opacity .18s ease,transform .24s ease}`,
+    `[data-dsh-piano-keys]:not([data-collapse-lock]):hover .pk-head,[data-dsh-piano-keys]:focus-within .pk-head{max-height:30px;padding-top:5px;padding-bottom:5px;opacity:1;transform:translateY(0)}`,
     `.pk-headLabel{flex:1;min-width:0;font-size:10.5px;font-weight:600;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}`,
     `.pk-navGroup{flex:none;display:flex;gap:3px}`,
     `.pk-navBtn{flex:none;width:20px;height:20px;border:1px solid var(--dsw-alias-border-l2,#ddd);background:var(--dsw-alias-bg-layer-1,#f5f5f5);color:var(--dsw-alias-label-primary,#222);border-radius:6px;cursor:pointer;font-size:9px;line-height:1;padding:0;transition:border-color .14s ease,color .14s ease}`,
@@ -604,6 +914,79 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
   }
   const canOfficialRename = (conn) =>
     conn !== undefined && conn.api !== undefined && conn.api.sessions !== undefined && typeof conn.api.sessions.rename === 'function'
+  // ── v0.1.2 兼容（三）：session RPC 双面适配器 ─────────────────────
+  // 新面：ctx.remote.session.*（inject 需声明 remote/remote.session，否则代理抛
+  // 「cannot get property remote.session without inject」）；信封顶层 {ok,value}；
+  // history 改名 page({address, maxMessages,...}) → {records, hasMore}；rename/list
+  // 仍在。旧面：connection.api.sessions.*（{result:{ok,value}}；subagents.history）。
+  // apply 时探测（ctx.get('remote') 旧宿主抛错 → 回退旧面）。
+  const sfRemoteRef = { current: null }
+  const sfBuildRemote = (ctx, connection) => {
+    try {
+      const remote = ctx && typeof ctx.get === 'function' ? ctx.get('remote') : null
+      const sess = remote && remote.session
+      if (sess && typeof sess.page === 'function') {
+        // 宿主硬校验：throughSeq > 日志 cursor 直接 gateway/bad-request——不存在
+        // 「取最新」的大数哨兵。cursor 来源 = list items[].projections.asOfSeq
+        //（投影截至 seq，恒 ≤ 真实日志 cursor，安全）。2s TTL 缓存防探测并发打爆 list。
+        let listCache = null
+        const cursorOf = async (sessionId) => {
+          const now = Date.now()
+          if (listCache === null || now - listCache.at > 2000) {
+            const r = await sess.list({})
+            listCache = { at: now, items: r && r.ok && r.value && Array.isArray(r.value.items) ? r.value.items : [] }
+          }
+          const it = listCache.items.find((x) => x.sessionId === sessionId)
+          return it && it.projections && typeof it.projections.asOfSeq === 'number' ? it.projections.asOfSeq : -1
+        }
+        return {
+          kind: 'remote',
+          async pageBySession(sessionId, maxMessages) {
+            const throughSeq = await cursorOf(sessionId)
+            if (throughSeq < 0) return undefined
+            const r = await sess.page({ address: { kind: 'session', sessionId }, throughSeq, maxMessages })
+            return r && r.ok ? r.value : undefined
+          },
+          async pageBySub(parentSessionId, childSessionId, mode, maxMessages) {
+            const throughSeq = await cursorOf(childSessionId)
+            if (throughSeq < 0) return undefined
+            const r = await sess.page({ address: { kind: 'subagent', parentSessionId, childSessionId, mode }, throughSeq, maxMessages })
+            return r && r.ok ? r.value : undefined
+          },
+          async listSessions() { if (typeof sess.list !== 'function') return undefined; const r = await sess.list({}); return r && r.ok ? r.value : undefined },
+          canRename: typeof sess.rename === 'function',
+          async rename(sessionId, title) { const r = await sess.rename({ sessionId, title }); return r && r.ok && r.value && typeof r.value.title === 'string' ? r.value.title : undefined },
+        }
+      }
+    } catch (e) {}
+    if (connection && connection.api && connection.api.sessions && typeof connection.api.sessions.history === 'function') {
+      const envVal = (r) => (r && r.result && r.result.ok ? r.result.value : (r && r.ok ? r.value : undefined))
+      return {
+        kind: 'legacy',
+        async pageBySession(sessionId, maxMessages) { return envVal(await connection.api.sessions.history({ sessionId, maxMessages })) },
+        async pageBySub(parentSessionId, childSessionId, mode, maxMessages) { return envVal(await connection.api.subagents.history({ parentSessionId, childSessionId, mode, maxMessages })) },
+        async listSessions() { return envVal(await connection.api.sessions.list({})) },
+        canRename: canOfficialRename(connection),
+        async rename(sessionId, title) { const t = await renameViaOfficial(connection, sessionId, title).catch(() => undefined); return t },
+      }
+    }
+    return null
+  }
+  // v0.1.2 兼容（一）：sessions.history 返回值从 {events} 改为 {records, hasMore}
+  //（记录 = {type:'event', event} 或 chunk 行 {type:'chunks', event:{type:'chunkrow/…'}}）。
+  // 旧版 {events} 每项亦可能包 {event}。统一解析为事件数组；丢弃 chunkrow 合成
+  // 事件（derive 只认真实事件类型，混入会污染分类）。全部 6 个消费点共用。
+  const historyEventsOf = (val) => {
+    if (!val) return []
+    const list = Array.isArray(val.events) ? val.events : (Array.isArray(val.records) ? val.records : [])
+    const out = []
+    for (const r of list) {
+      const e = (r && r.event) || r
+      if (!e || typeof e.type !== 'string' || e.type.startsWith('chunkrow/')) continue
+      out.push(e)
+    }
+    return out
+  }
   /** 静默时长文本（{N} 占位）。 */
   const fmtSilent = (idleMs) => {
     if (idleMs === null || idleMs === undefined) return ''
@@ -612,6 +995,16 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       ? STR.healthSilentMin.replace('{N}', String(min))
       : STR.healthSilentSec.replace('{N}', String(Math.max(1, Math.round(idleMs / 1000))))
   }
+  /** 相对时间文本（空闲胶囊「N 分钟前」；分钟粒度足够，不追秒级新鲜度）。 */
+  const fmtAgo = (ms) => {
+    if (!ms || ms < 0) return ''
+    const min = Math.floor(ms / 60000)
+    if (min < 1) return STR.agoJustNow
+    if (min < 60) return STR.agoMin.replace('{N}', String(min))
+    const h = Math.floor(min / 60)
+    if (h < 24) return STR.agoHour.replace('{N}', String(h))
+    return STR.agoDay.replace('{N}', String(Math.floor(h / 24)))
+  }
   /** 健康徽标（详情实时条 / 总览卡片共用）；active/ended/unknown 不渲染（已有进行中/已结束徽标）。 */
   const healthBadge = (health) => {
     if (!health) return null
@@ -622,24 +1015,41 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     return null
   }
 
-  // ── 会话页头部健康芯片（官方 conversation.session.header.actions 槽位）──
+  // ── 会话页头部健康胶囊（官方 conversation.session.header.actions 槽位）──
   // 位置：官方模式标识（agent-preset label, order -10）右侧（order -9）。
-  // 数据：sessions.list 快照跟踪 running（官方真实状态，随 host 流即时翻转）→
-  // running 时 10s 轮询 tail history → host derive 健康分类（与总览探测同管线）。
+  // 常驻四态（用户需求 2026-09-05：非运行也展示）：
+  //   空闲（灰条 +「N 分钟前」相对时间，零 RPC，来自 byId.updatedAt）
+  //   运行·活跃（绿）/ 运行·工具执行中·静默中（黄）/ 运行·疑似卡死（红，脉冲）
+  //   —— 运行时 10s 轮询 tail history → host derive 健康分类；probe 未返回前
+  //   乐观显示「活跃」（避免胶囊闪烁）。空白新会话不显示。
   // 点击：唤起会话流工作台并直达该会话详情（workbenchBridge 意图桥）。
+  // 槽位 props 兜底：v0.1.2 若 sessionId 标准 prop 管道变化，退回 sessions.list
+  // 快照的 current（头部胶囊面对的就是当前会话）。
+  const currentSessionIdOf = (sessions) => {
+    try {
+      const snap = sessions && sessions.list && typeof sessions.list.getSnapshot === 'function' ? sessions.list.getSnapshot() : null
+      return snap && snap.current ? snap.current : undefined
+    } catch (e) { return undefined }
+  }
+  // 【临时诊断】chipDbg 已于 v1.3.0 验收后撤除；probe error 静默（与总览探测同口径）。
   function SessionHealthChip(props) {
-    const { sessionId, connection, sessions } = props
+    const { connection, sessions } = props
+    const sid = props.sessionId || currentSessionIdOf(sessions)
+    const sessionId = sid
     const [running, setRunning] = useState(false)
+    const [meta, setMeta] = useState({ updatedAt: 0, blank: false })
     const [health, setHealth] = useState(null)
     useEffect(() => {
       if (!sessionId || !sessions || !sessions.list || typeof sessions.list.getSnapshot !== 'function') return undefined
       const compute = () => {
         try {
-          // sessions.list 快照 = { ids, current, byId }（byId[id] 含 running）——
-          // 不是 { items }（那是 workspace 浏览器用的另一个视图快照，曾误用导致芯片恒 null）。
+          // sessions.list 快照 = { ids, current, byId }（byId[id] 含 running/updatedAt/blank）。
           const snap = sessions.list.getSnapshot()
           const it = snap && snap.byId ? snap.byId[sessionId] : undefined
           setRunning(it ? it.running === true : false)
+          const u = it && typeof it.updatedAt === 'number' ? it.updatedAt : 0
+          const b = it ? it.blank === true : false
+          setMeta((prev) => (prev.updatedAt === u && prev.blank === b ? prev : { updatedAt: u, blank: b }))
         } catch (e) { setRunning(false) }
       }
       compute()
@@ -647,13 +1057,12 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       return undefined
     }, [sessions, sessionId])
     useEffect(() => {
-      if (!running || !sessionId || !canOfficialRename(connection)) { setHealth(null); return undefined }
+      if (!running || !sessionId || !sfRemoteRef.current) { setHealth(null); return undefined }
       let alive = true
       const probe = async () => {
         try {
-          const hr = await connection.api.sessions.history({ sessionId, maxMessages: 3 })
-          const val = hr && hr.result && hr.result.value
-          const events = val && Array.isArray(val.events) ? val.events.map((e) => (e && e.event) || e) : []
+          const val = await sfRemoteRef.current.pageBySession(sessionId, 3)
+          const events = historyEventsOf(val)
           if (events.length === 0) { if (alive) setHealth(null); return }
           const d = await api('derive', { events, now: Date.now(), assumeRunning: true })
           if (alive && d && d.ok) setHealth(d.health || null)
@@ -663,22 +1072,61 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       const iv = setInterval(probe, 10000)
       return () => { alive = false; clearInterval(iv) }
     }, [running, sessionId, connection])
-    if (!running || !health) return null
-    const kind = health.kind
-    const silent = fmtSilent(health.idleMs)
-    // 收拢态胶囊条颜色语义：绿=活跃 / 黄=工具执行中·静默中 / 红=疑似卡死（脉冲）。
-    let text = STR.healthActive, cls = 'hc-active'
-    if (kind === 'tool-wait') { text = STR.healthToolWait; cls = 'hc-wait' }
-    else if (kind === 'quiet') { text = STR.healthQuiet; cls = 'hc-wait' }
-    else if (kind === 'stalled') { text = STR.healthStalled; cls = 'hc-stall' }
-    else if (kind !== 'active') return null // ended/unknown 不显示
+    // 空闲态每 30s 轻 tick 一次，驱动「N 分钟前」相对时间保鲜。
+    const [, setTick] = useState(0)
+    useEffect(() => {
+      if (running) return undefined
+      const iv = setInterval(() => setTick((n) => n + 1), 30000)
+      return () => clearInterval(iv)
+    }, [running])
+    // 空闲计时基准 = 最后一条事件的 time（= 会话结束时刻）。byId.updatedAt 是
+    // 「列表投影上次变化」时间戳——运行中投影值不变就停在上次用户消息，语义不对
+    //（用户实测裁定）。空闲期间该时刻不再变化 → 会话切入空闲时拉一次即可。
+    const [idleSince, setIdleSince] = useState(0)
+    useEffect(() => {
+      if (running || !sessionId || !sfRemoteRef.current) { setIdleSince(0); return undefined }
+      let alive = true
+      ;(async () => {
+        try {
+          const val = await sfRemoteRef.current.pageBySession(sessionId, 3)
+          const events = historyEventsOf(val)
+          const last = events.length > 0 ? events[events.length - 1] : null
+          const t = last && typeof last.time === 'number' ? last.time : 0
+          if (alive) setIdleSince(t)
+        } catch (e) { if (alive) setIdleSince(0) }
+      })()
+      return () => { alive = false }
+    }, [running, sessionId])
+    if (!sessionId) return null
+    // 空闲常驻态：灰条 + 「距最后事件」相对时间。空白新会话不显示（避免噪音）。
+    if (!running) {
+      if (meta.blank) return null
+      const ago = idleSince > 0 ? fmtAgo(Date.now() - idleSince) : ''
+      return h('button', {
+        className: 'sf-healthChip hc-idle',
+        title: STR.healthChipTitle,
+        onClick: (e) => { e.stopPropagation(); if (props.onOpen) props.onOpen() },
+      },
+        h('span', { className: 'sf-hcBar' }),
+        h('span', { className: 'sf-hcLabel' }, STR.healthIdle + (ago ? ' · ' + ago : '')),
+      )
+    }
+    // 运行态：probe 未返回前乐观显示「活跃」（防闪烁）；derive ended/unknown 亦按活跃渲染。
+    let text = STR.healthActive, cls = 'hc-active', silent = ''
+    if (health) {
+      const kind = health.kind
+      silent = fmtSilent(health.idleMs)
+      if (kind === 'tool-wait') { text = STR.healthToolWait; cls = 'hc-wait' }
+      else if (kind === 'quiet') { text = STR.healthQuiet; cls = 'hc-wait' }
+      else if (kind === 'stalled') { text = STR.healthStalled; cls = 'hc-stall' }
+    }
     return h('button', {
       className: 'sf-healthChip ' + cls,
       title: STR.healthChipTitle,
       onClick: (e) => { e.stopPropagation(); if (props.onOpen) props.onOpen() },
     },
       h('span', { className: 'sf-hcBar' }),
-      h('span', { className: 'sf-hcLabel' }, text + (silent && kind !== 'active' ? ' · ' + silent : '')),
+      h('span', { className: 'sf-hcLabel' }, text + (silent && cls !== 'hc-active' ? ' · ' + silent : '')),
     )
   }
 
@@ -744,8 +1192,9 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         const target = all.find((x) => x.id === sid)
         if (target && target.titleSource === 'user') return Promise.reject(new Error(STR.renameClearBlocked))
       }
-      if (trimmed !== '' && canOfficialRename(conn)) {
-        return renameViaOfficial(conn, sid, trimmed)
+      if (trimmed !== '' && sfRemoteRef.current && sfRemoteRef.current.canRename) {
+        return sfRemoteRef.current.rename(sid, trimmed)
+          .then((accepted) => { if (typeof accepted !== 'string') throw new Error(STR.renameFail); return accepted })
           .then((accepted) => applyLocal(accepted))
           .catch(() => legacy())
       }
@@ -757,16 +1206,15 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     const [healthMap, setHealthMap] = useState({})
     const [liveRunning, setLiveRunning] = useState(null) // null=未探测；Set<sessionId>
     useEffect(() => {
-      const conn = props.connection
-      if (!canOfficialRename(conn) || state.phase !== 'ready') return undefined
+      if (!sfRemoteRef.current || state.phase !== 'ready') return undefined
       let alive = true
       let probing = false
       const probe = async () => {
         if (probing) return
         probing = true
         try {
-          const resp = await conn.api.sessions.list({})
-          const items = (resp && resp.result && resp.result.value && resp.result.value.items) || []
+          const val = await sfRemoteRef.current.listSessions()
+          const items = (val && val.items) || []
           const runningIds = items.filter((i) => i.running === true).map((i) => i.sessionId)
           if (!alive) return
           setLiveRunning(new Set(runningIds))
@@ -774,9 +1222,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           for (let i = 0; i < Math.min(runningIds.length, 8); i += 3) {
             await Promise.all(runningIds.slice(i, i + 3).map(async (sid) => {
               try {
-                const hr = await conn.api.sessions.history({ sessionId: sid, maxMessages: 3 })
-                const val = hr && hr.result && hr.result.value
-                const events = val && Array.isArray(val.events) ? val.events.map((e) => (e && e.event) || e) : []
+                const events = historyEventsOf(await sfRemoteRef.current.pageBySession(sid, 3))
                 if (events.length === 0) return
                 const d = await api('derive', { events, now: Date.now(), assumeRunning: true })
                 if (d && d.ok && d.health) next[sid] = d.health
@@ -792,12 +1238,17 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       return () => { alive = false; clearInterval(iv) }
     }, [props.connection, state.phase])
     // 头部芯片直达：工作台打开意图 → 列表就绪后自动进入该会话详情（每个意图只消费一次）。
+    // T3 修复：无论命中与否都标记消费 + 通知父级清意图——此前 Overview 卸载（进详情）后
+    // intentConsumed ref 随之丢失，「← 返回」重挂 Overview 时旧意图被再次消费，
+    // 表现为返回后又被拉回详情（用户实测）；未命中时也消费，避免每次重挂都重试查找。
     const intentConsumed = useRef(null)
     useEffect(() => {
       if (!props.intentId || intentConsumed.current === props.intentId || state.phase !== 'ready') return
+      intentConsumed.current = props.intentId
+      if (props.onIntentConsumed) props.onIntentConsumed()
       const all = ((state.data && state.data.workspaces) || []).flatMap((g) => g.sessions || [])
       const target = all.find((x) => x.id === props.intentId)
-      if (target) { intentConsumed.current = props.intentId; props.onOpen(target) }
+      if (target) props.onOpen(target)
     }, [props.intentId, state.phase])
     useEffect(() => () => {
       if (fullTextTimer.current) clearTimeout(fullTextTimer.current)
@@ -1445,16 +1896,12 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         }
       } catch (e) {}
       // 2) 运行时 history 桥接（在线子代理）→ host derive 得 light 结构
-      if (connection !== undefined && node.parentId !== undefined) {
+      if (node.parentId !== undefined && sfRemoteRef.current) {
         try {
-          const resp = await connection.api.subagents.history({
-            parentSessionId: node.parentId,
-            childSessionId: node.id,
-            mode: node.mode,
-            maxMessages: 120,
-          })
-          if (resp && resp.result && resp.result.ok && resp.result.value && Array.isArray(resp.result.value.events)) {
-            const events = resp.result.value.events.map((entry) => entry.event)
+          const subVal = await sfRemoteRef.current.pageBySub(node.parentId, node.id, node.mode, 120)
+          const subEvents = historyEventsOf(subVal)
+          if (subEvents.length > 0) {
+            const events = subEvents
             const derived = await api('derive', { events })
             if (derived && derived.ok) {
               // derive 返回完整 timeline——转成 light 结构
@@ -1572,8 +2019,9 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       })
       const trimmed = String(title || '').trim()
       if (trimmed === '' && session.titleSource === 'user') return Promise.reject(new Error(STR.renameClearBlocked))
-      if (trimmed !== '' && canOfficialRename(conn)) {
-        return renameViaOfficial(conn, session.id, trimmed)
+      if (trimmed !== '' && sfRemoteRef.current && sfRemoteRef.current.canRename) {
+        return sfRemoteRef.current.rename(session.id, trimmed)
+          .then((accepted) => { if (typeof accepted !== 'string') throw new Error(STR.renameFail); return accepted })
           .then((accepted) => { setTitleOverride(accepted); setRenaming(false); return true })
           .catch(() => legacy())
       }
@@ -1714,27 +2162,22 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       }
       setLiveState((s) => ({ ...s, phase: 'loading' }))
       try {
-        // 会话地址未知时走普通 sessions 通道（当前会话）；若连接层要求显式地址则回退。
-        const resp = await conn.api.sessions.history({
-          sessionId: session.id,
-          mode: 'full',
-          maxMessages: 400,
-        })
-        const val = resp && resp.result && resp.result.value
-        if (val === undefined || !Array.isArray(val.events)) {
+        // v0.1.2：session RPC 经双面适配器（remote.session.page / 旧 history）。
+        const val = sfRemoteRef.current ? await sfRemoteRef.current.pageBySession(session.id, 400) : undefined
+        if (val === undefined) {
           setLiveState((s) => ({ ...s, phase: 'error', error: STR.liveFail }))
           return
         }
-        const events = val.events.map((entry) => (entry && entry.event) || entry)
+        const events = historyEventsOf(val)
         const derived = await api('derive', { events, now: Date.now() })
         if (!derived || !derived.ok) {
           setLiveState((s) => ({ ...s, phase: 'error', error: (derived && derived.error) || STR.liveFail }))
           return
         }
         const tl = (derived.timeline && derived.timeline.turns) || []
-        // 实时视图只保留「最近 3 个历史回合 + 当前运行回合」（若有），数量恒定，
-        // 不随 history 窗口大小变化——新回合出现时最旧的被挤出。
-        const LIVE_MAX_HISTORY_TURNS = 3
+        // 实时视图只保留「最近 N 个历史回合 + 当前运行回合」（若有），数量恒定，
+        // 不随 history 窗口大小变化——新回合出现时最旧的被挤出。N 可配置（设置页）。
+        const LIVE_MAX_HISTORY_TURNS = sfSettings.current.liveHistoryTurns
         const liveRunning = derived.running === true
         const keepCount = tl.length > LIVE_MAX_HISTORY_TURNS + (liveRunning ? 1 : 0)
           ? LIVE_MAX_HISTORY_TURNS + (liveRunning ? 1 : 0)
@@ -1769,11 +2212,26 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     const enterLive = () => {
       setLiveOn(true)
       liveSeenTurns.current.clear() // 重进实时：全新视图，首轮全部折叠
+      tlFollowRef.current = true // T7：开播默认吸底
       fetchLive.current()
       if (liveTimer.current === null) {
-        liveTimer.current = setInterval(() => { fetchLive.current() }, 3000)
+        liveTimer.current = setInterval(() => { fetchLive.current() }, sfSettings.current.livePollMs)
       }
     }
+    // T7 实时吸底跟随：用户在时间线底部（距底 ≤liveFollowPx）时，每次轮询刷新后平滑滚到
+    // 新底部；上滑读历史不跟随（onScroll 实时追踪）。阈值默认 40px（可在设置页调整）。
+    const tlScrollRef = useRef(null)
+    const tlFollowRef = useRef(true)
+    const onTlScroll = () => {
+      const el = tlScrollRef.current
+      if (el === null) return
+      tlFollowRef.current = el.scrollHeight - el.scrollTop - el.clientHeight <= sfSettings.current.liveFollowPx
+    }
+    useEffect(() => {
+      if (!liveOn || liveState.timeline === null) return
+      const el = tlScrollRef.current
+      if (el !== null && tlFollowRef.current) el.scrollTo({ top: el.scrollHeight, behavior: 'smooth' })
+    }, [liveState.timeline, liveOn])
     const exitLive = () => {
       setLiveOn(false)
       liveSeenTurns.current.clear()
@@ -2009,10 +2467,15 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         running ? h('span', { className: 'sf-badge sf-badgeRun' }, STR.running) : h('span', { className: 'sf-badge sf-badgeEnd' }, STR.ended),
         session.delegationDepth > 0 && h('span', { className: 'sf-badge sf-badgeSub' }, STR.subagent),
         h('button', { className: 'sf-btn', onClick: () => { setPendingSelect(null); setView('lineage') } }, STR.lineage),
-        // M12：并入右栏（仅工作台详情页；嵌入标签页不显示——避免右栏与标签页重复）。
-        !props.embedded && h('button', {
+        // T6：并入右栏（工作台详情页 + 嵌入标签页都显示）。嵌入模式点击后额外
+        // 自动切回「对话」标签——右栏已接管会话流展示，中栏标签页继续停留会造成
+        // 双视图冗余（用户指定交互：点击=打开 dock+跳回对话）。
+        h('button', {
           className: 'sf-btn',
-          onClick: () => { if (dockBridge.controller) dockBridge.controller.open() },
+          onClick: () => {
+            if (dockBridge.controller) dockBridge.controller.open()
+            if (props.embedded) activateChatTab()
+          },
           title: STR.dockHint,
         }, STR.dock),
         // M6 实时通道：进行中会话可实时查看（sessions.history → derive → 折叠视图）。
@@ -2031,8 +2494,8 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       state.phase === 'error' && h('div', { className: 'sf-hint', style: { color: '#d43b3b' } }, STR.detailFailed + ': ' + String(state.error)),
       state.phase === 'empty' && h('div', { className: 'sf-hint' }, STR.emptyHint),
       state.phase === 'ready' && h('div', { className: 'sf-detailBody' },
-        // 左侧时间线
-        h('div', { className: 'sf-timeline' },
+        // 左侧时间线（T7：ref+onScroll 供实时吸底跟随）
+        h('div', { className: 'sf-timeline', ref: tlScrollRef, onScroll: onTlScroll },
           h('div', { className: 'sf-muted', style: { flex: 'none' }, title: data.workspaceCwd || data.workspace },
             (data.workspaceLabel || data.workspace || '') + ' · ' + fmtTime(sessionInfo.createdAt) +
             ' · ' + STR.duration + ' ' + fmtDuration((sessionInfo.lastEventTime || 0) - (sessionInfo.createdAt || 0)) +
@@ -2111,7 +2574,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
             ),
             h('button', { className: 'sf-btn sf-liveExitBtn', onClick: exitLive }, STR.liveExit),
           ),
-          liveOn && liveState.phase === 'error' && h('div', { className: 'sf-hint', style: { color: '#d43b3b' } }, liveState.error),
+        liveOn && liveState.phase === 'error' && h('div', { className: 'sf-hint', style: { color: '#d43b3b' } }, liveState.error),
           liveOn && liveState.phase === 'loading' && liveState.timeline === null && h('div', { className: 'sf-hint' }, STR.liveLoading),
           liveOn && liveState.timeline !== null && h(TimelineTurns, {
             // 保留回合头（默认折叠可点击展开）：hideHead=true 时折叠回合既无内容
@@ -2342,19 +2805,18 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
 
     const fetchLive = useRef(async () => {})
     fetchLive.current = async () => {
-      if (connection === undefined || connection.api === undefined || connection.api.sessions === undefined) {
+      if (!sfRemoteRef.current) {
         setState((s) => ({ ...s, phase: 'error', error: STR.liveUnavailable }))
         return
       }
       setState((s) => ({ ...s, phase: s.timeline === null ? 'loading' : 'ready' }))
       try {
-        const resp = await connection.api.sessions.history({ sessionId, mode: 'full', maxMessages: 400 })
-        const val = resp && resp.result && resp.result.value
-        if (val === undefined || !Array.isArray(val.events)) {
+        const val = await sfRemoteRef.current.pageBySession(sessionId, 400)
+        if (val === undefined) {
           setState((s) => ({ ...s, phase: 'error', error: STR.liveFail }))
           return
         }
-        const events = val.events.map((entry) => (entry && entry.event) || entry)
+        const events = historyEventsOf(val)
         const derived = await api('derive', { events, now: Date.now() })
         if (!derived || !derived.ok) {
           setState((s) => ({ ...s, phase: 'error', error: (derived && derived.error) || STR.liveFail }))
@@ -2384,7 +2846,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     useEffect(() => {
       liveSeenTurns.current.clear()
       fetchLive.current()
-      if (timer.current === null) timer.current = setInterval(() => { fetchLive.current() }, 3000)
+      if (timer.current === null) timer.current = setInterval(() => { fetchLive.current() }, sfSettings.current.livePollMs)
       return () => { if (timer.current !== null) { clearInterval(timer.current); timer.current = null } }
     }, [sessionId])
 
@@ -2445,6 +2907,33 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       })()
       return () => ac.abort()
     }, [props.connection])
+    // v0.1.2 起 events.mux 消费面移除 → 改用 sessions.list 订阅：官方 rename 后
+    // 列表行 byId[sessionId].title 由 title projection 即时更新（新控制器
+    // dsh-api-session-controller rename 后 projections.apply('title') 即落列表），
+    // 订阅回调秒级收集全量标题快照，浅比较防抖。与 mux 路径并存（旧版 dsh 仍走 mux）。
+    useEffect(() => {
+      const svc = props.sessions
+      const list = svc && svc.list
+      if (!list || typeof list.getSnapshot !== 'function' || typeof list.subscribe !== 'function') return undefined
+      const collect = () => {
+        const snap = list.getSnapshot()
+        const byId = snap && snap.byId
+        if (!byId) return
+        const map = {}
+        for (const id of Object.keys(byId)) {
+          const t = byId[id] && byId[id].title
+          if (typeof t === 'string' && t !== '') map[id] = t
+        }
+        setLiveTitles((prev) => {
+          const pk = Object.keys(prev)
+          const nk = Object.keys(map)
+          if (pk.length === nk.length && nk.every((k) => prev[k] === map[k])) return prev
+          return map
+        })
+      }
+      collect()
+      return list.subscribe(collect)
+    }, [props.sessions])
 
     return detail === null
       ? h(SessionFlowOverview, {
@@ -2455,6 +2944,9 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           connection: props.connection,
           liveTitles,
           intentId,
+          // T3：意图消费后即清除（SessionFlowView 不随详情↔总览切换卸载，状态稳）——
+          // 防止「← 返回」重挂 Overview 时旧意图再次消费把用户拉回详情。
+          onIntentConsumed: () => setIntentId(null),
         })
       : h(SessionFlowDetail, {
           session: detail.session,
@@ -2485,6 +2977,34 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       : { open: false, listeners: new Set(), controller: null })
   const PIANO_WINDOW = 15
 
+  // T6：从嵌入标签页切回「对话」标签。官方 conversation.view 槽位环的标签栏没有
+  // 公开激活 API（标准 props 仅 sessionId/useSession）——DOM 兜底：先按文案定位我们
+  // 自己的标签按钮（「会话流」），再取其父容器（标签栏）的【直接子元素】逐个按文本
+  // 精确匹配「对话 / Chat」——不限定 button：实测部分内置标签（对话/轨迹）不是
+  // <button> 元素，按 button 过滤会漏掉它们、只命中插件 tab（点了会跳 Plan 图，
+  // 实测踩坑）。命中后点击该元素或其内部首个按钮；未命中则不动作（宁可不动也
+  // 不跳错标签）。React 合成监听挂在本事件上，click() 有效。
+  function activateChatTab() {
+    try {
+      const pane = document.querySelector(CONVERSATION_SELECTOR)
+      if (pane === null) return
+      const btns = Array.prototype.slice.call(pane.querySelectorAll('button'))
+      const ours = btns.find((b) => (b.textContent || '').trim().indexOf(STR.entry) >= 0)
+      if (ours === undefined) return
+      const bar = ours.parentElement
+      if (bar === null) return
+      const kids = Array.prototype.slice.call(bar.children)
+      let target = null
+      for (const k of kids) {
+        if (k === ours || (typeof k.contains === 'function' && k.contains(ours))) continue
+        if (/^(对话|Chat)$/.test((k.textContent || '').trim())) { target = k; break }
+      }
+      if (target === null) return
+      const clickable = target.tagName === 'BUTTON' ? target : (target.querySelector('button') || target)
+      clickable.click()
+    } catch (e) {}
+  }
+
   // 定位目标：会话内容区。注意必须选**滚动容器** scrollBody（data-conversation-scroll）：
   // viewArea 在滚动场景下 rect 是「内容全尺寸」（如 y=-25687, h=26823），用它定位会把
   // 竖条甩到视口外（实测踩坑）。scrollBody 才有正确的视口内矩形。
@@ -2499,28 +3019,98 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     return undefined
   }
 
+  // ── 共享：纯色矢量图标 + 轮次 meta chips（rail 增强层与钢琴键详情框共用）──
+  // stroke=currentColor 随主题取色；不用 emoji（用户裁定 2026-09-05）。
+  const SF_ICON_PATHS = {
+    clock: '<circle cx="8" cy="8" r="6.3"/><path d="M8 4.6V8l2.4 1.5"/>',
+    tool: '<rect x="2.4" y="3" width="11.2" height="10" rx="1.6"/><path d="M5 7l2.2 2L5 11M8.6 11h2.6"/>',
+    alert: '<circle cx="8" cy="8" r="6.3"/><path d="M8 5.2v3.2M8 11.2h.01"/>',
+    think: '<path d="M8 2.2a4 4 0 0 0-4 4c0 1.7.9 2.7 1.6 3.5.3.4.4 1.3.4 1.3h4s.1-.9.4-1.3c.7-.8 1.6-1.8 1.6-3.5a4 4 0 0 0-4-4z"/><path d="M6.4 13.6h3.2"/>',
+  }
+  const sfIcon = (name) => {
+    const span = document.createElement('span')
+    span.className = 'sf-ico'
+    span.innerHTML = '<svg viewBox="0 0 16 16" width="11" height="11" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round">' + SF_ICON_PATHS[name] + '</svg>'
+    return span
+  }
+  // 时长格式化（ms → 42s / 2m 14s；与 host 导出 fmtDur 同风格）。
+  const sfFmtDur = (ms) => {
+    if (!ms || ms <= 0) return ''
+    const s = Math.round(ms / 1000)
+    if (s < 60) return s + 's'
+    const m = Math.floor(s / 60)
+    return s % 60 === 0 ? m + 'm' : m + 'm ' + (s % 60) + 's'
+  }
+  // meta chips：耗时 / 工具调用 / 错误（红）/ 思考标记。无任何信息时返回 null。
+  const buildTurnMeta = (entry) => {
+    const meta = document.createElement('div')
+    meta.className = 'sf-turnMeta'
+    const chip = (icon, text, cls) => {
+      const c = document.createElement('span')
+      c.className = 'sf-turnMetaChip' + (cls ? ' ' + cls : '')
+      c.appendChild(sfIcon(icon))
+      const t = document.createElement('span')
+      t.textContent = text
+      c.appendChild(t)
+      meta.appendChild(c)
+    }
+    if (entry.durMs > 0) chip('clock', sfFmtDur(entry.durMs))
+    if (entry.tools > 0) chip('tool', STR.railMetaCalls.replace('{tools}', String(entry.tools)))
+    if (entry.errors > 0) chip('alert', STR.railMetaErrors.replace('{errors}', String(entry.errors)), 'err')
+    if (entry.thinking) chip('think', STR.railThinking)
+    return meta.childNodes.length > 0 ? meta : null
+  }
+  // lightTurn → 共享字段（tools/errors/durMs/thinking/conclusion）。
+  const ltMeta = (lt) => ({
+    tools: lt.toolCount || 0,
+    errors: lt.errorCount || 0,
+    durMs: (typeof lt.startTime === 'number' && typeof lt.endTime === 'number' && lt.endTime > lt.startTime) ? lt.endTime - lt.startTime : 0,
+    thinking: lt.hasThinking === true,
+  })
+  // getTurn → 工具分布文本（top4：pwsh ×6 · edit ×3）；共享给 rail 与钢琴键。
+  const toolDistOf = (turn) => {
+    const counts = new Map()
+    for (const st of (turn && turn.steps) || []) for (const c of st.toolCalls || []) counts.set(c.name, (counts.get(c.name) || 0) + 1)
+    return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 4).map(([n, c]) => n + ' ×' + c).join(' · ')
+  }
+
   // ── M11：本会话轮次导航（会话页左侧常驻悬浮条目条，v3）──────────
   // 范围：只显示【当前会话】的对话轮次（用户消息），不跨会话/不跨工作区。
-  // 数据：官方消息行锚点 DOM 驱动（data-time-hover-root，dsh-navbar 同款机制，
-  // 零 RPC 实时）：用户行 = 无 data-turn-tail + 含 [class*=bubble]。
+  // 数据：官方消息行锚点 DOM 驱动（v0.1.2 起 [data-chat-flow] [data-chat-flow-kind=user]，
+  // 旧版回退 data-time-hover-root；零 RPC 实时）。
   // 轮次 → 结论预览：按顺序索引映射 host get 的 lightTurns（用户消息摊平）。
   // 交互：点击滚动定位该轮、active 跟随视口第一条、窗口裁剪 + 滚轮/▲▼、
   // 键盘 ↑↓/Enter、hover 预览卡（该轮用户消息 + 结论）、右键唤起会话流工作台。
   // 样式：DeepSeek 网页版右侧悬浮消息导航风格（圆角卡片 + 单行截断文字），移到左侧。
   function TurnKeys(props) {
     const { sessions, onOpenWorkbench } = props
-    const [entries, setEntries] = useState([]) // [{turn, seq, preview}] host 全量用户轮次
+    const [entries, setEntries] = useState([]) // [{turn, seq, preview, tools, errors, durMs, thinking}] host 全量用户轮次
+    const distCache = useRef(new Map()) // turn → 工具分布文本（getTurn 懒加载缓存）
+    const [, setDistTick] = useState(0) // distCache 到位后触发详情框重渲染
     const [activeIdx, setActiveIdx] = useState(-1)
-    const [winOffset, setWinOffset] = useState(0)
+    // T5 平滑滚动：连续滚动位置（浮点，单位=行）。替代原整数 winOffset 的「每格硬跳
+    // 1 条」——滚轮增量累积（deltaMode 归一）+ 列表 transform 百分比位移（transition
+    // 追逐），渲染窗口 = 可视 WINDOW 条 + 上下缓冲，位移按列表自身高度百分比换算，
+    // 收拢（4px）/展开（30px）行高变化时比例自守恒，无需测量行距。
+    const [scrollPos, setScrollPos] = useState(0)
     const [kbGlobal, setKbGlobal] = useState(null)
     const [detailIdx, setDetailIdx] = useState(null) // 右侧信息面板显示的条目索引
     const detailTimer = useRef(null)
     const rootRef = useRef(null) // 悬浮条根容器（面板定位换算基准）
     const [jumpFail, setJumpFail] = useState(false) // 未加载轮次提示
     const [, force] = useState(0)
+    // detailIdx 镜像：过渡监听 effect（deps []）闭包里读取当前值，避免读到旧 state。
+    const detailIdxRef = useRef(null)
 
     // 定位自管理：垂直居中悬浮于会话内容区（scrollBody 矩形中心 + translateY(-50%)）。
     const [pos, setPos] = useState(null) // {left, top(区中心)}
+    useEffect(() => {
+      return () => {
+        const lock = collapseLockRef.current
+        if (lock.timer) clearTimeout(lock.timer)
+        if (lock.retry) clearTimeout(lock.retry)
+      }
+    }, [])
     useEffect(() => {
       const compute = () => {
         const area = pianoViewArea()
@@ -2552,7 +3142,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     useEffect(() => {
       if (initTailDone.current || entries.length <= WINDOW) return
       initTailDone.current = true
-      setWinOffset(entries.length - WINDOW)
+      setScrollPos(entries.length - WINDOW)
     }, [entries])
 
     // 当前会话 id（仅取 current，不展示跨会话列表）。
@@ -2578,7 +3168,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           const flat = []
           for (const lt of json.lightTurns || []) {
             for (const u of lt.userMessages || []) {
-              flat.push({ turn: lt.turn, seq: u.seq, preview: u.preview })
+              flat.push({ turn: lt.turn, seq: u.seq, preview: u.preview, ...ltMeta(lt) })
             }
           }
           // 防御：同一 seq 只保留一条（避免同一条消息重复渲染 = 「最后一条显示两次」）。
@@ -2622,10 +3212,18 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       return () => { alive = false; if (iv) clearInterval(iv); if (flowObs) flowObs.disconnect() }
     }, [currentId])
 
-    // DOM 行工具：官方消息行锚点（dsh-navbar 同款）。
-    const domRows = () => [...document.querySelectorAll('[data-time-hover-root]')]
-      .filter((r) => !r.hasAttribute('data-pending-steering'))
-      .filter((r) => !r.hasAttribute('data-turn-tail') && r.querySelector('[class*=bubble]') !== null)
+    // DOM 行工具：用户消息行锚点。v0.1.2 起官方会话流重构进 dsh-client-ui-chat：
+    // data-time-hover-root 移除，行结构 = [data-chat-flow] > [data-chat-flow-key]
+    // （data-chat-flow-kind 区分 user/steering/turn-process/…，官方内部查行同款
+    // 选择器）；旧版 dsh 回退 data-time-hover-root 锚点（dsh-navbar 同款机制）。
+    // 零 RPC 实时。steering（随转消息）不算新轮次，不计入。
+    const domRows = () => {
+      const next = document.querySelectorAll('[data-chat-flow] [data-chat-flow-kind="user"]')
+      if (next.length > 0) return [...next]
+      return [...document.querySelectorAll('[data-time-hover-root]')]
+        .filter((r) => !r.hasAttribute('data-pending-steering'))
+        .filter((r) => !r.hasAttribute('data-turn-tail') && r.querySelector('[class*=bubble]') !== null)
+    }
     const textOf = (row) => {
       const b = row.querySelector('[class*=bubble]')
       return b ? String(b.textContent || '').replace(/\s+/g, ' ').trim() : ''
@@ -2639,56 +3237,184 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       .replace(/[*_#>|~-]{1,3}/g, ' ')
       .replace(/\s+/g, ' ')
       .trim()
-    // 条目 → DOM 行匹配：preview 归一化截断前缀与行文本归一化后 includes 比较。
-    const findRow = (entry) => {
-      const core = norm(String(entry.preview || '').replace(/…+$/u, '')).slice(0, 50)
-      if (!core) return null // 无文字内容（纯图片/文件消息）无法文本定位
-      for (const row of domRows()) {
-        const t = norm(textOf(row))
-        if (t && t.includes(core.slice(0, 30))) return row
+    // 行→条目映射（单调整体映射，active 定位与点击跳转共用）：
+    // 按文档序游标推进匹配用户行（「继续」类重复文本不会误配到前面条目）；
+    // 助手行未匹配时继承前一条用户行的条目（轮次归属）——视口首行为助手
+    // 回复时 active 仍指向其所属用户轮次，不再丢失高亮（T1 修复点一）。
+    const mapRows = () => {
+      const rows = domRows()
+      const idxs = new Array(rows.length).fill(-1)
+      let cursor = 0
+      let last = -1
+      for (let i = 0; i < rows.length; i++) {
+        const t = norm(textOf(rows[i]))
+        if (t) {
+          for (let j = cursor; j < entries.length; j++) {
+            const core = norm(String(entries[j].preview || '').replace(/…+$/u, '')).slice(0, 50)
+            if (core && t.includes(core.slice(0, 30))) { cursor = j + 1; last = j; break }
+          }
+        }
+        idxs[i] = last
       }
+      return { rows, idxs }
+    }
+    // 条目 → DOM 行：从映射中取首个归属该条目的行（用户行本身；映射按文档序
+    // 单调推进，重复文本不会命中到前面的同文条目）。
+    const findRow = (entry) => {
+      const target = entries.indexOf(entry)
+      if (target === -1) return null
+      const { rows, idxs } = mapRows()
+      for (let i = 0; i < rows.length; i++) if (idxs[i] === target) return rows[i]
       return null
     }
 
+    // 未加载轮次 → 委托官方轮次导航引擎（v0.1.2+ 吸收官方独有能力）：合成 click
+    // 命中目标刻度，官方 navigate 自动加载未载入页并跳转（其引擎含 busy 态/加载锚定，
+    // 优于我们的「只提示」）。合成事件 clientY 按官方 itemAtPointer 几何反解
+    // （offset = clientY - rect.top + scrollTop - 6 = idx*10）；官方处理挂在 nav 的
+    // onClick 且只读 event.clientY，与事件落在哪个子元素无关（刻度按钮
+    // pointer-events:none，不能直接 btn.click()——clientY=0 会误算成第一条）。
+    const delegateToRail = (entry) => {
+      try {
+        const nav = document.querySelector(RAIL_SELECTOR)
+        if (!nav) return false
+        const turns = [...nav.querySelectorAll('button[aria-label]')]
+          .map((b) => { const m = /(\d+)/.exec(b.getAttribute('aria-label') || ''); return m ? Number(m[1]) : null })
+        const idx = turns.indexOf(entry.turn)
+        if (idx < 0) return false
+        const rect = nav.getBoundingClientRect()
+        const scroller = nav.firstElementChild
+        const st = scroller ? scroller.scrollTop : 0
+        const y = rect.top + (idx * 10 + 6) - st
+        nav.dispatchEvent(new MouseEvent('click', { bubbles: true, clientX: rect.left + 10, clientY: y }))
+        return true
+      } catch (e) { return false }
+    }
     // 点击定位：先查该轮次是否已加载（DOM 中能否匹配到对应行）——
-    // 已加载 → 平滑滚动定位；未加载 → 只提示、不跳转（自动加载循环会让消息流
-    // 乱滚/跳错位置，实测踩坑；用户需先在会话区向上滚动加载历史再点击）。
+    // 已加载 → 平滑滚动定位；未加载 → 委托官方 rail 引擎加载跳转（v0.1.2+）；
+    // rail 缺席（旧版 dsh）→ 只提示、不跳转（自动加载循环会让消息流乱滚/跳错
+    // 位置，实测踩坑；用户需先在会话区向上滚动加载历史再点击）。
     const open = (entry) => {
       const row = findRow(entry)
       if (row) { row.scrollIntoView({ behavior: 'smooth', block: 'start' }); return }
+      if (delegateToRail(entry)) return
       setJumpFail(true)
       setTimeout(() => setJumpFail(false), 2600)
     }
 
-    // active：视口内第一条 DOM 用户行 → 文本匹配条目索引高亮（阅读位置跟随）。
+    // 详情框 meta 注入（与 rail 增强层同款信息：矢量 chips + 工具分布行；
+    // imperative ref 填充，data-sig 幂等）。工具分布懒加载：详情驻留 200ms 拉
+    // getTurn 聚合（distCache 跨 hover 缓存，到位后 tick 触发 ref 重填）。
+    const fillDetailMeta = (el, entry) => {
+      if (!el) return
+      const dist = distCache.current.get(entry.turn) || ''
+      const sig = entry.turn + '|' + dist
+      if (el.dataset.sig === sig) return
+      el.dataset.sig = sig
+      el.replaceChildren()
+      const meta = buildTurnMeta(entry)
+      if (meta) el.appendChild(meta)
+      if (dist !== '') {
+        const tools = document.createElement('div')
+        tools.className = 'sf-rail-conclusionTools'
+        tools.textContent = dist
+        el.appendChild(tools)
+      }
+    }
+    useEffect(() => {
+      if (detailIdx === null || !currentId) return undefined
+      const entry = entries[detailIdx]
+      if (!entry || entry.tools === 0 || distCache.current.has(entry.turn)) return undefined
+      const turn = entry.turn
+      const timer = setTimeout(() => {
+        api('getTurn', { sessionId: currentId, turn }).then((json) => {
+          if (!json || !json.ok || !json.turn) return
+          distCache.current.set(turn, toolDistOf(json.turn))
+          setDistTick((n) => n + 1)
+        }).catch(() => {})
+      }, 200)
+      return () => clearTimeout(timer)
+    }, [detailIdx, currentId, entries])
+
+    // active：视口内最靠上的可见行 → 映射条目索引高亮（阅读位置跟随）。
+    // 可见判定用 bottom 进入视口（含被顶部裁切一半的行）——此前 top>=0 会
+    // 跳过被裁切行导致高亮偏晚一轮（T1 修复点二）。
     useEffect(() => {
       const compute = () => {
         if (entries.length === 0) { setActiveIdx(-1); return }
-        const rows = domRows()
-        let target = null
+        const { rows, idxs } = mapRows()
+        let target = -1
         let bestTop = Number.POSITIVE_INFINITY
-        for (const row of rows) {
-          const top = row.getBoundingClientRect().top
-          if (top >= 0 && top < bestTop) { bestTop = top; target = row }
+        for (let i = 0; i < rows.length; i++) {
+          const r = rows[i].getBoundingClientRect()
+          if (r.bottom > 1 && r.top < bestTop) { bestTop = r.top; target = i }
         }
-        if (!target) { setActiveIdx(entries.length - 1); return }
-        const t = norm(textOf(target))
-        const idx = entries.findIndex((e) => {
-          const core = norm(String(e.preview || '').replace(/…+$/u, '')).slice(0, 50)
-          return core && t.includes(core.slice(0, 30))
-        })
-        setActiveIdx(idx)
+        if (target === -1) { setActiveIdx(entries.length - 1); return }
+        const idx = idxs[target]
+        // idx<0（视口首行在第一条用户消息之前）：保持现状，不清高亮不跳变。
+        if (idx >= 0) setActiveIdx(idx)
       }
       compute()
       const iv = setInterval(compute, 800)
       return () => clearInterval(iv)
     }, [entries])
 
-    const WINDOW = 12
+    const WINDOW = sfSettings.current.pianoWindow
     const hidden = entries.length < 2
-    const windowed = entries.slice(winOffset, winOffset + WINDOW)
-    const canUp = winOffset > 0
-    const canDown = winOffset + WINDOW < entries.length
+    // 虚拟窗口：renderStart 起渲染 WINDOW+3 条（上方缓冲 1 + 下方缓冲 2）。
+    const maxOff = Math.max(0, entries.length - WINDOW)
+    const clampedPos = Math.max(0, Math.min(maxOff, scrollPos))
+    const renderStart = Math.max(0, Math.floor(clampedPos) - 1)
+    const renderCount = Math.min(WINDOW + 3, entries.length - renderStart)
+    const windowed = entries.slice(renderStart, renderStart + renderCount)
+    const winOffset = Math.round(clampedPos) // 逻辑口径（高亮/面板/▲▼基准）四舍五入
+    const canUp = clampedPos > 0.01
+    const canDown = clampedPos < maxOff - 0.01
+    // T5 显示位（ref，非 state——逐帧 DOM 更新不过 React）：renderStartRef 镜像供
+    // 逐帧换算；displayPos 由 rAF 追逐 clampedPos（指数趋近 .22/帧 ≈ .16s 到位）。
+    const displayPosRef = useRef(0)
+    const renderStartRef = useRef(0)
+    renderStartRef.current = renderStart
+    const applyShift = () => {
+      const list = listRef.current
+      if (list === null || list.children.length < 2) return
+      const pitch = list.children[1].offsetTop - list.children[0].offsetTop
+      if (!(pitch > 0)) return
+      list.style.transform = 'translate3d(0,' + (-(displayPosRef.current - renderStartRef.current) * pitch).toFixed(2) + 'px,0)'
+      // strip 高度显式管理：clipper 脱流后 strip 不能靠内容撑高（塌缩=整条消失）。
+      // 纯内容高 = 可见行数 × 实测行距 − 间隙（12×35−5=415 / 12×9−5=103）；呼吸
+      // 在 strip 外（head 下边距 8 + 根下内边距 8）；键高动画期间 RO 逐帧跟随。
+      const rows = Math.min(WINDOW, entries.length)
+      const strip = stripRef.current
+      if (strip !== null) strip.style.height = (rows * pitch - 5).toFixed(1) + 'px'
+    }
+    useEffect(() => {
+      let raf = 0
+      const step = () => {
+        const target = Math.max(0, Math.min(Math.max(0, entries.length - WINDOW), scrollPos))
+        const cur = displayPosRef.current
+        if (Math.abs(target - cur) < 0.002) {
+          displayPosRef.current = target
+          applyShift()
+          return
+        }
+        displayPosRef.current = cur + (target - cur) * 0.22
+        applyShift()
+        raf = requestAnimationFrame(step)
+      }
+      raf = requestAnimationFrame(step)
+      return () => cancelAnimationFrame(raf)
+    }, [scrollPos, entries.length])
+    // renderStart 跳变（内容重排）后同步重设 transform（渲染后、绘制前），显示位
+    // 不变 → 无视觉跳变；列表高度随键高变化（收拢/展开）时重算行距保持对齐。
+    useEffect(() => { applyShift() })
+    useEffect(() => {
+      const list = listRef.current
+      if (list === null || typeof ResizeObserver !== 'function') return undefined
+      const ro = new ResizeObserver(() => applyShift())
+      ro.observe(list)
+      return () => ro.disconnect()
+    }, [renderStart, entries.length])
 
     // 悬浮条滚轮/▲▼：只翻悬浮条自身窗口，绝不影响会话区滚动（用户明确要求）。
     const onKeyDown = (e) => {
@@ -2707,35 +3433,118 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     }
     useEffect(() => {
       if (kbGlobal === null) return
-      if (kbGlobal < winOffset) setWinOffset(kbGlobal)
-      else if (kbGlobal >= winOffset + WINDOW) setWinOffset(kbGlobal - WINDOW + 1)
+      setScrollPos((o) => {
+        const p = Math.max(0, Math.min(maxOff, o))
+        if (kbGlobal < p) return kbGlobal
+        if (kbGlobal >= p + WINDOW) return Math.max(0, Math.min(maxOff, kbGlobal - WINDOW + 1))
+        return o
+      })
     }, [kbGlobal])
 
-    // 滚轮翻页：React onWheel 是被动监听器（passive: true），内部 preventDefault
+    // 滚轮平滑滚动：React onWheel 是被动监听器（passive: true），内部 preventDefault
     // 无效并刷屏告警（实测踩坑）——改原生 addEventListener('wheel', {passive:false})。
+    // 增量累积（deltaMode 归一为像素；~0.012 行/px：一整格滚轮 ≈1.2 行，触控板小
+    // 增量连续累积），rAF 追逐成连续位移。**静止吸附**：滚轮停 ~170ms 后取整到最近
+    // 整行（chase 平滑滑过去）——小数位置会让顶/底条露半截（「展示了 T23 的一部
+    // 分」实测踩坑），用户要求静止时恰好完整 12 条。
     const stripRef = useRef(null)
+    const listRef = useRef(null) // T5 虚拟滚动列表容器（键的父级，transform 平移）
+    const snapTimerRef = useRef(0)
     useEffect(() => {
       const el = stripRef.current
       if (el === null) return undefined
       const onNativeWheel = (e) => {
         e.preventDefault()
         e.stopPropagation()
-        if (e.deltaY > 0) setWinOffset((o) => Math.min(Math.max(0, entries.length - WINDOW), o + 1))
-        else setWinOffset((o) => Math.max(0, o - 1))
+        let dy = e.deltaY
+        if (e.deltaMode === 1) dy *= 33
+        else if (e.deltaMode === 2) dy *= 300
+        setScrollPos((o) => Math.max(0, Math.min(Math.max(0, entries.length - WINDOW), o + dy * sfSettings.current.pianoWheelSpeed)))
+        // 静止吸附：连续滚动不断顺延；停止后吸附到最近整行。
+        if (snapTimerRef.current !== 0) clearTimeout(snapTimerRef.current)
+        snapTimerRef.current = setTimeout(() => {
+          snapTimerRef.current = 0
+          setScrollPos((o) => Math.round(o))
+        }, sfSettings.current.pianoSnapMs)
       }
       el.addEventListener('wheel', onNativeWheel, { passive: false })
-      return () => el.removeEventListener('wheel', onNativeWheel)
+      return () => {
+        el.removeEventListener('wheel', onNativeWheel)
+        if (snapTimerRef.current !== 0) { clearTimeout(snapTimerRef.current); snapTimerRef.current = 0 }
+      }
     }, [entries.length])
 
+    // 面板锚定刷新：detailPos 在渲染时刻从键的实时矩形计算——mouseenter 常发生在
+    // 收拢/半展开几何（root 宽 32），面板被锚在收拢条右缘=鼠标旁，且展开完成后无
+    // 重渲染而停留在旧坐标。监听过渡结束（React 合成事件不含 transitionend 的完整
+    // 语义），仅几何属性（width/height/max-height）且面板显示中时强制重渲染，用最终
+    // 几何重算（面板可见延迟 .28s > 展开 .26s，用户看到的就是正确位置）。
+    useEffect(() => {
+      const el = rootRef.current
+      if (el === null) return undefined
+      const onEnd = (e) => {
+        if (detailIdxRef.current !== null &&
+            (e.propertyName === 'width' || e.propertyName === 'height' || e.propertyName === 'max-height')) {
+          force((t) => t + 1)
+        }
+      }
+      el.addEventListener('transitionend', onEnd)
+      return () => el.removeEventListener('transitionend', onEnd)
+    }, [])
+
     // 右侧信息面板：hover 条目/键盘聚焦时弹出该轮信息（保留弹出面板、移除原生
-    // tooltip——tooltip 与面板重复且视觉凌乱）；鼠标在条目与面板间移动 150ms 宽限。
+    // tooltip——tooltip 与面板重复且视觉凌乱）；鼠标在条目间移动 250ms 宽限。
     const showDetail = (idx) => {
+      const lock = collapseLockRef.current
+      if (Date.now() < lock.until) {
+        // 锁检查必须先于 clearTimeout：收拢条上的合成 mouseenter（skipped）不得
+        // 清掉待执行的隐藏定时器（实测：连续 skipped 把面板拖了 ~1s 不走）。
+        if (lock.kind === 'enter') {
+          // 进入护栏期（hover-guard）：推迟到锁过期后重试——驻留则面板照常出现，
+          // 快速路过则随离场作废（重试前检查 root 仍 :hover）。
+          if (lock.retry) clearTimeout(lock.retry)
+          lock.retry = setTimeout(() => {
+            lock.retry = null
+            if (rootRef.current !== null && rootRef.current.matches(':hover')) showDetail(idx)
+          }, Math.max(20, lock.until - Date.now() + 20))
+          return
+        }
+        return
+      }
+      if (lock.retry) { clearTimeout(lock.retry); lock.retry = null }
       if (detailTimer.current) clearTimeout(detailTimer.current)
       setDetailIdx(idx)
     }
     const hideDetail = () => {
+      const lock = collapseLockRef.current
+      if (lock.retry) { clearTimeout(lock.retry); lock.retry = null }
       if (detailTimer.current) clearTimeout(detailTimer.current)
-      detailTimer.current = setTimeout(() => setDetailIdx(null), 150)
+      // 宽限 250ms：标题行/首键边界窄带来回移动时，面板滑出动画（.24s）频繁被
+      // 打断重入，加长宽限减少闪动。
+      detailTimer.current = setTimeout(() => setDetailIdx(null), 250)
+    }
+    const collapseLockRef = useRef({ until: 0, timer: null, retry: null, kind: '' })
+    // hover-guard / collapse-lock 二合一：进入锁 120ms（「快速路过闪动」——锁窗内
+    // :hover 不展开，路过即零动画；驻留 120ms 后照常展开）＋离开锁 300ms（防几何
+    // 自反馈回路：展开态越界→收拢→胶囊条弹到静止鼠标下→合成 mouseenter→再展开）。
+    // kind 区分 showDetail 策略：enter 锁→推迟重试（驻留后面板照常），leave 锁→跳过。
+    const armCollapseLock = (ms, kind) => {
+      const lock = collapseLockRef.current
+      const el = rootRef.current
+      const w = typeof ms === 'number' ? ms : 300
+      if (el !== null && el.getAttribute('data-collapse-lock') === null) {
+        el.setAttribute('data-collapse-lock', '')
+      }
+      lock.kind = kind === 'enter' ? 'enter' : 'leave'
+      lock.until = Date.now() + w
+      if (lock.timer) clearTimeout(lock.timer)
+      lock.timer = setTimeout(() => {
+        lock.until = 0
+        lock.kind = ''
+        if (lock.timer) { clearTimeout(lock.timer); lock.timer = null }
+        const el2 = rootRef.current
+        if (el2 !== null) el2.removeAttribute('data-collapse-lock')
+      }, w)
     }
     useEffect(() => () => { if (detailTimer.current) clearTimeout(detailTimer.current) }, [])
     // 键盘聚焦跟随显示面板。
@@ -2743,6 +3552,9 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       if (kbGlobal !== null && entries[kbGlobal]) showDetail(kbGlobal)
     }, [kbGlobal])
 
+    // detailIdx 镜像同步（供 deps [] 的过渡监听闭包读取当前值）。
+    useEffect(() => { detailIdxRef.current = detailIdx }, [detailIdx])
+
     const rootStyle = pos === null ? { display: 'none' } : {
       left: pos.left + 'px',
       top: pos.top + 'px',
@@ -2752,12 +3564,12 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
 
     const detailEntry = detailIdx !== null ? entries[detailIdx] : null
     // 面板位置：absolute 相对悬浮条容器（容器有 translateY(-50%) transform，fixed
-    // 会退化为相对容器——必须按容器内偏移计算）。条目 = strip 直接子元素，
-    // 索引 = detailIdx - winOffset；越界修正按视口坐标换算回容器内。
+    // 会退化为相对容器——必须按容器内偏移计算）。条目 = 列表（pk-list）直接子元素，
+    // 索引 = detailIdx - renderStart（虚拟窗口含缓冲）；越界修正按视口坐标换算回容器内。
     let detailPos = null
     const rootRect = rootRef.current ? rootRef.current.getBoundingClientRect() : null
-    if (detailEntry && rootRect) {
-      const el = stripRef.current ? stripRef.current.children[detailIdx - winOffset] : null
+    if (detailEntry && rootRect && listRef.current) {
+      const el = listRef.current.children[detailIdx - renderStart]
       if (el instanceof Element) {
         const r = el.getBoundingClientRect()
         const topV = Math.min(r.top, Math.max(4, window.innerHeight - 320))
@@ -2765,42 +3577,74 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       }
     }
 
-    return h('div', { 'data-dsh-piano-keys': '', ref: rootRef, style: rootStyle },
-      h('div', { className: 'pk-head' },
+    return h('div', {
+      'data-dsh-piano-keys': '', ref: rootRef, style: rootStyle,
+      onPointerEnter: () => {
+        // 进入锁（hover-guard 120ms）：快速路过收拢条零动画零闪动；驻留后照常展开。
+        armCollapseLock(120, 'enter')
+      },
+      onPointerLeave: () => {
+        // 面板随收拢同步消失：root 级离开=真实收拢开始，立即隐藏（淡出 .18s 与收拢
+        // .22-.26s 同步收完）——不走 250ms 宽限+滑出拖尾 ~0.5s。
+        if (detailIdx !== null) {
+          if (detailTimer.current) clearTimeout(detailTimer.current)
+          setDetailIdx(null)
+        }
+        // 锁只在「当前不在锁窗内」时武装：锁窗内的离开（条本就被抑制未展开）不续期，
+        // 否则收拢条边缘快速进出让锁自续（实测 1.4s 不展开），300ms 后照常展开。
+        if (Date.now() >= collapseLockRef.current.until) armCollapseLock()
+      },
+    },
+      h('div', {
+        className: 'pk-head',
+        // 热区链：hover 标题行 ≡ hover 第一个键（CSS 侧高亮已链；JS 侧面板跟随）。
+        // head↔gap↔首键连续同态，消灭「横条出现消失」的状态边界。
+        onMouseEnter: () => showDetail(winOffset),
+        onMouseLeave: hideDetail,
+      },
         h('span', { className: 'pk-headLabel' }, STR.pianoTitle),
         h('div', { className: 'pk-navGroup' },
-          h('button', { className: 'pk-navBtn', disabled: !canUp, onClick: () => setWinOffset((o) => Math.max(0, o - 1)), title: STR.expanded }, '▲'),
-          h('button', { className: 'pk-navBtn', disabled: !canDown, onClick: () => setWinOffset((o) => Math.min(Math.max(0, entries.length - WINDOW), o + 1)), title: STR.collapsed }, '▼'),
+          h('button', { className: 'pk-navBtn', disabled: !canUp, onClick: () => { const n = Math.max(0, winOffset - 1); setScrollPos(n); showDetail(n) }, title: STR.expanded }, '▲'),
+          h('button', { className: 'pk-navBtn', disabled: !canDown, onClick: () => { const n = Math.min(Math.max(0, entries.length - WINDOW), winOffset + 1); setScrollPos(n); showDetail(n) }, title: STR.collapsed }, '▼'),
         ),
       ),
       h('div', { className: 'pk-strip', ref: stripRef, tabIndex: 0, onKeyDown, onMouseDown: (e) => { if (e.target === e.currentTarget) e.preventDefault() }, 'aria-label': STR.pianoTitle },
-        windowed.map((entry, idx) => {
-          const gi = winOffset + idx
-          const act = activeIdx === gi
-          return h('button', {
-            key: 'turn-' + gi + '-' + entry.seq,
-            type: 'button',
-            className: 'pk-key' + (act ? ' pk-keyActive' : '') + (kbGlobal === gi ? ' pk-keyFocus' : ''),
-            // 点击后主动失焦：避免 button 焦点让 :focus-within 常驻展开
-            // （鼠标移开后悬浮条收不拢，箭头「残留」——实测踩坑）。
-            onClick: (e) => { open(entry); e.currentTarget.blur() },
-            onMouseEnter: () => showDetail(gi),
-            onMouseLeave: hideDetail,
-            onContextMenu: (e) => {
-              e.preventDefault()
-              if (onOpenWorkbench) onOpenWorkbench()
+        // T5 裁剪框（strip 内容盒）：缓冲键全裁，可见区恰好 12 行；strip 本体保留
+        // 内边距（视觉呼吸）+ 定位（relative）。
+        h('div', { className: 'pk-clip' },
+          // T5 虚拟滚动列表：transform 由 JS 逐帧驱动（applyShift），不设 style
+          // 以免 React 重渲染覆盖 JS 值。
+          h('div', { className: 'pk-list', ref: listRef },
+          windowed.map((entry, idx) => {
+            const gi = renderStart + idx
+            const act = activeIdx === gi
+            return h('button', {
+              key: 'turn-' + gi + '-' + entry.seq,
+              type: 'button',
+              className: 'pk-key' + (act ? ' pk-keyActive' : '') + (kbGlobal === gi ? ' pk-keyFocus' : ''),
+              // 点击后主动失焦：避免 button 焦点让 :focus-within 常驻展开
+              // （鼠标移开后悬浮条收不拢，箭头「残留」——实测踩坑）。
+              onClick: (e) => { open(entry); e.currentTarget.blur() },
+              onMouseEnter: () => showDetail(gi),
+              onMouseLeave: hideDetail,
+              onContextMenu: (e) => {
+                e.preventDefault()
+                if (onOpenWorkbench) onOpenWorkbench()
+              },
             },
-          },
-            // 轮次序号：展开态常驻【最左侧】独立模块（与文本模块分离，互不侵占）。
-            h('span', { className: 'pk-turnNo' }, 'T' + entry.turn),
-            h('span', { className: 'pk-label' }, entry.preview || '（空）'),
-          )
-        }),
+              // 轮次序号：展开态常驻【最左侧】独立模块（与文本模块分离，互不侵占）。
+              h('span', { className: 'pk-turnNo' }, 'T' + entry.turn),
+              h('span', { className: 'pk-label' }, entry.preview || '（空）'),
+            )
+          }),
+          ),
+        ),
       ),
       // 信息面板：跟随 hover 条目右侧展开（fixed，位置由 detailPos 控制）；
       // 常驻渲染 + hidden 类做滑入/滑出；内容 key 变化触发 pkSlideIn。
       h('div', { className: 'pk-detail' + (detailEntry ? '' : ' hidden'), style: detailPos, onMouseEnter: () => showDetail(detailIdx), onMouseLeave: hideDetail },
         detailEntry && h('div', { key: 'h' + detailEntry.turn, className: 'pk-detailHead' }, 'T' + detailEntry.turn + ' · ' + STR.user),
+        detailEntry && h('div', { key: 'm' + detailEntry.turn, className: 'pk-detailMeta', ref: (el) => fillDetailMeta(el, detailEntry) }),
         detailEntry && h('div', { key: 'b' + detailEntry.turn, className: 'pk-detailBody' }, detailEntry.preview || '（空）'),
       ),
       // 跳转状态提示：常驻渲染 + hidden 类（从下方淡入/淡出）；未加载轮次提示。
@@ -2816,27 +3660,170 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
   function DetailsDockView(props) {
     const { sessionId, connection, onExit } = props
     const [state, setState] = useState({ phase: 'loading', error: null, data: null })
-    const [collapsed, setCollapsed] = useState(() => new Set())
+    // T8-B：重挂载续播时折叠集合按钉住时间线播种（新回合照常并入折叠）。
+    const [collapsed, setCollapsed] = useState(() => {
+      const s = new Set()
+      if (dockBridge.live && dockBridge.live.on && dockBridge.live.lastState) {
+        for (const t of dockBridge.live.lastState.timeline || []) s.add('turn-' + t.turn)
+      }
+      return s
+    })
     const collapsedInit = useRef(false)
     const [turnItems, setTurnItems] = useState(() => new Map())
     const loadingTurns = useRef(new Set())
 
-    useEffect(() => {
-      let alive = true
+    // ── T6 dock 实时模式：复用实时通道（sessions.history → derive，与详情页 M6
+    // 同构），但只显示「开播后」的对话——首轮记录基准回合集合，此后仅显示新出现
+    // 的回合（含开播时正在运行的回合）；不加载历史回合（档案 get 在实时期间跳过）。
+    // ── T8-B 钉住原会话：dock 视图随会话切换整体重挂载（槽位 session 作用域
+    // key），组件级实时状态必丢——实时状态提升到 dockBridge.live 模块级存储
+    // （钉住 sid/基准/已见/定时器/最近状态跨挂载存活）：开播即钉住当时的会话，
+    // GUI 切走后右栏继续直播原会话并显示提示条（告知用户），可一键转播当前会话。
+    const liveStore = dockBridge.live || (dockBridge.live = {
+      on: false, sid: undefined, timer: null, base: null, seen: new Set(),
+      lastState: null, conn: undefined, emit: null, tick: null,
+    })
+    const [liveOn, setLiveOn] = useState(() => liveStore.on)
+    const [liveState, setLiveState] = useState(() => liveStore.lastState
+      || { phase: 'idle', error: null, timeline: [], running: false, eventCount: 0, health: null })
+    const fetchLive = useRef(async () => {})
+    fetchLive.current = async () => {
+      const sid = liveStore.sid
+      const conn = liveStore.conn
+      if (sid === undefined || conn === undefined || conn.api === undefined || conn.api.sessions === undefined) {
+        liveStore.lastState = { phase: 'error', error: STR.liveUnavailable, timeline: [], running: false, eventCount: 0, health: null }
+        if (liveStore.emit !== null) liveStore.emit(liveStore.lastState)
+        return
+      }
+      if (liveStore.emit !== null) liveStore.emit({ ...liveStateKeep(), phase: 'loading' })
+      try {
+        const val = sfRemoteRef.current ? await sfRemoteRef.current.pageBySession(sid, 400) : undefined
+        if (val === undefined) {
+          liveStore.lastState = { ...liveStateKeep(), phase: 'error', error: STR.liveFail }
+          if (liveStore.emit !== null) liveStore.emit(liveStore.lastState)
+          return
+        }
+        const events = historyEventsOf(val)
+        const derived = await api('derive', { events, now: Date.now() })
+        if (!derived || !derived.ok) {
+          liveStore.lastState = { ...liveStateKeep(), phase: 'error', error: (derived && derived.error) || STR.liveFail }
+          if (liveStore.emit !== null) liveStore.emit(liveStore.lastState)
+          return
+        }
+        const tl = (derived.timeline && derived.timeline.turns) || []
+        const running = derived.running === true
+        if (liveStore.base === null) {
+          // 开播基准：当时已存在的全部回合；运行中的那个除外（它是「正在发生的
+          // 实时对话」，从开播起就要展示其后续流式变化）。
+          liveStore.base = new Set(tl.map((t) => t.turn))
+          if (running && tl.length > 0) liveStore.base.delete(tl[tl.length - 1].turn)
+        }
+        // 只保留：开播基准之后新出现的回合 + 开播时正在运行的那个回合。
+        const display = tl.filter((t) => !liveStore.base.has(t.turn))
+        const newTurns = display.filter((t) => !liveStore.seen.has(t.turn))
+        for (const t of display) liveStore.seen.add(t.turn)
+        if (newTurns.length > 0 && liveStore.emit !== null) {
+          setCollapsed((prev) => {
+            const next = new Set(prev)
+            for (const t of newTurns) next.add('turn-' + t.turn)
+            return next
+          })
+        }
+        liveStore.lastState = { phase: 'ready', error: null, timeline: display, running, eventCount: events.length, health: derived.health || null }
+        if (liveStore.emit !== null) liveStore.emit(liveStore.lastState)
+      } catch (e) {
+        liveStore.lastState = { ...liveStateKeep(), phase: 'error', error: STR.liveFail + ': ' + String(e && e.message || e) }
+        if (liveStore.emit !== null) liveStore.emit(liveStore.lastState)
+      }
+    }
+    // 保留当前显示数据、只换 phase 的辅助（emit 前构造）。
+    function liveStateKeep() {
+      return liveStore.lastState || { phase: 'idle', error: null, timeline: [], running: false, eventCount: 0, health: null }
+    }
+    const enterLive = () => {
+      liveStore.on = true
+      liveStore.sid = sessionId // T8-B：开播即钉住当前会话
+      liveStore.seen.clear()
+      liveStore.base = null
+      liveStore.lastState = null
+      setLiveOn(true)
+      liveFollowRef.current = true // T7：开播默认吸底
+      fetchLive.current()
+      if (liveStore.timer === null) {
+        liveStore.timer = setInterval(() => { if (liveStore.tick !== null) liveStore.tick() }, sfSettings.current.livePollMs)
+      }
+    }
+    const exitLive = () => {
+      liveStore.on = false
+      liveStore.sid = undefined
+      liveStore.seen.clear()
+      liveStore.base = null
+      liveStore.lastState = null
+      if (liveStore.timer !== null) { clearInterval(liveStore.timer); liveStore.timer = null }
+      setLiveOn(false)
+      setLiveState({ phase: 'idle', error: null, timeline: [], running: false, eventCount: 0, health: null })
+      // 回到档案视图：重新加载（实时期间可能已产生新回合）。
       setState({ phase: 'loading', error: null, data: null })
       setTurnItems(new Map())
       collapsedInit.current = false
-      if (!sessionId) { setState({ phase: 'empty', error: null, data: null }); return }
-      api('get', { sessionId }).then((json) => {
-        if (!alive) return
-        if (json && json.ok) {
-          setState({ phase: 'ready', error: null, data: json })
-        } else {
-          setState({ phase: 'error', error: (json && json.error) || 'get failed', data: null })
+    }
+    // T8-B：转播当前会话（提示条按钮）——重钉到当前 sessionId、基准重算。
+    const rebindLive = () => {
+      liveStore.sid = sessionId
+      liveStore.seen.clear()
+      liveStore.base = null
+      fetchLive.current()
+    }
+    // 挂载注册：连接对象/状态发射器/定时器分发指向当前实例（跨重挂载续播）；
+    // 卸载时若 3s 内无新实例接管（dock 真正关闭走 onExit→exitLive），停表清理。
+    useEffect(() => {
+      liveStore.conn = props.connection
+      liveStore.emit = setLiveState
+      liveStore.tick = () => { fetchLive.current() }
+      return () => {
+        if (liveStore.emit === setLiveState) liveStore.emit = null
+        if (liveStore.tick !== null) {
+          const t = liveStore.tick
+          setTimeout(() => { if (liveStore.tick === t && liveStore.emit === null) {
+            if (liveStore.timer !== null) { clearInterval(liveStore.timer); liveStore.timer = null }
+            liveStore.on = false; liveStore.tick = null
+          } }, 500)
         }
-      }).catch((e) => { if (alive) setState({ phase: 'error', error: String(e), data: null }) })
+      }
+    }, [])
+    // T7 实时吸底跟随（dock）：dk-body 距底 ≤40px 时每次刷新平滑滚到新底部。
+    const dkBodyRef = useRef(null)
+    const liveFollowRef = useRef(true)
+    const onDkBodyScroll = () => {
+      const el = dkBodyRef.current
+      if (el === null) return
+      liveFollowRef.current = el.scrollHeight - el.scrollTop - el.clientHeight <= sfSettings.current.liveFollowPx
+    }
+    useEffect(() => {
+      if (!liveOn || liveState.timeline === null || liveState.timeline.length === 0) return
+      const el = dkBodyRef.current
+      if (el !== null && liveFollowRef.current) el.scrollTo({ top: el.scrollHeight, behavior: 'smooth' })
+    }, [liveState.timeline, liveOn])
+
+    useEffect(() => {
+      let alive = true
+      // T8-B：实时钉住在 liveStore.sid（会话切换不重绑）；档案加载仅非实时时进行。
+      if (!liveOn) {
+        setState({ phase: 'loading', error: null, data: null })
+        setTurnItems(new Map())
+        collapsedInit.current = false
+        if (!sessionId) { setState({ phase: 'empty', error: null, data: null }); return }
+        api('get', { sessionId }).then((json) => {
+          if (!alive) return
+          if (json && json.ok) {
+            setState({ phase: 'ready', error: null, data: json })
+          } else {
+            setState({ phase: 'error', error: (json && json.error) || 'get failed', data: null })
+          }
+        }).catch((e) => { if (alive) setState({ phase: 'error', error: String(e), data: null }) })
+      }
       return () => { alive = false }
-    }, [sessionId])
+    }, [sessionId, liveOn])
 
     useEffect(() => {
       if (state.phase !== 'ready' || collapsedInit.current) return
@@ -2890,14 +3877,40 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
 
     return h('div', { className: 'dk-root' },
       h('div', { className: 'dk-head' },
-        h('span', { className: 'dk-title' }, STR.dockHint),
+        // T6：标题「会话流」+ 按钮**紧跟标题**（左侧区）；spacer 吃掉右侧余量——
+        // 彻底避开右上角 dsh-better-sidebar toggleCluster（视口级常驻浮钮区）。
+        h('span', { className: 'dk-title', title: STR.dockHint }, STR.entry),
+        props.connection !== undefined && h('button', {
+          className: 'dk-btn' + (liveOn ? ' dk-btnLive' : ''),
+          onClick: liveOn ? exitLive : enterLive,
+          title: STR.dockLiveHint,
+        }, liveOn ? STR.liveActive + ' ✕' : STR.live),
         h('button', { className: 'dk-btn', onClick: onExit }, STR.dockExit),
+        h('span', { className: 'dk-headSpacer' }),
       ),
-      h('div', { className: 'dk-body' },
-        state.phase === 'loading' && h('div', { className: 'sf-hint' }, STR.detailLoading),
-        state.phase === 'empty' && h('div', { className: 'sf-hint' }, STR.dockEmpty),
-        state.phase === 'error' && h('div', { className: 'sf-hint', style: { color: '#d43b3b' } }, STR.detailFailed + ': ' + String(state.error)),
-        state.phase === 'ready' && h('div', { className: 'dk-summary' },
+      h('div', { className: 'dk-body', ref: dkBodyRef, onScroll: onDkBodyScroll },
+        liveOn && h('div', { className: 'sf-liveBar', style: { flex: 'none' } },
+          h('span', { className: 'sf-badge sf-badgeRun', style: { flex: 'none' } }, STR.liveActive),
+          healthBadge(liveState.health),
+          h('span', { className: 'sf-liveText' },
+            h('span', { className: 'sf-muted', style: { flex: 'none' } }, (liveState.eventCount || 0) + ' ' + STR.liveEvents),
+            liveState.phase === 'loading' && h('span', { className: 'sf-muted', style: { flex: 'none' } }, STR.liveRefreshing),
+          ),
+        ),
+        liveOn && liveState.phase === 'error' && h('div', { className: 'sf-hint', style: { color: '#d43b3b' } }, liveState.error),
+        liveOn && liveStore.sid !== undefined && liveStore.sid !== sessionId && h('div', { className: 'dk-pinBar', title: liveStore.sid },
+          h('span', { className: 'dk-pinText' }, STR.dockPinNotice),
+          h('button', { className: 'dk-btn', onClick: rebindLive }, STR.dockPinRebind),
+        ),
+        liveOn && liveState.phase !== 'error' && liveState.timeline.length === 0 && h('div', { className: 'sf-hint' }, STR.dockLiveEmpty),
+        liveOn && liveState.timeline.length > 0 && h(TimelineTurns, {
+          turns: liveState.timeline, collapsed, toggle, liveActive: liveState.running === true,
+          activeTurn: null, setActiveTurn: () => {},
+        }),
+        !liveOn && state.phase === 'loading' && h('div', { className: 'sf-hint' }, STR.detailLoading),
+        !liveOn && state.phase === 'empty' && h('div', { className: 'sf-hint' }, STR.dockEmpty),
+        !liveOn && state.phase === 'error' && h('div', { className: 'sf-hint', style: { color: '#d43b3b' } }, STR.detailFailed + ': ' + String(state.error)),
+        !liveOn && state.phase === 'ready' && h('div', { className: 'dk-summary' },
           ruleTaskCount > 0 && h('div', { className: 'dk-summaryRow' },
             h('span', { className: 'dk-summaryTag' }, STR.summaryTaskCount),
             h('span', { className: 'dk-summaryText' }, ruleTaskCount),
@@ -2916,8 +3929,8 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           ),
           data.summary && h('div', { className: 'dk-summaryFull' }, data.summary),
         ),
-        state.phase === 'ready' && lightTurns.length === 0 && h('div', { className: 'sf-hint' }, STR.noTimeline),
-        state.phase === 'ready' && h(TurnList, {
+        !liveOn && state.phase === 'ready' && lightTurns.length === 0 && h('div', { className: 'sf-hint' }, STR.noTimeline),
+        !liveOn && state.phase === 'ready' && h(TurnList, {
           sessionId,
           lightTurns,
           collapsed,
@@ -2929,11 +3942,233 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     )
   }
 
+  // ── M11×v0.1.2：官方轮次导航（TurnNavigatorRail）增强层 ─────────────
+  // 官方 rail 无扩展槽位（chat 槽位仅 node/turnTail/assistant-actions/commandview），
+  // 本层走 DOM 观察（家族传统：观察器 + 自愈重挂），挂载我们的独有增量：
+  //   1) hover 结论段注入官方预览卡：该轮「结论摘要」（官方预览只有 prompt/response
+  //      片段）+ 工具统计（错误角标方案已撤——开发会话多数轮次都有工具错误，
+  //      刻度全员红点等于无信息，用户实机裁定 2026-09-05）；
+  //   2) 右键 rail → 唤起会话流工作台。
+  // 定位：nav[aria-label=轮次导航|Turn navigation]；几何换算复刻官方 itemAtPointer
+  // （TURN_SPACING 10px / RAIL_INSET 6px + scroller.scrollTop）；turn 号从刻度按钮
+  // aria-label（跳转到第 N 轮 / Jump to turn N）提取，索引↔turn 精确映射，不依赖
+  // 「index+1 == turn」假设。官方 navigate 引擎（含未载入轮次自动加载跳转）原样保留，
+  // 我们不拦截点击。
+  const RAIL_SELECTOR = 'nav[aria-label="轮次导航"], nav[aria-label="Turn navigation"]'
+  function RailEnhancer(props) {
+    const { sessions, railEl, onOpenWorkbench } = props
+    const [turnData, setTurnData] = useState([]) // [{turn, preview, conclusion, tools, errors}]
+    const [hoverInfo, setHoverInfo] = useState(null) // {turn, clientY, railLeft}
+    const [, force] = useState(0)
+
+    // 订阅会话列表变化：切换会话 → 重拉条目。
+    useEffect(() => {
+      if (sessions && sessions.list && typeof sessions.list.subscribe === 'function') {
+        return sessions.list.subscribe(() => force((n) => n + 1))
+      }
+      return undefined
+    }, [sessions])
+
+    const currentId = (() => {
+      try {
+        const s = sessions && sessions.list && typeof sessions.list.getSnapshot === 'function' ? sessions.list.getSnapshot() : null
+        return s && s.current ? s.current : null
+      } catch (e) { return null }
+    })()
+
+    // 条目数据：host get lightTurns（每轮一条，对齐官方 rail item 粒度）。
+    // 轮询节奏同钢琴键：DOM 变化切 3s 高频，空闲 15s 兜底。
+    useEffect(() => {
+      if (!currentId) { setTurnData([]); return undefined }
+      let alive = true
+      const refresh = () => {
+        api('get', { sessionId: currentId }).then((json) => {
+          if (!alive || !json || !json.ok) return
+          const rows = (json.lightTurns || []).map((lt) => ({
+            turn: lt.turn,
+            preview: lt.userMessages && lt.userMessages[0] ? String(lt.userMessages[0].preview || '') : '',
+            conclusion: String(lt.conclusionPreview || ''),
+            tools: lt.toolCount || 0,
+            errors: lt.errorCount || 0,
+            durMs: (typeof lt.startTime === 'number' && typeof lt.endTime === 'number' && lt.endTime > lt.startTime) ? lt.endTime - lt.startTime : 0,
+            thinking: lt.hasThinking === true,
+          }))
+          setTurnData((prev) => {
+            if (prev.length === rows.length && prev.length > 0 && prev[prev.length - 1].turn === rows[rows.length - 1].turn) return prev
+            return rows
+          })
+        }).catch(() => {})
+      }
+      const ACTIVE_MS = 3000
+      const IDLE_MS = 15000
+      let iv = null
+      const schedule = (delay) => { if (iv) clearInterval(iv); iv = setInterval(refresh, delay) }
+      let flowObs = null
+      let lastDomRefresh = 0
+      const onDomChange = () => {
+        if (!alive) return
+        const now = Date.now()
+        if (now - lastDomRefresh < 1000) return
+        lastDomRefresh = now
+        refresh()
+        schedule(ACTIVE_MS)
+      }
+      const flowEl = document.querySelector('[data-chat-flow=""]') || document.querySelector('[data-chat-flow]')
+      if (flowEl) {
+        flowObs = new MutationObserver(onDomChange)
+        flowObs.observe(flowEl, { childList: true, subtree: true })
+      }
+      refresh()
+      schedule(IDLE_MS)
+      return () => { alive = false; if (iv) clearInterval(iv); if (flowObs) flowObs.disconnect() }
+    }, [currentId])
+
+    // rail 交互：hover 几何换算 + 右键唤起工作台。
+    useEffect(() => {
+      if (!railEl) { setHoverInfo(null); return undefined }
+      const scroller = railEl.firstElementChild // 官方结构：nav.frame > div.scroller
+      const railTurns = () => [...railEl.querySelectorAll('button[aria-label]')]
+        .map((b) => { const m = /(\d+)/.exec(b.getAttribute('aria-label') || ''); return m ? Number(m[1]) : null })
+        .filter((n) => n !== null)
+      const onMove = (e) => {
+        const rect = railEl.getBoundingClientRect()
+        const st = scroller ? scroller.scrollTop : 0
+        const idx = Math.max(0, Math.round((e.clientY - rect.top + st - 6) / 10))
+        const turns = railTurns()
+        const turn = idx < turns.length ? turns[idx] : null
+        setHoverInfo((prev) => {
+          const prevTurn = prev === null ? null : prev.turn
+          return prevTurn === turn ? prev : (turn === null ? null : { turn })
+        })
+      }
+      const onLeave = () => setHoverInfo(null)
+      const onContext = (e) => { e.preventDefault(); onOpenWorkbench() }
+      railEl.addEventListener('pointermove', onMove)
+      railEl.addEventListener('pointerleave', onLeave)
+      railEl.addEventListener('contextmenu', onContext)
+      return () => {
+        railEl.removeEventListener('pointermove', onMove)
+        railEl.removeEventListener('pointerleave', onLeave)
+        railEl.removeEventListener('contextmenu', onContext)
+      }
+    }, [railEl, onOpenWorkbench])
+
+    // 工具分布懒加载（独特信息维度，官方 preview 只有 prompt/response 片段）：
+    // hover 驻留 250ms 后拉 getTurn，聚合工具名 ×次数 top4（防扫过时每刻度一请求）。
+    const [toolDist, setToolDist] = useState(null) // {turn, text}
+    useEffect(() => {
+      if (!railEl || hoverInfo === null || !currentId) { setToolDist(null); return undefined }
+      const turn = hoverInfo.turn
+      const timer = setTimeout(() => {
+        api('getTurn', { sessionId: currentId, turn }).then((json) => {
+          if (!json || !json.ok || !json.turn) return
+          const text = toolDistOf(json.turn)
+          setToolDist((prev) => (prev && prev.turn === turn && prev.text === text) ? prev : { turn, text })
+        }).catch(() => {})
+      }, 250)
+      return () => clearTimeout(timer)
+    }, [railEl, hoverInfo, currentId])
+
+    // hover 增强段注入官方预览卡内部（单卡融合——另起一卡会与官方预览上下堆叠成
+    // 两大块，实测很丑）。官方 preview 容器 = rail 内 class 以 _preview 结尾的元素
+    //（CSS module hash 前缀 + preview/previewPrompt/previewResponse 三段，用
+    // /(?:^|_)preview(?:$|\s)/ 精确命中容器）；React 复用 preview 元素跨轮次渲染 →
+    // data-sig 核对（轮次+工具分布到位状态），变化即重建；observer 监视 rail 子树，
+    // preview 出现/消失/被重渲染时自愈。**独特性原则（用户裁定 2026-09-05）：只给
+    // 官方 preview 没有的信息维度——耗时 / 工具统计与分布 / 错误 / 思考标记；
+    // 结论不再展示（与官方 response 片段重复，用户二次裁定撤下）；图标一律纯色
+    // 矢量（stroke=currentColor），不用 emoji**。
+    // 高度解禁：官方 preview 固定 --turn-preview-height:100px 且溢出裁剪——注入段
+    // 会被裁成「残缺卡」（实测踩坑）；注入期间内联 height:auto + maxHeight 放开，
+    // 撤注入时还原内联样式。
+    useEffect(() => {
+      if (!railEl) return undefined
+      const findPreview = () => [...railEl.querySelectorAll('[class*=preview]')]
+        .find((el) => /(?:^|_)preview(?:$|\s)/.test(String(el.className)))
+      const cleanup = () => {
+        for (const n of railEl.querySelectorAll('.sf-rail-conclusion')) n.remove()
+        const p = findPreview()
+        if (p) { p.style.height = ''; p.style.maxHeight = ''; p.style.overflow = '' }
+      }
+      const enhance = () => {
+        const preview = findPreview()
+        const turn = hoverInfo === null ? null : hoverInfo.turn
+        const entry = turn === null ? undefined : turnData.find((t) => t.turn === turn)
+        if (!preview || !entry || (entry.durMs === 0 && entry.tools === 0)) { cleanup(); return }
+        preview.style.height = 'auto'
+        preview.style.maxHeight = '280px'
+        preview.style.overflow = 'hidden'
+        let node = preview.querySelector(':scope > .sf-rail-conclusion')
+        if (!node) {
+          node = document.createElement('div')
+          node.className = 'sf-rail-conclusion'
+          preview.appendChild(node)
+        }
+        const dist = toolDist !== null && toolDist.turn === entry.turn ? toolDist.text : ''
+        const sig = entry.turn + '|' + dist
+        if (node.dataset.sig === sig) return
+        node.dataset.sig = sig
+        node.replaceChildren()
+        // meta chips 行（纯色矢量图标）：耗时 · n 次工具 · m 错误（红）· 含思考
+        const meta = buildTurnMeta(entry)
+        if (meta) node.appendChild(meta)
+        // 工具分布行（懒加载到位后经 sig 变化重建本节点）
+        if (dist !== '') {
+          const tools = document.createElement('div')
+          tools.className = 'sf-rail-conclusionTools'
+          tools.textContent = dist
+          node.appendChild(tools)
+        }
+      }
+      enhance()
+      const obs = new MutationObserver(enhance)
+      obs.observe(railEl, { childList: true, subtree: true })
+      return () => { obs.disconnect(); cleanup() }
+    }, [railEl, hoverInfo, turnData, toolDist])
+
+    return null
+  }
+
+  // ── 导航总挂载：官方 rail 增强层 ⇄ 经典钢琴键悬浮条 ────────────────
+  // 默认（v0.1.2+，用户裁定 2026-09-05）：经典悬浮条默认开启（pianoClassicStrip
+  // 默认 true），与官方 rail 增强层并存——左右双导航各司其职（我们：预览卡/右键
+  // 工作台/滚轮窗口/键盘；官方：完整历史刻度）；设置里可各自关闭。旧版 dsh
+  // （无官方 rail）railEl=null 时 classic 恒 true，功能不丢。
+  function NavRoot(props) {
+    const { settingsCtrl } = props
+    const [, force] = useState(0)
+    const [railEl, setRailEl] = useState(null)
+    useEffect(() => (settingsCtrl ? settingsCtrl.subscribe(() => force((n) => n + 1)) : undefined), [settingsCtrl])
+    useEffect(() => {
+      const find = () => {
+        const nav = document.querySelector(RAIL_SELECTOR)
+        setRailEl((prev) => (prev === nav || (prev === null && nav === null) ? prev : nav))
+      }
+      find()
+      const obs = new MutationObserver(find)
+      obs.observe(document.body, { childList: true, subtree: true })
+      return () => obs.disconnect()
+    }, [])
+    const classicWanted = sfSettings.current.pianoClassicStrip === true
+    const enhanceWanted = sfSettings.current.railEnhance !== false
+    // railHideOfficial：完全屏蔽官方刻度条（只留我们的悬浮条）；隐藏期间增强层不挂。
+    const hideOfficial = sfSettings.current.railHideOfficial === true
+    useEffect(() => {
+      if (railEl) railEl.style.display = hideOfficial ? 'none' : ''
+      return () => { if (railEl) railEl.style.display = '' }
+    }, [railEl, hideOfficial])
+    const showClassic = classicWanted || railEl === null
+    const showEnhance = enhanceWanted && railEl !== null && !hideOfficial
+    return h(React.Fragment, null,
+      showClassic ? h(TurnKeys, { sessions: props.sessions, connection: props.connection, onOpenWorkbench: props.onOpenWorkbench }) : null,
+      showEnhance ? h(RailEnhancer, { sessions: props.sessions, railEl, onOpenWorkbench: props.onOpenWorkbench }) : null)
+  }
+
   // ── M11：钢琴键竖条挂载（DOM 注入 + 自愈）────────────────────────
   // 容器挂 document.body（dsh-navbar 同款模式）：完全脱离会话区布局树，
   // 不干扰 conversation 的 flex/grid 布局；fixed 定位由组件自管理。
   // MutationObserver 自愈：容器丢失（布局重建）时自动恢复。
-  function mountPianoKeys(controller, sessions, connection) {
+  function mountPianoKeys(controller, sessions, connection, settingsCtrl) {
     let root = undefined
     let container = undefined
     let waitObserver = null
@@ -2957,9 +4192,10 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       document.body.appendChild(container)
       try {
         root = createRoot(container)
-        root.render(h(TurnKeys, {
+        root.render(h(NavRoot, {
           sessions,
           connection,
+          settingsCtrl: settingsCtrl || null,
           onOpenWorkbench: () => controller.open(),
         }))
         syncChatVisibility()
@@ -3127,7 +4363,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
   }
 
   // ── 插件体 ─────────────────────────────────────────────────────────
-  const inject = ['sessions', 'connection', 'slots', 'layout']
+  const inject = ['sessions', 'connection', 'slots', 'layout', 'remote', 'remote.session']
 
   function apply(ctx) {
     try {
@@ -3135,12 +4371,17 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       if (!document.getElementById('dsh-session-flow-style')) {
         const style = document.createElement('style')
         style.id = 'dsh-session-flow-style'
-        style.textContent = STYLE
+        style.textContent = STYLE + '\n' + SETTINGS_STYLE
         document.head.appendChild(style)
       }
 
       const sessions = ctx.get('sessions')
       const connection = ctx.get('connection')
+      // v0.1.2 RPC 双面适配（remote.session 新面优先，connection 旧面回退）。
+      sfRemoteRef.current = sfBuildRemote(ctx, connection)
+      // 设置控制器引用：settings.section 注册块内创建，挂载钢琴键/导航增强层时
+      // 传给 NavRoot 做设置变更即时切换（不可用则为 null，走默认值）。
+      let sfSettingsCtrl = null
 
       const state = { open: false, listeners: new Set() }
       const controller = {
@@ -3215,6 +4456,27 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         } catch (error) {
           console.error('[dsh-session-flow] header health chip registration failed:', error)
         }
+        // 插件设置页：settings.section 顶级 tab（order 140，排在皮肤中心 120/宠物 130 之后）。
+        // 读写经 settingsScope（pet 同款：优先 webUiSettings 桥，回退 settingsScope）；
+        // 两者都不可用（旧宿主/未暴露）时不注册 tab。controller 闭包持有，
+        // 卸载经 slots.inject 返回的 disposer 释放 scope 订阅。
+        try {
+          const settingsBinder = ctx.get('webUiSettings') ?? ctx.get('settingsScope')
+          if (settingsBinder !== undefined && settingsBinder !== null && typeof settingsBinder.bind === 'function') {
+            sfSettingsCtrl = new SfSettingsController(settingsBinder.bind({ namespace: 'session-flow' }))
+            slots.inject('settings.section', () => {
+              const unregister = slots.register({
+                name: 'settings.section',
+                id: 'session-flow',
+                order: 140,
+                label: () => STR.settingsTitle,
+              }, () => h(SessionFlowSettingsSection, { controller: sfSettingsCtrl }))
+              return () => { sfSettingsCtrl.dispose(); unregister() }
+            })
+          }
+        } catch (error) {
+          console.error('[dsh-session-flow] settings.section registration failed:', error)
+        }
       }
 
       // M12：详情并入右侧栏 —— details 槽位动态占用（priority -1 低于官方 tool-details）。
@@ -3233,66 +4495,10 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         } catch (e) {}
       }
 
-      // M12×aionui 兼容层：官方 details 把手按 3 轨模型定位（left = frameWidth - details，
-      // 假设 details 是最后一轨）；aionui-panel 把 frame grid 扩为 5 轨
-      // （sidebar|center|details|preview|explorer）后，真实边界左移 preview+explorer px，
-      // 把手却停在旧位置（悬浮于预览列上方，见 docs/02-design/LAYOUT-COEXIST.md）。
-      // dock 激活期间按实际轨宽重算把手位置：三方写 frame style → MutationObserver；
-      // 纯缩放（grid 字符串不变）→ ResizeObserver。3 轨时公式退化为官方原值，无副作用。
-      const parseGridTracksCompat = (input) => {
-        const tracks = []
-        let depth = 0
-        let current = ''
-        for (const ch of String(input)) {
-          if (ch === '(') depth += 1
-          if (ch === ')') depth = Math.max(0, depth - 1)
-          if (ch === ' ' && depth === 0) {
-            if (current !== '') { tracks.push(current); current = '' }
-            continue
-          }
-          current += ch
-        }
-        if (current !== '') tracks.push(current)
-        return tracks
-      }
-      const detailsHandleCompat = {
-        frame: null,
-        observer: null,
-        sizeObserver: null,
-        start() {
-          if (this.observer !== null) return
-          const frame = document.querySelector('[data-dsh-frame]') ||
-            (document.querySelector('[class*="sidebarCol"]') || {}).parentElement || null
-          if (frame === null) return
-          this.frame = frame
-          this.observer = new MutationObserver(() => this.apply())
-          this.observer.observe(frame, { attributes: true, attributeFilter: ['style'] })
-          this.sizeObserver = new ResizeObserver(() => this.apply())
-          this.sizeObserver.observe(frame)
-          this.apply()
-        },
-        stop() {
-          if (this.observer !== null) { this.observer.disconnect(); this.observer = null }
-          if (this.sizeObserver !== null) { this.sizeObserver.disconnect(); this.sizeObserver = null }
-          this.frame = null
-        },
-        apply() {
-          const frame = this.frame
-          if (frame === null) return
-          const tracks = parseGridTracksCompat(frame.style.gridTemplateColumns)
-          if (tracks.length < 3) return
-          const trackPx = (t) => {
-            const m = /^(-?[\d.]+)px$/.exec(String(t).trim())
-            return m === null ? 0 : Number(m[1])
-          }
-          const details = trackPx(tracks[2])
-          const preview = tracks.length >= 4 ? trackPx(tracks[3]) : 0
-          const explorer = tracks.length >= 5 ? trackPx(tracks[4]) : 0
-          const handle = frame.querySelector('[data-side="details"]')
-          if (handle === null) return
-          handle.style.left = `${Math.round(frame.getBoundingClientRect().width - details - preview - explorer)}px`
-        },
-      }
+      // M12×aionui：官方 details 把手在 5 轨 grid 下的位置补偿已由上游
+      // aionui-panel ≥0.2.0 接管（dsh-web-ui PR #311，applyGrid 每帧重算；
+      // 3 轨时退化为官方原值）。本插件过渡兼容层 detailsHandleCompat 已移除
+      // （2026-08-18，本机 aionui 0.2.0 实证含修复；旧版 aionui 请升级）。
       const ensureColumn = () => {
         if (dockBridge.open && layout !== undefined && typeof layout.openDetails === 'function') {
           try { layout.openDetails() } catch (e) {}
@@ -3334,7 +4540,6 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           if (!dockBridge.open) {
             dockBridge.open = true
             syncDetails()
-            detailsHandleCompat.start()
             // 会话切换时官方会自动 closeDetails —— 高频守护快速重开（无动画，内容直接刷新）。
             if (detailsGuard === null) {
               detailsGuard = setInterval(() => { ensureColumn() }, 150)
@@ -3346,7 +4551,6 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           if (dockBridge.open) {
             dockBridge.open = false
             syncDetails()
-            detailsHandleCompat.stop()
             if (detailsGuard !== null) { clearInterval(detailsGuard); detailsGuard = null }
             for (const fn of dockBridge.listeners) fn()
           }
@@ -3387,7 +4591,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         disposers.push(mountSidebarEntry(controller))
         disposers.push(mountBoard(controller, sessions, connection))
         // M11：钢琴键会话快切（会话页左侧常驻竖条）；挂载失败不影响其他功能。
-        disposers.push(mountPianoKeys(controller, sessions, connection))
+        disposers.push(mountPianoKeys(controller, sessions, connection, sfSettingsCtrl))
       } catch (error) {
         console.error('[dsh-session-flow] mount failed:', error)
       }
@@ -3400,7 +4604,6 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         }
         if (detailsGuard !== null) { clearInterval(detailsGuard); detailsGuard = null }
         setDockActive(false)
-        detailsHandleCompat.stop()
         if (layout !== undefined && typeof layout.closeDetails === 'function') {
           try { layout.closeDetails() } catch (e) {}
         }