@hyzyn/dsh-docker 0.9.5 → 0.10.0

package/client-src/index.js

@@ -22,6 +22,13 @@ import { currentSessionIdOf } from './current-session.js'
 import { createLogBuffer, splitLogLines } from './log-buffer.js'
 import { createLogWindow, LOG_ROW_ESTIMATE_PX, LOG_WINDOW_OVERSCAN, LOG_HEIGHT_CACHE_LIMIT } from './log-window.js'
 import { subscribeLogStream, reconnectTail, LOG_RECONNECT_BASE_MS, LOG_RECONNECT_MAX_MS } from './log-stream.js'
+import { upsertElevationRecord, removeElevationRecord, markElevationGranted, pruneElevationRecords, buildMergedElevationText, mergeElevationCommands, joinElevationCommands, shouldOfferMerge } from './elevation.js'
+
+/**
+ * 「复制全部」按钮的反馈归属哨兵键：能力名不会取这个值，所以它与单条按钮的反馈天然不串。
+ * （`copiedKey` 逐能力隔离见卡片里那段注释。）
+ */
+const ELEVATION_COPY_ALL = '__all__'
 
 /* ================================ 国际化 ================================ */
 
@@ -351,7 +358,10 @@ const I18N_ZH = {
   'status.eventsClosed': '事件流已断开',
   'status.eventsStream': '事件流',
   'status.eventsEnded': '事件流已结束',
-  'status.backToListRefresh': '，列表回到 AUTO REFRESH / 手动刷新',
+  'status.backToListRefresh': '，列表回到 AUTO REFRESH / 手动刷新；活动条上点「重连」可重新订阅',
+  'btn.reconnectEvents': '重连',
+  'hint.reconnectEvents': '重新打开容器事件流（docker events）；列表刷新按钮也会一并重连',
+  'hint.eventsClosedNoAuto': '事件流断开后不会自己回来（EventSource 只在连接层抖动时自愈；docker events 进程退出属于终止态）——点它重连，或点右上角刷新列表',
   'hint.conversationHidden': ' · 会话在面板后面：关掉或最小化面板/终端即可看到',
   'msg.copied': '已复制：',
   'error.copyManual': '复制失败，请手动执行：',
@@ -453,6 +463,8 @@ const I18N_ZH = {
   'msg.saved': '已保存并热生效',
   'msg.savedDirty': '已保存并热生效（表单在保存期间有新编辑，未覆盖你正在输入的内容）',
   'error.saveFailed': '保存失败：',
+  'msg.connectLocalBusy': '正在连接本机…',
+  'error.connectLocalFailed': '连接本机失败：',
   'card.desc': '本机与 SSH 主机的容器与镜像：容器 / 镜像 / 网络 / 卷查看，默认只读，变更操作需显式开启。',
   'card.name': 'Docker 容器面板',
   'card.summary': '本机 / SSH 主机上的容器与镜像；默认只读，变更操作需显式开启',
@@ -474,6 +486,9 @@ const I18N_ZH = {
   'hint.capabilityNotGranted': '⚠ 宿主尚未授权：这两个开关现在打不开，点它会给出一条就地确认的命令（免重启）。关掉它们随时可用。',
   'badge.notEffective': '未生效：未获宿主授权',
   'elev.title': '就地授权（免重启）',
+  'elev.copyAll': '复制全部（{count} 条）',
+  'elev.copyAllHint': '每个能力各要一条命令。一次粘贴全部命令，执行后全部开关自动解锁（各自的探测周期内先后生效）。',
+  'elev.copyAllCopied': '已复制全部 {count} 条',
   'elev.lockedWhy': '本机任意进程都能发回环请求，所以「打开危险能力」这件事不能由这个页面自己说了算——必须在宿主的文件系统上确认一次。',
   'elev.step': '在宿主的终端里执行下一条命令，开关会自动解锁：',
   'elev.copy': '复制命令',
@@ -508,6 +523,8 @@ const I18N_ZH = {
   'hint.keyPath': '支持 ~ 与 ~/ 展开（不支持 ~user）；Windows 请写绝对路径',
   'placeholder.passwordSet': '（已设置，留空保持不变）',
   'btn.addTarget': '添加目标',
+  'btn.connectLocal': '连接本机',
+  'hint.connectLocal': '加一个指向宿主所在机器的本机目标并选中（已有本机目标则直接复用）；SSH 与自定义目标原样保留。',
   'hint.addTarget': 'SSH 目标推荐直接选 tty 终端面板的连接簿条目（凭证只需维护一处）；手填时密码 / 口令建议写 env:NAME（凭据引用：由官方凭据存储解析，缺失时退回环境变量）。',
   'section.tofu': 'SSH 主机密钥记录（TOFU）',
   'list.noHostKeys': '暂无记录 — 首次 SSH 连接成功后自动记录主机指纹（若 tty 已记录同一主机，会直接复用）。',
@@ -828,7 +845,10 @@ const I18N_EN = {
   'status.eventsClosed': 'Event stream closed',
   'status.eventsStream': 'Event stream',
   'status.eventsEnded': 'Event stream ended',
-  'status.backToListRefresh': ', the list returns to AUTO REFRESH / manual refresh',
+  'status.backToListRefresh': ', the list returns to AUTO REFRESH / manual refresh; hit “Reconnect” on the activity bar to resubscribe',
+  'btn.reconnectEvents': 'Reconnect',
+  'hint.reconnectEvents': 'Reopen the container event stream (docker events); the list refresh button reconnects it too',
+  'hint.eventsClosedNoAuto': 'A closed event stream does not come back on its own (EventSource only self-heals connection blips; the docker events process exiting is terminal) — click to reconnect, or hit refresh in the top right',
   'hint.conversationHidden': ' · the session is behind this panel: close or minimise the panel/terminal to see it',
   'msg.copied': 'Copied: ',
   'error.copyManual': 'Copy failed, run it manually: ',
@@ -930,6 +950,8 @@ const I18N_EN = {
   'msg.saved': 'Saved and applied live',
   'msg.savedDirty': 'Saved and applied live (the form got new edits while saving; what you were typing was not overwritten)',
   'error.saveFailed': 'Save failed: ',
+  'msg.connectLocalBusy': 'Connecting to the local Docker…',
+  'error.connectLocalFailed': 'Connecting local Docker failed: ',
   'card.desc': 'Containers and images on this machine and SSH hosts: containers / images / networks / volumes, read-only by default, changes must be enabled explicitly.',
   'card.name': 'Docker containers',
   'card.summary': 'Containers and images on this machine / SSH hosts; read-only by default, changes must be enabled explicitly',
@@ -951,6 +973,9 @@ const I18N_EN = {
   'hint.capabilityNotGranted': '⚠ Not granted by the host: these two switches cannot be turned on right now — clicking one gives you a command to confirm in place (no restart). Turning them off always works.',
   'badge.notEffective': 'Not effective: not granted by the host',
   'elev.title': 'Grant in place (no restart)',
+  'elev.copyAll': 'Copy all ({count})',
+  'elev.copyAllHint': 'Each capability needs its own command. Paste both lines at once; every switch unlocks by itself once they run (each on its own probe cycle).',
+  'elev.copyAllCopied': 'Copied all {count}',
   'elev.lockedWhy': 'Any local process can send loopback requests, so “turn on a dangerous capability” cannot be decided by this page alone — it has to be confirmed on the host’s filesystem once.',
   'elev.step': 'Run the command below in a terminal on the host and the switch unlocks by itself:',
   'elev.copy': 'Copy command',
@@ -985,6 +1010,8 @@ const I18N_EN = {
   'hint.keyPath': 'Supports ~ and ~/ expansion (not ~user); use absolute paths on Windows',
   'placeholder.passwordSet': '(already set, leave empty to keep)',
   'btn.addTarget': 'Add target',
+  'btn.connectLocal': 'Connect local',
+  'hint.connectLocal': 'Add a local target pointing at the machine running the host and select it (reuses an existing local target); SSH and custom targets stay untouched.',
   'hint.addTarget': 'For an SSH target, prefer picking a tty terminal panel bookmark (credentials live in one place); when filling in manually, write the password / passphrase as env:NAME (credential reference: resolved by the official credential store, falling back to the environment variable).',
   'section.tofu': 'SSH host key records (TOFU)',
   'list.noHostKeys': 'No records yet — the host fingerprint is recorded automatically after the first successful SSH connection (reused directly if tty already recorded the same host).',
@@ -1089,6 +1116,12 @@ async function request(path, init) {
 const api = {
   config: () => request('/config'),
   saveConfig: (patch) => request('/config', { method: 'POST', body: JSON.stringify(patch) }),
+  /**
+   * 一键连接本机（宿主同源证明要求 POST）：直接加一个 kind=local 目标并选中它，
+   * 返回 { result: { name, created, saved, reachable, serverVersion?, message }, config }。
+   * 与「设置卡片里手填一个本机目标」是**同一份宿主实现**（/connect-local ↔ connectLocal）。
+   */
+  connectLocal: () => request('/connect-local', { method: 'POST', body: '{}' }),
   targets: () => request('/targets'),
   probe: (target) => request('/probe', { method: 'POST', body: JSON.stringify({ target }) }),
   containers: (target, all) => request('/containers', { method: 'POST', body: JSON.stringify({ target, all }) }),
@@ -1532,12 +1565,38 @@ const PICK_MAX = 8
  */
 const PICK_MAX_SSH = 6
 
+/**
+ * 目标下拉里要不要列「＋ 连接本机」那一项。
+ *
+ * 入参是**渲染作用域里的目标列表**（与同一个下拉展开的 `<option>` 用同一份数据）——
+ * 刻意不读模块级 configCache：同一个下拉里「列了哪些目标」与「要不要多列这一项」必须同源，
+ * 否则会出现「列表里已经有本机目标、却又多列一项连接本机」这种自相矛盾。
+ *
+ * 两个条件缺一不可：
+ *   - `targets.length > 0`：一个目标都没有时，正文空态里已经有一个大按钮（那里才是它最该
+ *     出现的地方），下拉里再列一项就是同一个入口出现两次；
+ *   - 没有 `kind=local`：已经有了就不列（选择器里已经有那台本机了）。
+ */
+function shouldOfferConnectLocal(targets) {
+  return targets.length > 0 && !targets.some((item) => item.kind === 'local')
+}
+
 /** 目标是不是 SSH —— 决定聚合流的上限。读模块级 configCache，任何组件都能问。 */
 function isSshTarget(name) {
   const targets = configCache !== null && Array.isArray(configCache.targets) ? configCache.targets : []
   return targets.some((item) => item.name === name && item.kind === 'ssh')
 }
 
+/**
+ * 目标选择器里那一项「＋ 连接本机」的哨兵值。
+ *
+ * 为什么不用个普通字符串（如 `local`）：目标名是**用户自由填的**（sanitizeTargets 只限长度与
+ * 非空），任何可打印值都可能与真实目标重名——重名就意味着用户点「连接本机」反而切到了别的机器。
+ * 用 NUL 开头则不可能撞上：目标名来自输入框，NUL 进不去；而 `<option value>` 允许任意字符串，
+ * 比较是纯 JS 字符串比较，不经过任何会截断的路径。
+ */
+const CONNECT_LOCAL_OPTION = '\u0000connect-local'
+
 /** 由勾选数量推导「聚合日志」按钮是否可用 + 操作条提示文案。 */
 function pickDecide(count, ssh = false) {
   const max = ssh === true ? PICK_MAX_SSH : PICK_MAX
@@ -1895,6 +1954,19 @@ const EVENT_RECENT = 8
  */
 const EVENTS_REFRESH_DEBOUNCE_MS = 500
 
+/**
+ * 事件流处在「需要人工重连」的终止态吗（D160）。
+ *
+ * 抽成纯函数而不是写在组件里：离线冒烟的 React 桩把 `useState` 冻在初值上，组件里
+ * 那个 `eventsStatus` 永远是 `''`，遍历渲染树根本走不到重连按钮——判定必须能直接驱动。
+ *
+ * **只认 `closed`**：`open` / `connecting` / `reconnecting` 都还在自动恢复的路上；
+ * `unsupported`（环境没有 EventSource）重连必然再失败，给按钮等于骗人。
+ */
+function canReconnectEvents(status) {
+  return status === 'closed'
+}
+
 /** 新事件放最前（活动条按时间倒序读），超出上限丢最旧。 */
 function pushEvent(list, event, limit) {
   const next = [event, ...list]
@@ -5401,21 +5473,45 @@ window.__ModuleLoader__.load({
       const open = props.open === true
       const events = Array.isArray(props.events) ? props.events : []
       const recent = events.slice(0, EVENT_RECENT)
+      /*
+       * 断开时给一个显式的「重连」（D160）：这条流进了 closed 就是**终止态**，没有任何
+       * 东西会再开它；而活动条上那句「事件流已断开」看着却像会自愈（EventSource 平时
+       * 确实会自动重连），用户点工具条的 ⟳ 也不见好。
+       * `unsupported` 刻意不给这个按钮：那个环境根本没有 EventSource，重连必然还是失败。
+       */
+      const canReconnect = canReconnectEvents(props.status)
       return jsxs('div', { className: 'dk_activity', 'data-open': open ? '1' : '0', children: [
-        jsx('button', {
-          type: 'button',
-          className: 'dk_activityHead',
-          'aria-expanded': open,
-          title: t('hint.eventsToggle'),
-          onClick: props.onToggle,
-          children: [
-            jsx('span', { className: 'dk_activityTitle', children: t('panel.activity') }),
-            jsx('span', { className: 'dk_activityState', 'data-state': props.status ?? '', children: props.statusText ?? '' }),
-            jsx('span', { className: 'dk_headerSpacer' }),
-            jsx('span', { className: 'dk_hint', children: events.length === 0 ? t('list.noEvents') : t('list.recentEvents', { recent: recent.length, total: events.length }) }),
-            jsx('span', { className: 'dk_activityChevron', dangerouslySetInnerHTML: { __html: ICON_CHEVRON } }),
-          ],
-        }),
+        /*
+         * 折叠按钮与「重连」是**兄弟**，不是嵌套——按钮里嵌按钮既不是合法 HTML，
+         * 也会让读屏把「折叠」与「重连」两个动作听成一个。
+         */
+        jsxs('div', { className: 'dk_activityHeadRow', children: [
+          jsx('button', {
+            type: 'button',
+            className: 'dk_activityHead',
+            'aria-expanded': open,
+            title: t('hint.eventsToggle'),
+            onClick: props.onToggle,
+            children: [
+              jsx('span', { className: 'dk_activityTitle', children: t('panel.activity') }),
+              jsx('span', { className: 'dk_activityState', 'data-state': props.status ?? '', children: props.statusText ?? '' }),
+              jsx('span', { className: 'dk_headerSpacer' }),
+              // 断开时右侧那句「暂无事件」是误导（不是「没动静」，是「听不见了」），
+              // 换成一句说明为什么需要手动重连
+              jsx('span', { className: 'dk_hint', children: canReconnect
+                ? t('hint.eventsClosedNoAuto')
+                : (events.length === 0 ? t('list.noEvents') : t('list.recentEvents', { recent: recent.length, total: events.length })) }),
+              jsx('span', { className: 'dk_activityChevron', dangerouslySetInnerHTML: { __html: ICON_CHEVRON } }),
+            ],
+          }, 'head'),
+          canReconnect ? jsx('button', {
+            type: 'button',
+            className: 'dk_activityRetry',
+            title: t('hint.reconnectEvents'),
+            onClick: props.onReconnect,
+            children: t('btn.reconnectEvents'),
+          }, 'retry') : null,
+        ] }),
         open === false ? null : (
           recent.length === 0
             ? jsx('div', { className: 'dk_activityEmpty', children: t('list.noEventsHint') })
@@ -5687,6 +5783,8 @@ window.__ModuleLoader__.load({
       /** 已进入聚合视图（items 由 pickItems(containers, pickedIds) 现算）。 */
       const [aggregateOpen, setAggregateOpen] = useState(false)
       const [loading, setLoading] = useState(false)
+      /** 「连接本机」请求在飞：按钮转圈 + 置灰，避免连点造成一串并发写配置。 */
+      const [connectLocalBusy, setConnectLocalBusy] = useState(false)
       const [error, setError] = useState('')
       const [notice, setNotice] = useState('')
       const [all, setAll] = usePanelState('all', true)
@@ -5701,11 +5799,30 @@ window.__ModuleLoader__.load({
       /** 面板是否可见（S3）：折叠的 tab 不建流；模态 / dock 形态恒为 true。 */
       const active = usePanelActive()
       const [eventsStatus, setEventsStatus] = useState('')
+      /**
+       * 手动重连令牌（D160）：事件流断开后是**终止态**（EventSource 只在连接层抖动时自愈；
+       * `docker events` 进程退出 / 服务端发 `end` 帧都会走 close()，之后没有东西会再开流）。
+       *
+       * 为什么是计数器而不是布尔：布尔翻回 false 时 effect 看不出「又要求了一次」——
+       * 连点两次重连、或在已经 closed 的状态下再点一次都必须重开。自增的值天然两两不同。
+       */
+      const [eventsReconnect, setEventsReconnect] = useState(0)
       const [activityOpen, setActivityOpen] = usePanelState('activityOpen', true)
       /** 建流时用的列表加载器（用 ref 拿最新的，避免 all 一变就重连事件流）。 */
       const loadContainersRef = useRef(null)
       /** 事件流当前绑定的目标：换目标要清空活动条缓冲，免得混着两台主机的事件。 */
       const eventsTargetRef = useRef('')
+      /**
+       * 当前目标上是否**成功开过**事件流（D160）：重连补偿的判据。
+       *
+       * 用 ref 而不是 state：它只影响下一次建流时的补偿决定，不该触发重渲染；
+       * 而且必须**跨 effect 运行存活**——`eventsReconnect` 一变 effect 就重跑，
+       * 局部变量会归零，手动重连就会被误判成「首次」而不补偿。
+       * 换目标时重置（见 events effect），新目标的第一次 open 不该补。
+       */
+      const eventsOpenedRef = useRef({ opened: false })
+      /** 上一次建流时看到的**手动**重连令牌（D160）：用来认出「这次 effect 跑是用户点的重连」。 */
+      const eventsReconnectRef = useRef(0)
       /** 打开中的容器详情：{ id, tab, item }（item 为快照，列表刷新后优先用新数据）。 */
       const [detail, setDetail] = usePanelState('detail', null)
       const [refreshToken, setRefreshToken] = useState(0)
@@ -6167,6 +6284,64 @@ window.__ModuleLoader__.load({
         props.onTargetChange?.(targetLabel(name))
       }
 
+      /**
+       * 「连接本机」：面板工具条 / 无目标空态那一个按钮的唯一实现。
+       *
+       * 三件事一起做，缺任何一件这个按钮都不成立：
+       *   1. 调宿主的 `POST /connect-local`——它才是**唯一**写配置的地方（复用已有本机目标、
+       *      否则用确定性无冲突名新建；settings 不可用 / 保存失败会带原因返回）；
+       *   2. 用响应里的新 config 推送 `publishConfig`（已挂载的面板与连接栏立刻看到新目标）
+       *      并重拉一次 /targets（下拉里的 `name · 本机` label 只有它算得出来）；
+       *   3. 立刻把 target 切到那条本机目标（用户点它就是想说「看这台」），并清掉上一台的
+       *      错误 / 勾选 / 执行中标记——与手动换目标同一套清理。
+       *
+       * 探测结果（daemon 不可达 / CLI 缺失 / socket 无权）走 `notice`：**保存成功但连不上**
+       * 既不能被说成失败（目标真的加上了），也不能不提（否则用户只看到空列表）。
+       */
+      const connectLocal = useCallback(() => {
+        if (connectLocalBusy) return
+        setConnectLocalBusy(true)
+        setNotice(t('msg.connectLocalBusy'))
+        api.connectLocal().then((payload) => {
+          if (!mountedRef.current) return
+          const result = payload.result ?? {}
+          const config_ = payload.config
+          if (config_ !== null && typeof config_ === 'object') {
+            setConfig(config_)
+            primeTargetsCache(config_)
+            publishConfig(config_)
+          }
+          const name = typeof result.name === 'string' ? result.name : ''
+          if (name !== '') {
+            setTarget(name)
+            setSessionScoped(false)
+            setError('')
+            // 「连接本机」= 去看这台主机：容器列表页 + 同一套换目标清理
+            setView('containers')
+            setDetail(null)
+            resetPick()
+            setPending({})
+            props.onTargetChange?.(targetLabel(name))
+          }
+          setNotice(typeof result.message === 'string' && result.message !== '' ? result.message : t('msg.saved'))
+          // 下拉里的 label 只有 /targets 算得出来（config 快照里没有 label 字段）
+          void api.targets().then((targetsPayload) => {
+            if (!mountedRef.current) return
+            const rows = targetsPayload.targets ?? []
+            setTargets(rows)
+            targetsCache = rows
+          }).catch(() => { /* 失败不连坐：上面已按 config 校正过选中项 */ })
+          // 目标增删会影响 tty 连接栏按钮：刷新解析后的目标列表缓存
+          void refreshTargetsCache()
+        }).catch((error_) => {
+          // 设置存储不可用 / 保存失败 / 非 POST 同源拒绝：把宿主给的原因原样带出来
+          if (mountedRef.current) setError(t('error.connectLocalFailed') + error_.message)
+          setNotice('')
+        }).finally(() => {
+          if (mountedRef.current) setConnectLocalBusy(false)
+        })
+      }, [connectLocalBusy])
+
       const refresh = useCallback(() => {
         // 五个列表各有自己的加载器；容器以外的都变化慢，但都走同一条「切页 / 切目标即刷」
         if (view === 'overview') loadOverview()
@@ -6177,6 +6352,20 @@ window.__ModuleLoader__.load({
         setRefreshToken((value) => value + 1)
       }, [view, loadOverview, loadContainers, loadImages, loadNetworks, loadVolumes])
 
+      /**
+       * 工具条的 ⟳：**手动**刷新，比 `refresh()` 多做一件事——重开事件流（D160）。
+       *
+       * 为什么与 `refresh()` 分开：AUTO REFRESH 轮询也调 `refresh()`（默认 5 秒一次），
+       * 若把重连塞进去，一条因为 docker events 退出而进入终止态的流会被轮询不断重开——
+       * 既掩盖了「它已经断了」，又让每次轮询都多建一条 SSE。用户点 ⟳ 是**明确的**
+       * 「按现在的情况重新来一遍」，那时重连才对；自动轮询没有这个语义。
+       * `eventsReconnect` 自增即触发事件流 effect 重跑（见那里的依赖数组）。
+       */
+      const refreshManually = useCallback(() => {
+        refresh()
+        setEventsReconnect((value) => value + 1)
+      }, [refresh])
+
       useEffect(() => {
         // 总览有自己的取数 effect（它不依赖任何单个 target），这里只服务单目标视图
         if (view === 'overview') return undefined
@@ -6243,16 +6432,36 @@ window.__ModuleLoader__.load({
           return undefined
         }
         // 换目标就清空缓冲：活动条里不该混着另一台主机的事件
-        if (eventsTargetRef.current !== target) {
+        const sameTarget = eventsTargetRef.current === target
+        if (!sameTarget) {
           eventsTargetRef.current = target
           setEvents([])
+          eventsOpenedRef.current.opened = false
         }
+        /*
+         * 这一次 effect 跑是不是**用户点了「重连」**（令牌变了就是）。必须在建流前算好
+         * 并记下，否则下一次跑就没得比了。
+         */
+        const manualReconnect = eventsReconnect !== eventsReconnectRef.current
+        eventsReconnectRef.current = eventsReconnect
+        /*
+         * `hadOpen` 初值决定「这一次 open 要不要补一次全量列表刷新」（重连补偿）。
+         *
+         * 判据是**同一个目标上已经成功开过一次**，而不是「本次 effect 运行内开过」：
+         * 后者会让手动重连（D160）与折叠后展开都退化成「首次」，而这两条路径恰恰
+         * 都是「流断了一段时间、列表可能已经落后」——正是补偿要覆盖的情形。
+         * 换目标仍算首次：那边 loadContainers 的 effect 刚拉过一份新的。
+         *
+         * `manualReconnect` 单独兜一种情形：daemon 全程没起时流**从未 open 过**，
+         * 只按 `opened` 判就会把重连成功后的补偿一起省掉——那时列表还停在「这个目标
+         * 的数据没读到」，活动条却已经绿了，看着像好了其实没好。
+         */
+        let hadOpen = sameTarget && (eventsOpenedRef.current.opened || manualReconnect)
         setEventsStatus('connecting')
         const debounced = makeDebounced(EVENTS_REFRESH_DEBOUNCE_MS, () => {
           const load = loadContainersRef.current
           if (load !== null) load()
         })
-        let hadOpen = false
         const es = new EventSource(streamUrl('/events/stream', { target }))
         let closed = false
         const close = () => {
@@ -6301,12 +6510,13 @@ window.__ModuleLoader__.load({
             void loadContainersRef.current?.()
           }
           hadOpen = true
+          eventsOpenedRef.current.opened = true
         }
         return () => {
           close()
           debounced.cancel()
         }
-      }, [active, view, target])
+      }, [active, view, target, eventsReconnect])
 
       useEffect(() => {
         if (notice === '') return undefined
@@ -6617,6 +6827,28 @@ window.__ModuleLoader__.load({
         return found.label === undefined ? name : name + ' · ' + found.label
       }
 
+      /**
+       * 渲染「连接本机」按钮——**只出现在「一个目标都没有」的空态里**。
+       *
+       * 为什么不做成常驻的工具条按钮（第一版就是这么写的，用户当场指出多余）：它解决的
+       * 唯一问题是「面板全空、只让你去设置卡片手配」，而**已经有任何目标**时，选择器里
+       * 那台就是用户要用的那台——这时再挂一个按钮，既占掉选择器右边的位置，又要靠强调色
+       * 招人点，属于纯噪音。所以：没有任何目标 = 它是最短路径（主按钮）；有目标 = 不出现。
+       *
+       * 正因为只在 `target === ''` 的空态里渲染，这里**没有**「已有本机目标」的分支：
+       * 列表非空时 `chooseInitialTarget` 一定会选中一个目标，走不到这个空态；空态 ⇒ 没有
+       * 本机目标可复用 ⇒ 这一下必然是「新建并选中」（宿主侧用 `local` / `local-2`… 的确定性
+       * 名字，并自己处理「万一已经有」的复用）。
+       */
+      const connectLocalButton = (className) => jsx('button', {
+        type: 'button',
+        className,
+        disabled: connectLocalBusy,
+        title: t('btn.connectLocal') + ' — ' + t('hint.connectLocal'),
+        onClick: connectLocal,
+        children: connectLocalBusy ? t('msg.connectLocalBusy') : t('btn.connectLocal'),
+      }, 'connectLocal')
+
       const empty = () => {
         if (loading) return jsx('div', { className: 'dk_empty', children: [jsx('span', { className: 'dk_spin' }), jsx('div', { children: t('list.loading') })] })
         if (target === '') {
@@ -6629,6 +6861,8 @@ window.__ModuleLoader__.load({
           return jsxs('div', { className: 'dk_empty', children: [
             jsx('div', { className: 'dk_emptyTitle', children: t('list.noTargetsConfigured') }),
             jsx('div', { className: 'dk_emptyHint', children: t('hint.addTargetEmpty') }),
+            // 一键路径就放在这里：面板全空、「一个目标都没有」正是这个按钮最该出现的地方
+            connectLocalButton('dk_btn dk_btnPrimary'),
           ] })
         }
         // 读取失败时列表本来就会被清空（切目标失败尤其如此）：此时别把空列表说成
@@ -6891,7 +7125,7 @@ window.__ModuleLoader__.load({
               config?.allowMutations === true ? null : jsx('span', { className: 'dk_badge', 'data-state': 'paused', children: t('badge.readOnly') }),
               jsx('span', { className: 'dk_headerSpacer' }),
               // 刷新中让图标自己转（loading 也用于镜像列表）
-              selected !== null ? null : jsx('button', { type: 'button', className: 'dk_iconBtn', title: t('btn.refreshList'), 'data-spin': loading ? '1' : undefined, onClick: refresh, children: jsx('span', { className: 'dk_iconGlyph', dangerouslySetInnerHTML: { __html: ICON_REFRESH } }) }),
+              selected !== null ? null : jsx('button', { type: 'button', className: 'dk_iconBtn', title: t('btn.refreshList'), 'data-spin': loading ? '1' : undefined, onClick: refreshManually, children: jsx('span', { className: 'dk_iconGlyph', dangerouslySetInnerHTML: { __html: ICON_REFRESH } }) }),
               jsx('button', { type: 'button', className: 'dk_iconBtn', title: t('btn.closePanel'), onClick: requestClose, children: jsx('span', { dangerouslySetInnerHTML: { __html: ICON_CLOSE } }) }),
             ] }),
             /* 工具栏：只在列表视图显示；容器详情是整栏视图，列表筛选在这里没有意义 */
@@ -6901,6 +7135,15 @@ window.__ModuleLoader__.load({
                 // 总览没有「当前目标」这回事：选择器回落成一条带说明的空值项
                 value: view === 'overview' ? '' : target,
                 onChange: (event) => {
+                  /*
+                   * 下拉里的「＋ 连接本机」哨兵项：它不是一个目标，选中它等于「我想加一台本机」。
+                   * 必须**在**下面那套换目标逻辑之前拦下——否则 setTarget('\0connect-local') 会把
+                   * 当前目标换成一个不存在的名字，面板随即报「未知目标」。
+                   */
+                  if (event.target.value === CONNECT_LOCAL_OPTION) {
+                    connectLocal()
+                    return
+                  }
                   setTarget(event.target.value)
                   // 用户手动选了目标 = 会话级「未匹配」状态结束（D23）：此后 staleList
                   // 的锁与胶囊照常工作，旧目标卡片不再可点
@@ -6924,6 +7167,20 @@ window.__ModuleLoader__.load({
                     : (target === '' ? [jsx('option', { value: '', children: t('option.noTargetSelected') }, '__none')] : [])),
                   ...(targets.length === 0 && target !== '' ? [{ name: target, label: undefined }] : targets)
                     .map((item) => jsx('option', { value: item.name, children: targetLabel(item.name) }, item.name)),
+                  /*
+                   * 「＋ 连接本机」放在列表**末尾**（就是用户找机器时会看的地方）：
+                   *   - 与工具条那版不同，它不占任何常驻位置，只有真的点开下拉才出现；
+                   *   - `targets.length > 0` 才出现：一个目标都没有时，正文空态里已经有一个
+                   *     大按钮（那里才是它最该出现的地方），这里再列一项等于同一入口出现两次；
+                   *   - 已经有本机目标时也不出现（选择器里已经有它了，再列一项等于重复）；
+                   *   - 总览视图没有「当前目标」，但仍可以加目标，所以不排除 overview。
+                   * `disabled` 复用 busy：请求在飞时不给点第二次（与按钮那版防连点一致）。
+                   */
+                  shouldOfferConnectLocal(targets) ? jsx('option', {
+                    value: CONNECT_LOCAL_OPTION,
+                    disabled: connectLocalBusy,
+                    children: connectLocalBusy ? t('msg.connectLocalBusy') : '+ ' + t('btn.connectLocal'),
+                  }, '__connectLocal') : null,
                 ],
               }),
               /*
@@ -7066,7 +7323,7 @@ window.__ModuleLoader__.load({
               docked ? jsxs('div', { className: 'dk_toolbarEnd', children: [
                 config?.allowMutations !== true ? jsx('span', { className: 'dk_badge', 'data-state': 'paused', children: t('badge.readOnly') }, 'readonly') : null,
                 // 刷新中图标自己转，所以这里不再另挂 spinner
-                jsx('button', { type: 'button', className: 'dk_iconBtn', title: t('btn.refreshList'), 'data-spin': loading ? '1' : undefined, onClick: refresh, children: jsx('span', { className: 'dk_iconGlyph', dangerouslySetInnerHTML: { __html: ICON_REFRESH } }) }, 'refresh'),
+                jsx('button', { type: 'button', className: 'dk_iconBtn', title: t('btn.refreshList'), 'data-spin': loading ? '1' : undefined, onClick: refreshManually, children: jsx('span', { className: 'dk_iconGlyph', dangerouslySetInnerHTML: { __html: ICON_REFRESH } }) }, 'refresh'),
               ] }) : null,
             ] }),
             /*
@@ -7131,6 +7388,9 @@ window.__ModuleLoader__.load({
                   statusText: eventsStatusText(),
                   open: activityOpen,
                   onToggle: () => setActivityOpen((value) => !value),
+                  // 只重开事件流，不顺带刷列表：列表有自己的 ⟳ 与 AUTO REFRESH，
+                  // 而用户点这句「重连」想救的就是那条听不见事件的活动条
+                  onReconnect: () => setEventsReconnect((value) => value + 1),
                 }, 'activity') : null,
                 body(),
               ] }),
@@ -7287,6 +7547,118 @@ window.__ModuleLoader__.load({
      * 设置卡片
      * ------------------------------------------------------------------ */
 
+    /** 能力开关名 → 宿主侧环境变量名（「另一种方式」那一栏要写出具体变量名）。 */
+    const CAPABILITY_ENV = {
+      allowMutations: 'DSH_DOCKER_ALLOW_MUTATIONS',
+      allowExec: 'DSH_DOCKER_ALLOW_EXEC',
+    }
+
+    /** 能力名 → 开关文案（面板标题靠它）。 */
+    function capabilityLabelOf(capability) {
+      return capability === 'allowMutations' ? t('check.allowMutations') : t('check.allowExec')
+    }
+
+    /**
+     * 就地提权面板组——**纯渲染函数**（入参是纯数据 + 一组回调，返回 jsx 树），刻意不做成组件：
+     * 离线冒烟的 React 桩把 `useState` 冻在初值上、`useEffect` 是空实现，「两个能力同时 pending」
+     * 这件事在组件里根本走不到，而它正是本次改造要保证的行为。做成普通函数后，用例可以真的调用它、
+     * 遍历返回的 jsx 树、并**驱动合并按钮的 onClick** 断言被复制下去的字节（见 scripts/client-smoke.mjs）。
+     *
+     * 结构：合并复制行（≥2 个能力 pending 时才有）→ 逐能力堆叠的面板（已授权的留痕不渲染）。
+     */
+    function elevationPanelsView(records, options) {
+      const list = Array.isArray(records) ? records : []
+      const now = options.now === undefined ? Date.now() : options.now
+      const pending = list.filter((record) => record !== null && record !== undefined && record.granted !== true)
+      if (pending.length === 0) return null
+      const merged = mergeElevationCommands(list, now)
+      const panel = (record) => {
+        const capability = String(record.capability)
+        const seconds = Number.isFinite(record.expiresAt)
+          ? Math.max(0, Math.ceil((Number(record.expiresAt) - now) / 1000))
+          : 0
+        return jsxs('div', { className: 'dk_elevPanel', children: [
+          jsxs('div', { className: 'dk_row', children: [
+            jsx('span', { className: 'dk_label', children: t('elev.title') + ' · ' + capabilityLabelOf(capability) }),
+            jsx('button', {
+              type: 'button',
+              className: 'dk_btn',
+              onClick: () => options.onClose(capability),
+              children: t('elev.close'),
+            }, 'close'),
+          ] }),
+          jsx('span', { className: 'dk_hint', children: t('elev.lockedWhy') }),
+          record.error === undefined
+            ? null
+            : jsx('span', { className: 'dk_hint dk_hintWarn', children: t('elev.error') + String(record.error) }),
+          record.command === undefined
+            ? null
+            : jsxs('div', { className: 'dk_elevSteps', children: [
+              jsx('span', { className: 'dk_hint', children: t('elev.step') }),
+              jsx('code', { className: 'dk_elevCommand', children: String(record.command) }),
+              /*
+               * 动作行：复制 / 重新生成 / 倒计时**并排一行、紧贴命令**。
+               *
+               * 早先这三样各自占一条栅格行，而且「重新生成」被「282 秒后失效」「等待确认…」两行
+               * 说明文字隔在下面——2026-09-27 的真机报告（Windows）里那块看上去就是散的：
+               * 按钮离自己的命令越远，越像「不知道点了会发生什么」。命令与它的按钮是一件事（docker D149）。
+               */
+              jsxs('div', { className: 'dk_elevActions', children: [
+                jsx('button', {
+                  type: 'button',
+                  className: 'dk_btn dk_btnPrimary',
+                  // 复制反馈**逐能力**隔离：这个按钮只认自己能力的键
+                  onClick: () => options.onCopy(capability, String(record.command)),
+                  children: options.copiedKey === capability ? t('elev.copied') : t('elev.copy'),
+                }, 'copy'),
+                jsx('button', {
+                  type: 'button',
+                  className: 'dk_btn',
+                  onClick: () => options.onRegenerate(capability),
+                  children: t('elev.regenerate'),
+                }, 'regen'),
+                jsx('span', {
+                  className: seconds > 0 ? 'dk_hint' : 'dk_hint dk_hintWarn',
+                  children: seconds > 0 ? t('elev.expiresIn', { sec: seconds }) : t('elev.expired'),
+                }),
+              ] }),
+              jsx('span', { className: 'dk_hint', children: t('elev.waiting') }),
+              jsxs('details', { className: 'dk_elevOther', children: [
+                jsx('summary', { children: t('elev.otherWay') }),
+                jsx('span', {
+                  className: 'dk_hint',
+                  children: t('elev.envHow', { env: CAPABILITY_ENV[capability] ?? '' }),
+                }),
+              ] }),
+            ] }),
+          options.configured(capability) === true
+            ? jsx('button', {
+              type: 'button',
+              className: 'dk_btn',
+              onClick: () => options.onDisableFirst(capability),
+              children: t('elev.disableFirst'),
+            }, 'disable')
+            : null,
+        ] })
+      }
+      return jsxs('div', { className: 'dk_elevPanels', children: [
+        shouldOfferMerge(list, now)
+          ? jsxs('div', { className: 'dk_elevMerge', children: [
+            jsx('button', {
+              type: 'button',
+              className: 'dk_btn dk_btnPrimary',
+              onClick: () => options.onCopyAll(joinElevationCommands(merged), merged.length),
+              children: options.copiedKey === ELEVATION_COPY_ALL
+                ? t('elev.copyAllCopied', { count: merged.length })
+                : t('elev.copyAll', { count: merged.length }),
+            }, 'copyAll'),
+            jsx('span', { className: 'dk_hint', children: t('elev.copyAllHint') }),
+          ] })
+          : null,
+        ...pending.map((record) => panel(record)),
+      ] })
+    }
+
     function DockerSettingsCard(props) {
       // DSH ≥0.1.6 的插件配置页把同一条目按 view 渲染两次：summary 一句话摘要、page 完整表单。
       // 旧版（≤0.1.5）的 settings.plugin.item 卡片不带 view，走原有可折叠卡片分支。
@@ -7318,10 +7690,26 @@ window.__ModuleLoader__.load({
        * 就地提权（见 kit 的 elevation.ts）：点开关 → 面板给出一条「在宿主上落地一个随机名文件」的
        * 命令 → 宿主发现文件即授权，免重启。状态放在卡片里而不是子组件里：离线冒烟的 React 桩不执行
        * 函数组件体（见文件里其它地方的说明），状态留在卡片里才测得动。
+       *
+       * **逐能力**记录（数组，按发起顺序）而不是单槽：面板开着时再点另一个开关，单槽会把前一个
+       * 能力的面板**替换**掉——它的命令从界面消失（宿主侧 challenge 仍 pending），用户于是要在宿主
+       * 终端粘贴两次（2026-09-26 截图实测：两次授权差 14 秒）。逐能力记录让两块面板同时在场，
+       * 顶部出一个「复制全部」。纯逻辑在 `client-src/elevation.js`（冒烟能直接驱动）。
+       *
+       * 为什么不做「kit 侧 begin 返回合并命令」（备选方案，已否）：`finishElevation` 只处理**被轮询
+       * 到的那个**能力，合并命令会让另一个能力停在「宿主已授权、配置开关没开」的半状态；还要处理
+       * 两条独立探测定时器之间的授权竞态。客户端合并零 API 变更、零新安全面——kit 的
+       * begin / status / revoke 契约一字不动（nonce 仍只出现在 begin 响应里）。
        */
-      const [elevation, setElevation] = useState(null)
+      const [elevations, setElevations] = useState([])
       const [elevationNotice, setElevationNotice] = useState('')
-      const [copied, setCopied] = useState(false)
+      /**
+       * 复制反馈的归属键（**不是**布尔）：单条按钮传自己的能力名、合并按钮传哨兵
+       * `ELEVATION_COPY_ALL`，渲染时各自判自己的键——于是「复制了 A」不会让 B 的按钮也显示
+       * 「已复制」，而「复制全部」也不会让每一块面板都亮起来（改前是一个全局 `copied` 布尔，
+       * 两个按钮会一起变成已复制）。同一时刻只留一处反馈是刻意的：它说的是「你刚复制的是哪一份」。
+       */
+      const [copiedKey, setCopiedKey] = useState('')
       /** 每秒推进一次的计数：只为了让「还剩 N 秒」自己走（读的是渲染期的时间差）。 */
       const [nowTick, setNowTick] = useState(0)
       /** 授权到达后要「先把开关写进表单、再自动保存」：保存读的是表单镜像，得等一次提交。 */
@@ -7444,12 +7832,6 @@ window.__ModuleLoader__.load({
 
       /* ---------------- 就地提权（capability elevation） ---------------- */
 
-      /** 能力开关名 → 宿主侧环境变量名（「另一种方式」那一栏要写出具体变量名）。 */
-      const CAPABILITY_ENV = {
-        allowMutations: 'DSH_DOCKER_ALLOW_MUTATIONS',
-        allowExec: 'DSH_DOCKER_ALLOW_EXEC',
-      }
-
       /**
        * 快照 → 表单：能力开关在表单里存**配置值**（用户写下的那个），不是快照里的有效值。
        *
@@ -7488,8 +7870,18 @@ window.__ModuleLoader__.load({
        * 一起写进去。脏的时候只把开关置上并提示「点保存生效」——不替用户做决定。
        */
       const finishElevation = (capability) => {
-        setElevation(null)
-        setCopied(false)
+        /*
+         * **不删记录**，只把它标成已授权并把命令清掉（面板据此消失）。为什么留着这条痕迹：
+         * 合并按钮的存续跟着「面板组里有过几个能力」，不是跟着当前还剩几条命令——两个能力
+         * 都点过之后，其中一个先解锁，按钮要留着把**剩下那条**交给用户（此时再让他回单条面板
+         * 里找命令，等于把刚刚那次「一次粘贴」的动作拆回去）。两个都解锁后组里没有可复制命令，
+         * 按钮自然消失（见 shouldOfferMerge）。
+         *
+         * 反向也成立：「单个 pending → 无合并按钮」——只动过一个开关时组里只有一条记录，
+         * 那条命令就在它自己的面板里，不需要一个「复制全部（1 条）」的按钮。
+         */
+        setElevations((current) => markElevationGranted(current, capability))
+        setCopiedKey('')
         const clean = JSON.stringify(toPayload(formRef.current)) === cleanPayloadRef.current
         setForm((current) => (current === null ? current : { ...current, [capability]: true }))
         setElevationNotice(clean ? t('elev.granted') : t('elev.grantedNeedSave'))
@@ -7499,19 +7891,37 @@ window.__ModuleLoader__.load({
 
       const beginElevation = (capability) => {
         setElevationNotice('')
-        setCopied(false)
-        setElevation({ capability })
+        setCopiedKey('')
+        // 只增改**这一个**能力的记录，别的 pending 原样留着（面板不再被替换）
+        setElevations((current) => upsertElevationRecord(current, capability, {
+          capability,
+          command: undefined,
+          expiresAt: undefined,
+          error: undefined,
+          // 清掉上一轮的「已授权」痕迹：撤销授权后再点这个开关要能重新出面板
+          granted: false,
+        }))
         api.elevateBegin(capability).then((result) => {
           if (result !== null && result.status === 'granted') {
             finishElevation(capability)
             return
           }
           if (result !== null && result.status === 'pending') {
-            setElevation({ capability, command: String(result.command), expiresAt: Number(result.expiresAt) })
+            setElevations((current) => upsertElevationRecord(current, capability, {
+              capability,
+              command: String(result.command),
+              expiresAt: Number(result.expiresAt),
+            }))
             return
           }
-          setElevation({ capability, error: String((result && result.error) ?? '') })
-        }).catch((error) => setElevation({ capability, error: String(error.message) }))
+          setElevations((current) => upsertElevationRecord(current, capability, {
+            capability,
+            error: String((result && result.error) ?? ''),
+          }))
+        }).catch((error) => setElevations((current) => upsertElevationRecord(current, capability, {
+          capability,
+          error: String(error.message),
+        })))
       }
 
       const revokeElevation = (capability) => {
@@ -7522,14 +7932,36 @@ window.__ModuleLoader__.load({
         }).catch((error) => setElevationNotice(t('elev.error') + String(error.message)))
       }
 
-      /** 复制命令：拿不到剪贴板（老宿主 / 非安全上下文）时退回「请手动复制」。 */
-      const copyCommand = (command) => {
+      /**
+       * 复制命令：拿不到剪贴板（老宿主 / 非安全上下文）时退回「请手动复制」。
+       *
+       * `key` 是反馈的归属：单条按钮传能力名，合并按钮传 `ELEVATION_COPY_ALL`——
+       * 于是「复制了 A」不会让 B 的按钮也显示「已复制」（早先是一个全局 `copied`）。
+       */
+      const copyCommand = (key, command) => {
         const clipboard = typeof navigator === 'undefined' ? undefined : navigator.clipboard
         if (clipboard === undefined || typeof clipboard.writeText !== 'function') {
           setElevationNotice(t('elev.copyManual'))
           return
         }
-        clipboard.writeText(command).then(() => setCopied(true)).catch(() => setElevationNotice(t('elev.copyManual')))
+        clipboard.writeText(command).then(() => setCopiedKey(key)).catch(() => setElevationNotice(t('elev.copyManual')))
+      }
+
+      /**
+       * 合并复制：把所有**仍 pending**（未过期、已拿到命令）的命令按发起顺序用换行连接后一次复制。
+       *
+       * 命令的取用 / 排序 / 连接全在纯函数里（`client-src/elevation.js` 的 `buildMergedElevationText`
+       * 与 `joinElevationCommands`），这里只负责把它交给剪贴板。连接方式为什么是换行而不是 `&&` / `;`：
+       * bash / zsh / PowerShell / cmd 粘贴多行都逐行执行，平台无关；`&&` 在 PS 5.1 上不认，`;` 在 cmd
+       * 上不认。文案只说「执行后全部开关自动解锁」，不承诺同一时刻：两个 challenge 的 TTL 与探测
+       * 周期各自独立（逐面板倒计时照旧显示）。
+       */
+      const copyAllElevations = (text) => {
+        if (text === '') {
+          setElevationNotice(t('elev.copyManual'))
+          return
+        }
+        copyCommand(ELEVATION_COPY_ALL, text)
       }
 
       /*
@@ -7546,20 +7978,33 @@ window.__ModuleLoader__.load({
       /*
        * 面板开着时轮询授权状态（1.5s）并顺带推进倒计时。轮询而不是等推送：这条通道本来就是
        * 「用户在别的终端里做了一件事」，宿主没有可订阅的事件面。
+       *
+       * **轮询全部 pending 能力**（不再只盯单槽那一个）：两个 challenge 是各自独立开始的，
+       * 各自的授权时刻可以差十几秒；只轮询一个会让另一个停在「宿主已授权、开关没开」。
+       * deps 用**能力名的拼接串**而不是数组：数组每次渲染都是新引用，effect 会被反复拆装，
+       * 1.5s 的节拍随之漂成「每渲染一次就重建定时器」。内容不变时它一字不变，effect 就不动。
        */
-      const elevationCapability = elevation === null ? '' : String(elevation.capability)
+      const elevationPendingKey = elevations
+        // 已授权的那条只是「留痕」（面板已消失），不再轮询——否则每 1.5s 又会走一遍 finishElevation
+        .filter((item) => item.granted !== true)
+        .map((item) => String(item.capability))
+        .sort()
+        .join(',')
       useEffect(() => {
-        if (elevationCapability === '') return undefined
+        if (elevationPendingKey === '') return undefined
+        const capabilities = elevationPendingKey.split(',')
         const timer = setInterval(() => {
           setNowTick((value) => value + 1)
-          api.elevateStatus(elevationCapability).then((status) => {
-            if (status !== null && status.status === 'granted') finishElevation(elevationCapability)
-          }).catch(() => {
-            /* 轮询失败静默：宿主可能在重启，下一次再试 */
-          })
+          for (const capability of capabilities) {
+            api.elevateStatus(capability).then((status) => {
+              if (status !== null && status.status === 'granted') finishElevation(capability)
+            }).catch(() => {
+              /* 轮询失败静默：宿主可能在重启，下一次再试 */
+            })
+          }
         }, 1500)
         return () => clearInterval(timer)
-      }, [elevationCapability])
+      }, [elevationPendingKey])
 
       /* ---------------- 能力开关那一段的渲染 ---------------- */
 
@@ -7665,79 +8110,35 @@ window.__ModuleLoader__.load({
         ] })
       }
 
-      /** 就地提权面板（内联展开；不用 confirm()——那会在 React 之外同步阻塞渲染）。 */
-      const elevationPanel = () => {
-        const capability = String(elevation.capability)
-        const label = capability === 'allowMutations' ? t('check.allowMutations') : t('check.allowExec')
-        const seconds = elevation.expiresAt === undefined
-          ? 0
-          : Math.max(0, Math.ceil((Number(elevation.expiresAt) - Date.now()) / 1000))
-        const close = () => {
-          setElevation(null)
-          setCopied(false)
-        }
-        return jsxs('div', { className: 'dk_elevPanel', children: [
-          jsxs('div', { className: 'dk_row', children: [
-            jsx('span', { className: 'dk_label', children: t('elev.title') + ' · ' + label }),
-            jsx('button', { type: 'button', className: 'dk_btn', onClick: close, children: t('elev.close') }, 'close'),
-          ] }),
-          jsx('span', { className: 'dk_hint', children: t('elev.lockedWhy') }),
-          elevation.error === undefined
-            ? null
-            : jsx('span', { className: 'dk_hint dk_hintWarn', children: t('elev.error') + String(elevation.error) }),
-          elevation.command === undefined
-            ? null
-            : jsxs('div', { className: 'dk_elevSteps', children: [
-              jsx('span', { className: 'dk_hint', children: t('elev.step') }),
-              jsx('code', { className: 'dk_elevCommand', children: String(elevation.command) }),
-              /*
-               * 动作行：复制 / 重新生成 / 倒计时**并排一行、紧贴命令**。
-               *
-               * 早先这三样各自占一条栅格行，而且「重新生成」被「282 秒后失效」「等待确认…」两行
-               * 说明文字隔在下面——2026-09-27 的真机报告（Windows）里那块看上去就是散的：
-               * 按钮离自己的命令越远，越像「不知道点了会发生什么」。命令与它的按钮是一件事（docker D149）。
-               */
-              jsxs('div', { className: 'dk_elevActions', children: [
-                jsx('button', {
-                  type: 'button',
-                  className: 'dk_btn dk_btnPrimary',
-                  onClick: () => copyCommand(String(elevation.command)),
-                  children: copied ? t('elev.copied') : t('elev.copy'),
-                }, 'copy'),
-                jsx('button', {
-                  type: 'button',
-                  className: 'dk_btn',
-                  onClick: () => beginElevation(capability),
-                  children: t('elev.regenerate'),
-                }, 'regen'),
-                jsx('span', {
-                  className: seconds > 0 ? 'dk_hint' : 'dk_hint dk_hintWarn',
-                  children: seconds > 0 ? t('elev.expiresIn', { sec: seconds }) : t('elev.expired'),
-                }),
-              ] }),
-              jsx('span', { className: 'dk_hint', children: t('elev.waiting') }),
-              jsxs('details', { className: 'dk_elevOther', children: [
-                jsx('summary', { children: t('elev.otherWay') }),
-                jsx('span', {
-                  className: 'dk_hint',
-                  children: t('elev.envHow', { env: CAPABILITY_ENV[capability] ?? '' }),
-                }),
-              ] }),
-            ] }),
-          form[capability] === true
-            ? jsx('button', {
-              type: 'button',
-              className: 'dk_btn',
-              onClick: () => {
-                patch({ [capability]: false })
-                close()
-              },
-              children: t('elev.disableFirst'),
-            }, 'disable')
-            : null,
-        ] })
+      /**
+       * 一块能力的面板（✕）与整个面板组都渲染自 `elevationPanelsView`（factory 级纯函数，
+       * 见那段注释）：组件这边只提供**状态与回调**，界面结构留在纯函数里，冒烟才驱动得动。
+       *
+       * 逐个能力的动作语义：
+       * - ✕ 只收起**这一个**能力的面板；别的 pending 原样留着（也不撤销宿主侧 challenge，
+       *   与改造前 close 的语义一致——challenge 仍在 pending，重新点开关即复用同一条命令）。
+       * - 「重新生成」= 再走一次 `beginElevation`（逐能力幂等，不动别的能力）。
+       * - 「先关掉这个配置开关」= 关配置 + 收起自己那块面板。
+       */
+      const closeElevationPanel = (capability) => {
+        setElevations((current) => pruneElevationRecords(removeElevationRecord(current, capability)))
+        setCopiedKey('')
       }
 
+      const elevationPanels = () => elevationPanelsView(elevations, {
+        now: Date.now(),
+        copiedKey,
+        configured: (capability) => form[capability] === true,
+        onCopy: (capability, command) => copyCommand(capability, command),
+        onCopyAll: (text) => copyAllElevations(text),
+        onRegenerate: (capability) => beginElevation(capability),
+        onClose: (capability) => closeElevationPanel(capability),
+        onDisableFirst: (capability) => {
+          patch({ [capability]: false })
+          closeElevationPanel(capability)
+        },
+      })
+
       const sectionTitle = (text) => jsx('div', { className: 'dk_cardSection', children: text })
 
       const field = (label, control, hint, span) => jsxs('div', {
@@ -7849,7 +8250,7 @@ window.__ModuleLoader__.load({
         elevationNotice === ''
           ? null
           : jsx('span', { className: 'dk_hint', children: elevationNotice }),
-        elevation === null ? null : elevationPanel(),
+        elevations.length === 0 ? null : elevationPanels(),
 
         sectionTitle(t('field.target')),
         ...form.targets.map((item, index) => {
@@ -8304,6 +8705,7 @@ window.__ModuleLoader__.load({
       actionText: eventActionText,
       timeText: eventTimeText,
       debounce: makeDebounced,
+      canReconnect: canReconnectEvents,
     }
     /*
      * 同一类测试缝：总览的折叠逻辑与**正文渲染**都是纯函数（正文刻意写成普通函数而不是
@@ -8339,7 +8741,26 @@ window.__ModuleLoader__.load({
        * 「连接还没建立时靠连接簿 host 兜底」这条路径。
        */
       matchTargetForSession,
+      /*
+       * 目标下拉里「＋ 连接本机」那一项：哨兵值 + 「要不要列这一项」的判定。两个都挂出来，
+       * 用例才能直接驱动 —— 离线冒烟的 React 桩把 useState 冻在初值上（`targets` 恒为 []），
+       * 遍历渲染树根本走不到那一项，所以判定必须是纯函数。
+       */
+      CONNECT_LOCAL_OPTION,
+      shouldOfferConnectLocal,
     }
+    /*
+     * 模块级 config 缓存的测试缝：`matchTargetForSession` 这类判定读的是它，而它只由
+     * `/config` 的响应 / 设置卡片保存后推进去。离线冒烟没有真往返，直接把一份 config
+     * 写进去是最短的路径（publish 顺带通知订阅者，与生产路径同一份语义）。
+     */
+    exports.__config = { publishConfig, primeTargetsCache }
+    /*
+     * HTTP 面的测试缝：模块级的 `api` 里的每条都是「路径 + 方法 + body」的直接映射，
+     * 离线冒烟用桩 fetch 调一次就能钉住「一键连接本机打的是 /connect-local 这个 POST」
+     * 这类**接线**错误（路径拼歪了在真机上才暴露）。
+     */
+    exports.__api = api
     /*
      * 日志缓冲的测试缝：环形上限 / 残行分片 / 单调 id / 快照切分都是纯逻辑，离线冒烟
      * 直接驱动（真实 EventSource 时序进不了 Node 桩）。常量挂出来供用例对齐，避免两边漂移。
@@ -8352,6 +8773,29 @@ window.__ModuleLoader__.load({
       PENDING_MAX: LOG_PENDING_MAX,
       FLUSH_MS: FOLLOW_FLUSH_MS,
     }
+    /*
+     * 就地提权「合并复制」的测试缝：逐能力记录的增改 / 收尾、取哪几条命令、顺序、怎么连接，
+     * 全是纯逻辑（`client-src/elevation.js`）。**必须直接驱动**而不是渲染卡片：离线冒烟的
+     * React 桩把 `useState` 冻在初值上、且 `useEffect` 是空实现，两块面板同时在场这件事
+     * 在组件里根本走不到（这正是 2026-09-26 那次「必须粘贴两次」漏掉测试入口的原因）。
+     */
+    exports.__elevation = {
+      upsert: upsertElevationRecord,
+      remove: removeElevationRecord,
+      markGranted: markElevationGranted,
+      prune: pruneElevationRecords,
+      merge: mergeElevationCommands,
+      join: joinElevationCommands,
+      text: buildMergedElevationText,
+      shouldOfferMerge,
+      COPY_ALL_KEY: ELEVATION_COPY_ALL,
+      /**
+       * 面板组的**渲染**（与 `__overview.body` 同一形态）：用例据它断言「几个 pending 才出
+       * 合并按钮」「按钮的 onClick 到底把什么字符串交下去」——只钉纯函数的话，「界面上没有
+       * 那个按钮」与「按钮接错了内容」这两类错都漏得掉。
+       */
+      view: elevationPanelsView,
+    }
     /*
      * 窗口化挂载（D152）的测试缝：布局是纯逻辑，离线冒烟直接驱动（真 DOM 里的量高与
      * 滚动位置由 test/log-window.test.ts 与性能门禁覆盖）。常量挂出来供用例对齐。