dsh-session-flow 1.0.0 → 1.2.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')
 
@@ -40,6 +40,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,12 +74,30 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     summaryStale: '⚠ 摘要生成后有新对话，内容可能已不准确，建议重新生成',
     llmSummary: '生成 LLM 摘要', llmGenerating: '生成中…', llmFail: '生成失败', summaryRuleTag: '规则', summaryLlmTag: 'LLM',
     cacheHint: '仅清理本插件的缓存（可自动重建），不影响 DSH 会话存档与任何其他数据', cacheLimit: '时间线缓存上限',
+    healthActive: '活跃', healthToolWait: '工具执行中', healthQuiet: '静默中', healthStalled: '疑似卡死',
+    healthSilentMin: '静默 {N} 分钟', healthSilentSec: '静默 {N} 秒',
+    healthChipTitle: '会话健康状态（会话流）· 点击打开详情',
+    renameClearBlocked: '该会话标题由官方会话管理：请输入新标题（不支持清空）',
+    settingsTitle: '会话流', settingsDesc: '调整轮次悬浮条与实时跟踪的行为参数。保存后立即生效（轮次悬浮条行数在重进会话页后完全生效）。',
+    setGroupPiano: '轮次悬浮条', setGroupLive: '实时跟踪', setGroupHealth: '健康监控',
+    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）',
+    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',
@@ -111,8 +131,218 @@ 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',
+    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 the piano-keys strip and live-tracking behavior. Applies on save (strip row count fully applies after re-entering a session page).',
+    setGroupPiano: 'Turn strip', setGroupLive: 'Live tracking', setGroupHealth: 'Health monitor',
+    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)',
+    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 }
+  const sfSettings = { current: { ...SETTINGS_DEFAULTS } }
+  const SETTING_GROUPS = [
+    { titleKey: 'setGroupPiano', fields: ['pianoWindow', 'pianoWheelSpeed', 'pianoSnapMs'] },
+    { titleKey: 'setGroupLive', fields: ['livePollMs', 'liveFollowPx', 'liveHistoryTurns'] },
+    { titleKey: 'setGroupHealth', fields: ['stallThresholdMin'] },
+  ]
+  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' },
+  }
+  function formatSettingValue(v) { return v === undefined || v === null ? '' : String(v) }
+  function parseSettingValue(spec, text) {
+    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' },
+            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-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>`
@@ -140,7 +370,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}`,
@@ -179,6 +415,29 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     `.sf-badgeEnd{background:rgba(120,120,120,.12);color:#888}`,
     `.sf-badgeSub{background:rgba(240,150,60,.15);color:#d97706}`,
     `.sf-badgeErr{background:rgba(230,80,80,.13);color:#d43b3b}`,
+    // 卡死监控徽标：疑似卡死（红，呼吸动画引起注意）/ 工具执行中·静默中（黄）。
+    `.sf-badgeStall{background:rgba(230,80,80,.16);color:#d43b3b;animation:sfBadgePulse 2.8s ease-in-out infinite}`,
+    `.sf-badgeWait{background:rgba(220,170,40,.15);color:#a87b00}`,
+    // 会话页头部健康芯片（官方 header.actions 槽位，模式标识右侧）。
+    // 钢琴键同款语言：收拢态 = 彩色短胶囊条（语义色保留：绿/黄/红，卡死带呼吸脉冲）；
+    // 悬浮/聚焦展开为毛玻璃文字标签（backdrop-filter + color-mix，与 pk-key 展开态同构）。
+    `.sf-healthChip{display:inline-flex;align-items:center;gap:6px;height:20px;padding:0 3px;margin-left:2px;border:none;border-radius:99px;background:transparent;cursor:pointer;font-family:inherit;overflow:hidden;outline:none;transition:padding .22s ease,background .18s ease,border-color .18s ease,box-shadow .18s ease}`,
+    `.sf-healthChip .sf-hcBar{flex:none;width:4px;height:16px;border-radius:99px;transition:width .22s ease,height .22s ease}`,
+    `.sf-healthChip .sf-hcLabel{font-size:11px;line-height:16px;white-space:nowrap;max-width:0;opacity:0;overflow:hidden;user-select:none;transition:max-width .24s ease,opacity .16s ease .05s}`,
+    // 展开态：毛玻璃底（blur 10px）+ 同色系淡 tint 背景（状态色 14% 透明混入 72% 基底色），
+    // 边框带 40% 状态色呼应；tint 淡雅、毛玻璃质感保留。
+    `.sf-healthChip:hover,.sf-healthChip:focus-visible{padding:3px 9px;border:1px solid var(--dsw-alias-border-l2,#e4e6eb);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);box-shadow:0 1px 3px rgba(0,0,0,.07)}`,
+    `.sf-healthChip.hc-active:hover,.sf-healthChip.hc-active:focus-visible{background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 72%,rgba(28,158,90,.14));border-color:color-mix(in srgb,var(--dsw-alias-border-l2,#e4e6eb) 60%,#1c9e5a)}`,
+    `.sf-healthChip.hc-wait:hover,.sf-healthChip.hc-wait:focus-visible{background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 72%,rgba(217,165,20,.14));border-color:color-mix(in srgb,var(--dsw-alias-border-l2,#e4e6eb) 60%,#d9a514)}`,
+    `.sf-healthChip.hc-stall:hover,.sf-healthChip.hc-stall:focus-visible{background:color-mix(in srgb,var(--dsw-alias-bg-base,#fff) 72%,rgba(212,59,59,.14));border-color:color-mix(in srgb,var(--dsw-alias-border-l2,#e4e6eb) 60%,#d43b3b)}`,
+    `.sf-healthChip:hover .sf-hcBar,.sf-healthChip:focus-visible .sf-hcBar{width:6px;height:6px;border-radius:99px}`,
+    `.sf-healthChip:hover .sf-hcLabel,.sf-healthChip:focus-visible .sf-hcLabel{max-width:200px;opacity:1}`,
+    `.sf-healthChip.hc-active .sf-hcBar{background:#1c9e5a}`,
+    `.sf-healthChip.hc-active .sf-hcLabel{color:#1c9e5a}`,
+    `.sf-healthChip.hc-wait .sf-hcBar{background:#d9a514}`,
+    `.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-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（独立一行，醒目）──
@@ -307,17 +566,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}`,
@@ -362,35 +630,73 @@ 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 再滑入——等悬浮条展开动画完成、条目就位后，
     // 位置才准确（第一次展开时条目仍在变形，立即计算会错位，实测踩坑）；
     // 隐藏则立即（无延迟）。
@@ -405,14 +711,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}`,
@@ -562,6 +864,104 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     )
   }
 
+  // ── 重命名对齐官方 + 卡死监控 共享辅助 ─────────────────────────────
+  /** 官方 rename RPC（log-backed session/title user 事件）：本插件与官方侧栏同一数据源。 */
+  const renameViaOfficial = (conn, sessionId, title) => {
+    return conn.api.sessions.rename({ sessionId, title }).then((resp) => {
+      const res = resp && resp.result
+      if (res && res.ok === true && res.value && typeof res.value.title === 'string') return res.value.title
+      throw new Error((res && res.error && res.error.message) || STR.renameFail)
+    })
+  }
+  const canOfficialRename = (conn) =>
+    conn !== undefined && conn.api !== undefined && conn.api.sessions !== undefined && typeof conn.api.sessions.rename === 'function'
+  /** 静默时长文本（{N} 占位）。 */
+  const fmtSilent = (idleMs) => {
+    if (idleMs === null || idleMs === undefined) return ''
+    const min = Math.floor(idleMs / 60000)
+    return min >= 1
+      ? STR.healthSilentMin.replace('{N}', String(min))
+      : STR.healthSilentSec.replace('{N}', String(Math.max(1, Math.round(idleMs / 1000))))
+  }
+  /** 健康徽标（详情实时条 / 总览卡片共用）；active/ended/unknown 不渲染（已有进行中/已结束徽标）。 */
+  const healthBadge = (health) => {
+    if (!health) return null
+    const silent = fmtSilent(health.idleMs)
+    if (health.kind === 'stalled') return h('span', { className: 'sf-badge sf-badgeStall' }, '🔴 ' + STR.healthStalled + (silent ? ' · ' + silent : ''))
+    if (health.kind === 'tool-wait') return h('span', { className: 'sf-badge sf-badgeWait' }, '🟡 ' + STR.healthToolWait + (silent ? ' · ' + silent : ''))
+    if (health.kind === 'quiet') return h('span', { className: 'sf-badge sf-badgeWait' }, '🟡 ' + STR.healthQuiet + (silent ? ' · ' + silent : ''))
+    return null
+  }
+
+  // ── 会话页头部健康芯片（官方 conversation.session.header.actions 槽位）──
+  // 位置：官方模式标识（agent-preset label, order -10）右侧（order -9）。
+  // 数据：sessions.list 快照跟踪 running（官方真实状态，随 host 流即时翻转）→
+  // running 时 10s 轮询 tail history → host derive 健康分类（与总览探测同管线）。
+  // 点击：唤起会话流工作台并直达该会话详情（workbenchBridge 意图桥）。
+  function SessionHealthChip(props) {
+    const { sessionId, connection, sessions } = props
+    const [running, setRunning] = useState(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）。
+          const snap = sessions.list.getSnapshot()
+          const it = snap && snap.byId ? snap.byId[sessionId] : undefined
+          setRunning(it ? it.running === true : false)
+        } catch (e) { setRunning(false) }
+      }
+      compute()
+      if (typeof sessions.list.subscribe === 'function') return sessions.list.subscribe(compute)
+      return undefined
+    }, [sessions, sessionId])
+    useEffect(() => {
+      if (!running || !sessionId || !canOfficialRename(connection)) { 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) : []
+          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)
+        } catch (e) {}
+      }
+      probe()
+      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 不显示
+    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 : '')),
+    )
+  }
+
+  // 工作台打开意图桥：头部芯片点击 → 唤起工作台并直达该会话详情。
+  // （工厂作用域：芯片渲染于官方槽位，与本插件视图分属不同 React 子树。）
+  const workbenchBridge = {
+    intent: null,
+    listeners: new Set(),
+    open(sid) { this.intent = sid; for (const fn of [...this.listeners]) fn(sid) },
+    subscribe(fn) { this.listeners.add(fn); return () => this.listeners.delete(fn) },
+  }
+
   // ── 总览页 ──────────────────────────────────────────────────────────
   // props: { onOpen: (session) => void, onClose: () => void }
   function SessionFlowOverview(props) {
@@ -583,28 +983,98 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     // M8a：当前编辑重命名的会话 id（null = 无编辑态）。
     const [renamingId, setRenamingId] = useState(null)
     // M8a：保存自定义标题 → 更新本地列表数据（userTitle 覆盖显示，不整页重刷）。
+    // 对齐官方（2026-08 起）：非空标题且连接可用时优先走官方 session.rename RPC
+    // （log-backed，官方侧栏同步）；空标题（清除）/官方拒绝（子代理 agent-busy 等）回退 legacy renames.json。
     const saveRename = (sid, title) => {
-      return api('rename', { sessionId: sid, title }).then((json) => {
-        if (json && json.ok) {
-          setState((prev) => {
-            if (!prev || !prev.data) return prev
-            return {
-              ...prev,
-              data: {
-                ...prev.data,
-                workspaces: (prev.data.workspaces || []).map((g) => ({
-                  ...g,
-                  sessions: (g.sessions || []).map((s) => (s.id === sid ? { ...s, userTitle: json.userTitle } : s)),
-                })),
-              },
-            }
-          })
-          setRenamingId(null)
-          return true
-        }
+      const conn = props.connection
+      const applyLocal = (userTitle) => {
+        setState((prev) => {
+          if (!prev || !prev.data) return prev
+          return {
+            ...prev,
+            data: {
+              ...prev.data,
+              workspaces: (prev.data.workspaces || []).map((g) => ({
+                ...g,
+                sessions: (g.sessions || []).map((s) => (s.id === sid ? { ...s, userTitle } : s)),
+              })),
+            },
+          }
+        })
+        setRenamingId(null)
+        return true
+      }
+      const legacy = () => api('rename', { sessionId: sid, title }).then((json) => {
+        if (json && json.ok) return applyLocal(json.userTitle)
         throw new Error((json && json.error) || STR.renameFail)
       })
+      const trimmed = String(title || '').trim()
+      // 官方 user 标题不可经本插件清空（官方服务无删除语义）：阻止并提示。
+      if (trimmed === '') {
+        const all = ((state.data && state.data.workspaces) || []).flatMap((g) => g.sessions || [])
+        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)
+          .then((accepted) => applyLocal(accepted))
+          .catch(() => legacy())
+      }
+      return legacy()
     }
+    // ── 卡死监控：总览探测 ─────────────────────────────────────────────
+    // 官方 sessions.list 的 running（attached agent 真实状态，比 15 分钟启发式准）+
+    // tail history → host derive 健康分类。30s 轮询，上限 8 个、并发 3。
+    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
+      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 runningIds = items.filter((i) => i.running === true).map((i) => i.sessionId)
+          if (!alive) return
+          setLiveRunning(new Set(runningIds))
+          const next = {}
+          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) : []
+                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
+              } catch {}
+            }))
+            if (!alive) return
+          }
+          if (alive) setHealthMap(next)
+        } catch {} finally { probing = false }
+      }
+      probe()
+      const iv = setInterval(probe, 30000)
+      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) props.onOpen(target)
+    }, [props.intentId, state.phase])
     useEffect(() => () => {
       if (fullTextTimer.current) clearTimeout(fullTextTimer.current)
       if (fullTextAbort.current) fullTextAbort.current.abort()
@@ -738,7 +1208,11 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
             }
           }
           const now = Date.now()
-          const running = s.lastEventTime !== null && s.lastEventTime !== undefined && (now - s.lastEventTime) < ACTIVE_WINDOW_MS
+          // 卡死监控：官方探测过（liveRunning 非 null）则以 attached agent 真实状态为准，
+          // 否则回退 15 分钟活动窗口启发式。
+          const running = liveRunning === null
+            ? s.lastEventTime !== null && s.lastEventTime !== undefined && (now - s.lastEventTime) < ACTIVE_WINDOW_MS
+            : liveRunning.has(s.id)
           out.push({ ...s, workspace: group.name, workspaceLabel: wsLabelOf(group), workspaceCwd: wsCwdOf(group), running, isEmpty: isSessionEmpty(s) })
         }
       }
@@ -754,7 +1228,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       const ascending = sort === 'oldest'
       out.sort((a, b) => (ascending ? key(a) - key(b) : key(b) - key(a)))
       return out
-    }, [state.data, query, wsFilter, sort, showEmpty, showIssues])
+    }, [state.data, query, wsFilter, sort, showEmpty, showIssues, liveRunning])
 
     // M5b 档案统计：聚合工具出现热度与问题会话数，跟随选中的工作区（wsFilter）变化。
     const stats = useMemo(() => {
@@ -904,13 +1378,14 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
             h('div', { className: 'sf-cardTitle' },
               renamingId === s.id
                 ? h(RenameInline, {
-                    initial: s.userTitle || s.title || '',
+                    initial: (props.liveTitles && props.liveTitles[s.id]) || s.userTitle || s.title || '',
                     onSave: (t) => saveRename(s.id, t),
                     onCancel: () => setRenamingId(null),
                   })
                 : h('span', { className: 'sf-cardText', style: { overflow: 'hidden', textOverflow: 'ellipsis' } },
-                    s.userTitle || s.title || STR.unknownTitle,
-                    s.userTitle && h('span', { className: 'sf-origTitle', title: s.title || STR.unknownTitle },
+                    // 显示优先级：mux 近实时官方标题 > userTitle（档案 user/遗留 overlay）> 自动标题。
+                    (props.liveTitles && props.liveTitles[s.id]) || s.userTitle || s.title || STR.unknownTitle,
+                    (s.userTitle || (props.liveTitles && props.liveTitles[s.id])) && h('span', { className: 'sf-origTitle', title: s.title || STR.unknownTitle },
                       STR.origTitle + ': ' + (s.title || STR.unknownTitle)),
                     h('button', {
                       className: 'sf-renameBtn', title: STR.rename,
@@ -919,6 +1394,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
                   ),
               s.isEmpty && h('span', { className: 'sf-badge sf-badgeEnd' }, STR.emptySession),
               s.running ? h('span', { className: 'sf-badge sf-badgeRun' }, STR.running) : h('span', { className: 'sf-badge sf-badgeEnd' }, STR.ended),
+              healthBadge(healthMap[s.id]),
               s.delegationDepth > 0 && h('span', { className: 'sf-badge sf-badgeSub' }, STR.subagent + ' · d' + s.delegationDepth),
               s.toolErrors > 0 && h('span', { className: 'sf-badge sf-badgeErr' }, STR.errors + ': ' + s.toolErrors),
             ),
@@ -1357,8 +1833,12 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     // M8a：标题重命名（编辑态 + 保存后的显示覆盖，优先于 session.userTitle）。
     const [renaming, setRenaming] = useState(false)
     const [titleOverride, setTitleOverride] = useState(null)
+    // mux 近实时官方标题（SessionFlowView 订阅 session/projection(title) 帧传入）。
+    const liveTitleOf = (id) => (props.liveTitles && props.liveTitles[id]) || null
+    // 对齐官方：优先官方 session.rename RPC（log-backed，双向一致）；空标题/官方拒绝回退 legacy。
     const saveRename = (title) => {
-      return api('rename', { sessionId: session.id, title }).then((json) => {
+      const conn = props.connection
+      const legacy = () => api('rename', { sessionId: session.id, title }).then((json) => {
         if (json && json.ok) {
           setTitleOverride(json.userTitle) // null = 清除恢复原名
           setRenaming(false)
@@ -1366,6 +1846,14 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         }
         throw new Error((json && json.error) || STR.renameFail)
       })
+      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)
+          .then((accepted) => { setTitleOverride(accepted); setRenaming(false); return true })
+          .catch(() => legacy())
+      }
+      return legacy()
     }
 
     useEffect(() => {
@@ -1514,15 +2002,15 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           return
         }
         const events = val.events.map((entry) => (entry && entry.event) || entry)
-        const derived = await api('derive', { events })
+        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)
@@ -1537,6 +2025,8 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           // 运行中 = 事件结构信号（未闭合回合/步骤/工具调用或流式中间态），
           // 不依赖时间戳：输出间隔长（模型思考/长工具执行）时不会误判停止。
           running: liveRunning,
+          // 卡死监控：host 分类（active/tool-wait/quiet/stalled/ended）。
+          health: derived.health || null,
         })
         // 只把「新出现的回合」并入折叠集合（默认折叠）；已展开的回合不被收拢。
         const newTurns = displayTl.filter((t) => !liveSeenTurns.current.has(t.turn))
@@ -1555,15 +2045,30 @@ 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()
-      setLiveState({ phase: 'idle', error: null, timeline: null, eventCount: 0, lastActive: null, running: false })
+      setLiveState({ phase: 'idle', error: null, timeline: null, eventCount: 0, lastActive: null, running: false, health: null })
       if (liveTimer.current !== null) { clearInterval(liveTimer.current); liveTimer.current = null }
     }
     useEffect(() => () => { if (liveTimer.current !== null) clearInterval(liveTimer.current) }, [])
@@ -1779,13 +2284,13 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         h('h2', { className: 'sf-viewTitle', style: { flex: '1 1 auto', overflow: 'hidden', textOverflow: 'ellipsis' } },
           renaming
             ? h(RenameInline, {
-                initial: titleOverride || session.userTitle || session.title || '',
+                initial: titleOverride || liveTitleOf(session.id) || session.userTitle || session.title || '',
                 onSave: saveRename,
                 onCancel: () => setRenaming(false),
               })
             : h('span', { style: { display: 'inline-flex', alignItems: 'center', minWidth: 0 } },
-                h('span', { style: { overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }, title: (titleOverride || session.userTitle) ? session.title || STR.unknownTitle : undefined },
-                  titleOverride || session.userTitle || session.title || STR.unknownTitle),
+                h('span', { style: { overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }, title: (titleOverride || liveTitleOf(session.id) || session.userTitle) ? session.title || STR.unknownTitle : undefined },
+                  titleOverride || liveTitleOf(session.id) || session.userTitle || session.title || STR.unknownTitle),
                 h('button', {
                   className: 'sf-renameBtn', title: STR.rename,
                   onClick: () => setRenaming(true),
@@ -1795,10 +2300,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 → 折叠视图）。
@@ -1817,8 +2327,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)) +
@@ -1889,6 +2399,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           // M6 实时模式：sessions.history → derive 的完整折叠时间线（轮询刷新）。
           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.lastActive && h('span', { className: 'sf-muted', style: { flex: 'none' } }, STR.liveLastActive + ' ' + fmtTime(liveState.lastActive)),
@@ -1896,7 +2407,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 时折叠回合既无内容
@@ -2119,7 +2630,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
   // 内实时通道同构（结构信号运行判定 / 只折叠新回合 / 不传 hideHead），自包含实现。
   function SessionFlowLiveFallback(props) {
     const { sessionId, connection } = props
-    const [state, setState] = useState({ phase: 'loading', error: null, timeline: null, eventCount: 0, running: false })
+    const [state, setState] = useState({ phase: 'loading', error: null, timeline: null, eventCount: 0, running: false, health: null })
     const [collapsed, setCollapsed] = useState(() => new Set())
     const [activeTurn, setActiveTurn] = useState(null)
     const liveSeenTurns = useRef(new Set())
@@ -2140,7 +2651,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           return
         }
         const events = val.events.map((entry) => (entry && entry.event) || entry)
-        const derived = await api('derive', { events })
+        const derived = await api('derive', { events, now: Date.now() })
         if (!derived || !derived.ok) {
           setState((s) => ({ ...s, phase: 'error', error: (derived && derived.error) || STR.liveFail }))
           return
@@ -2149,6 +2660,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         setState({
           phase: 'ready', error: null, timeline: tl, eventCount: events.length,
           running: derived.running === true,
+          health: derived.health || null,
         })
         // 只折叠新出现的回合（默认折叠），已展开的保持用户状态（M6 经验）。
         const newTurns = tl.filter((t) => !liveSeenTurns.current.has(t.turn))
@@ -2168,7 +2680,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])
 
@@ -2184,6 +2696,7 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     return h('div', { className: 'sf-view' },
       h('div', { className: 'sf-viewHeader' },
         h('span', { className: 'sf-badge sf-badgeRun', style: { flex: 'none' } }, STR.liveActive),
+        healthBadge(state.health),
         h('span', { className: 'sf-liveText' }, STR.liveFallbackHint),
         h('button', { className: 'sf-btn sf-liveExitBtn', onClick: props.onRetry }, STR.retryArchive),
       ),
@@ -2202,6 +2715,32 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
   // ── 主视图（总览 ⇄ 详情）───────────────────────────────────────────
   function SessionFlowView(props) {
     const [detail, setDetail] = useState(null) // { session, searchQuery }
+    // 头部芯片直达意图（workbenchBridge）：收到会话 id → 总览数据就绪后自动进详情。
+    const [intentId, setIntentId] = useState(workbenchBridge.intent)
+    useEffect(() => workbenchBridge.subscribe((sid) => { setDetail(null); setIntentId(sid) }), [])
+    // ── 官方标题近实时同步（rename 对齐增强）──────────────────────────
+    // 自建 mux 下行流监听 session/projection(title) 帧：官方 rename / 自动标题生成后
+    // host 向每个 mux 消费者即时广播（value 为标题字符串），秒级同步、免等重扫。
+    const [liveTitles, setLiveTitles] = useState({}) // sessionId -> 最新官方标题
+    useEffect(() => {
+      const conn = props.connection
+      if (conn === undefined || conn.api === undefined || conn.api.events === undefined || typeof conn.api.events.mux !== 'function') return undefined
+      const ac = new AbortController()
+      ;(async () => {
+        try {
+          for await (const envelope of conn.api.events.mux({}, ac.signal)) {
+            const f = (envelope && envelope.payload) || envelope
+            if (!f || f.type !== 'session/projection' || f.key !== 'title') continue
+            const title = typeof f.value === 'string' ? f.value : (f.value && typeof f.value.title === 'string' ? f.value.title : '')
+            if (f.sessionId && title !== '') {
+              const sid = f.sessionId
+              setLiveTitles((prev) => (prev[sid] === title ? prev : { ...prev, [sid]: title }))
+            }
+          }
+        } catch (e) { /* 流断开/中止：静默（组件卸载或下次挂载时重建） */ }
+      })()
+      return () => ac.abort()
+    }, [props.connection])
 
     return detail === null
       ? h(SessionFlowOverview, {
@@ -2209,12 +2748,19 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
           onOpen: (session, searchQuery) => setDetail({ session, searchQuery }),
           onClose: props.onClose,
           sessions: props.sessions,
+          connection: props.connection,
+          liveTitles,
+          intentId,
+          // T3：意图消费后即清除（SessionFlowView 不随详情↔总览切换卸载，状态稳）——
+          // 防止「← 返回」重挂 Overview 时旧意图再次消费把用户拉回详情。
+          onIntentConsumed: () => setIntentId(null),
         })
       : h(SessionFlowDetail, {
           session: detail.session,
           initialSearchQuery: detail.searchQuery || '',
           sessions: props.sessions,
           connection: props.connection,
+          liveTitles,
           onBack: () => setDetail(null),
           onClose: props.onClose,
         })
@@ -2238,6 +2784,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 才有正确的视口内矩形。
@@ -2264,16 +2838,29 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
     const { sessions, onOpenWorkbench } = props
     const [entries, setEntries] = useState([]) // [{turn, seq, preview}] host 全量用户轮次
     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()
@@ -2305,7 +2892,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，不展示跨会话列表）。
@@ -2392,14 +2979,34 @@ 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
     }
 
@@ -2413,35 +3020,85 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
       setTimeout(() => setJumpFail(false), 2600)
     }
 
-    // active：视口内第一条 DOM 用户行 → 文本匹配条目索引高亮（阅读位置跟随）。
+    // 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) => {
@@ -2460,35 +3117,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) }, [])
     // 键盘聚焦跟随显示面板。
@@ -2496,6 +3236,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',
@@ -2505,12 +3248,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))
@@ -2518,37 +3261,68 @@ 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。
@@ -2569,27 +3343,171 @@ 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 resp = await conn.api.sessions.history({ sessionId: sid, mode: 'full', maxMessages: 400 })
+        const val = resp && resp.result && resp.result.value
+        if (val === undefined || !Array.isArray(val.events)) {
+          liveStore.lastState = { ...liveStateKeep(), phase: 'error', error: STR.liveFail }
+          if (liveStore.emit !== null) liveStore.emit(liveStore.lastState)
+          return
+        }
+        const events = val.events.map((entry) => (entry && entry.event) || entry)
+        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
@@ -2643,14 +3561,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),
@@ -2669,8 +3613,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,
@@ -2888,7 +3832,7 @@ 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)
       }
 
@@ -2947,6 +3891,48 @@ window.__ModuleLoader__.load({ id: 'dsh-session-flow', factory: (require) => {
         } catch (error) {
           console.error('[dsh-session-flow] conversation.view registration failed:', error)
         }
+        // 会话健康芯片：官方 conversation.session.header.actions 槽位（ui-jobs/ui-subagent 同款），
+        // order -9 紧随官方模式标识（agent-preset label, order -10）右侧。
+        // 点击芯片 → workbenchBridge 意图桥直达该会话详情。
+        try {
+          slots.inject('conversation.session.header.actions', () => slots.register({
+            name: 'conversation.session.header.actions',
+            id: 'session-flow-health',
+            order: -9,
+          }, (slotProps) => h(SessionHealthChip, {
+            sessionId: slotProps ? slotProps.sessionId : undefined,
+            sessions,
+            connection,
+            onOpen: () => {
+              const sid = slotProps && slotProps.sessionId
+              if (sid) workbenchBridge.open(sid)
+              controller.open()
+            },
+          })))
+        } 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') {
+            const 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）。
@@ -2965,66 +3951,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) {}
@@ -3066,7 +3996,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)
@@ -3078,7 +4007,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()
           }
@@ -3132,7 +4060,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) {}
         }