@wenbin_wb/dsh-bridge 2.10.11 → 2.10.13

package/CHANGELOG.md

@@ -4,15 +4,38 @@
 
 ---
 
-## [v2.10.11] - 2026-09-16
+## [v2.10.13] - 2026-09-23
+
+> 本版为可靠性与兼容性加固：修复 cloudflared 连接器"假死"（进程存活但边缘连接全掉）造成的公网隧道静默失效（新增运行时健康探针与输出落盘）；跟随 DSH 0.1.5 的官方目录选择器，让本机访问不再误弹插件的远程抽屉；并修复添加工作区弹窗的状态泄漏卡死。
+
+### ✨ 新功能
+
+- **cloudflared 运行时健康探针**：解析 cloudflared 自报 metrics 地址并每 30s 探活官方 `/ready`（判据与上游一致：HTTP 200 且 `readyConnections > 0`）。连续 3 次失败（约 90s）→ 面板状态可见降级「⚠️ 连接器已无健康边缘连接」；连续 10 次（约 5min）→ 判定假死、终止进程并走既有自愈链路强制重建。重建链路（含重启后握手失败）**永不进入终态**——网络恢复后会自动自愈，不再需要人工干预。
+- **cloudflared 输出落盘**：子进程输出写入 `~/.dsh/dsh-bridge/cloudflared.log`，超 5MB 自动轮转为 `.1`；隧道 Token 落盘前强制脱敏（含跨输出块切分、以及 Token 前缀残留等边界，确保任何 Token 片段都不落盘）。
+
+### 🐞 修复
+
+- **公网入口静默失效数天无人发现**（现象：HTTP 530 + `error code: 1033`）：旧逻辑只监听子进程退出，而假死连接器既不退出也不报错，故永不触发自愈。探针上线后最迟约 5 分钟即可自动重建。
+- **本机点「添加工作区」误弹插件的远程抽屉**（issue #28 第 2 条）：DSH 0.1.5 起自带官方目录选择器（`dsh-host-directory-picker-auto` 按宿主能力分发 native / browse），且注册到与插件完全相同的 Slot；DSH 的 slots 是 shadow 语义（动态注册的插件天然覆盖内置实现），于是本机 `127.0.0.1:3080` 也被插件的远程目录选择器接管。现改为「本机访问 且 官方 picker 可用」时**不注册**该 Slot，让位给 DSH 官方——macOS / Windows 走系统原生文件夹对话框，无桌面环境的 Linux 走官方网页选择器；**旧版 DSH 与远程 / 移动访问仍由插件接管**，保留管理密码解锁与 `local_only` 目录策略。
+- **添加工作区弹窗点过「已注册工作区」后永久卡死**（PR #42）：`switchToWorkspace()` 只置位 `isSubmitting` 而从不复位，同一弹窗实例的 `loadDirectory()` / `doSubmit()` 守卫让弹窗彻底无响应（点目录不进目录、点添加无反应且按钮停在「正在添加并切换…」）；改为与 `doSubmit()` 对称的 `try/finally` 复位，`render()` 抛错与将来新增的提前 return 都不会再泄漏。
+- **探针自身异常不得拖垮宿主**：畸形 metrics 地址、日志通道自身抛错等任何探针路径异常都不会变成未处理 rejection 结束 DSH 主进程（独立子进程实验验证）。
+- **新增 18 条探针回归测试**（含防误杀正常重连连接器、防终态、脱敏泄漏/吞字符、跨 chunk 脱敏、崩溃回归等）。
+- **新增 15 条回归测试**：12 条目录选择器让位（让位判定真值表、官方 picker 探测、Slot 注册顺序结构断言、产物同步）+ 3 条添加工作区弹窗 `isSubmitting` 复位与产物同步。
+
+> ⚠️ 生效说明：本版需要重启一次 dsh（`systemctl --user restart dsh-web.service` 或面板「重启 DSH」）才加载新代码；重启会短暂中断当前会话与公网隧道（数十秒）。
+
+---
+
+## [v2.10.12] - 2026-09-16
+
+> 本版汇总 v2.10.11 的修复内容，并含 4 处可靠性加固（systemctl 退出码判定、单元名解析、助手失败日志、注入分段判重）。
 
 ### 🐞 修复
 
-- **移动端顶栏压住 `position: fixed` 全屏面板顶部 52px**（issue #41）：桥的让位方式此前是给内容框架加 `padding-top: var(--dsh-mobile-header-h)`，但 `position: fixed` 元素的包含块是视口（CSS 2.1 §10.1），不跟随祖先内边距。官方右侧栏在窄视口（`viewportWidth < 768`）自动全屏（`.P3OORG_panel[data-sidebar-right-panel=fullscreen]`，即 `fixed; inset:0; z-index:40`），其顶部标签栏因此落进顶栏（`z-index: 9998`）覆盖区。由于顶栏背景透明且容器自身 `pointer-events: none`，实际表现并非「被不透明条挡住」，而是顶栏标题/图标与面板标签压字，外加两处 40×40 命中区抢占点击——面板右端的「全屏 / 收起」按钮右半（14×28px）会被顶栏「+」按钮夺走，误触即触发新建会话。现按 `data-sidebar-right-panel="fullscreen"` 直接位移面板容器本身（`top` 下移 52px 并同步收窄 `height` / `max-height`），不依赖宿主 CSS-module 哈希类名，宿主升级不失效。若用户此前用 `top` 自行让位过，本次修复与之同属性、级联只生效一条，**不会叠加**；但若用的是 `padding-top` / `margin-top` / `transform` 位移，请撤掉旧规则，否则会叠加下移。
-- **移动端断点与宿主判据对齐**：桥原按 `max-width: 768px`（运行时亦为 `innerWidth <= 768`），而宿主用 `viewportWidth < 768` 决定右侧栏是否自动全屏，恰在 768px 这一宽度上出现「桥渲染移动端顶栏、宿主按桌面（push）布局」的错位。现移动端统一为 `<= 767px`（新增 `MOBILE_MAX_WIDTH = 767` 常量，消除散落的魔法值），`768px` 起彻底交还桌面布局。
-- **鸿蒙（HuaweiBrowser / ArkWeb）上文档预览永远显示「文件资源服务不可用。」**：该内核解析非特殊 scheme 时 `new URL('dsh-resource://file/session/<id>/<path>').hostname` 返回空串（Chrome/Safari 返回 `file`），而 DSH 的客户端资源注册表 `@deepseek-ai/dsh-client-resources` 正是拿 URL 的 hostname 当「协议键」——取不到就把记录判成「没有 provider」，状态永久停在 `none`；注册表只在 provider 注册那一刻回挂一次已有记录，之后不再重试，所以刷新也不恢复。表现为右侧栏文件与对话生成文档的预览全部打不开（而日志/探针里 `resources.providers` 其实一直有 `file`，容易误判成插件没生效）。现桥侧新增 `client/resource-url-compat.js`：**先做特性探测**，只有引擎确有差异时才包一层 `window.URL`，且仅对 `dsh-resource:` 协议、原生 hostname 为空、原始串能解析出 host 的实例补上 `hostname`/`host`（写成实例自有访问器，读取时原生值优先、为空才回退现解析，赋值/改 href 后立即反映新值；setter 仍委托原生原型）；引擎正常时一个字节都不动（判定 `not-needed`）。根因在宿主侧（用 URL.hostname 当协议键），已另行整理上游材料；上游若改为从原始串解析协议，本兼容层自动空转。
-- **iOS 16 / 旧 Safari 完全打不开 DSH（页面红屏 `Failed to load plugins … Can't find variable: Iterator`）**：DSH 自带的 pdf.js 在**模块顶层**就执行 `if (typeof Iterator.prototype.join !== 'function') Iterator.prototype.join = …`，而 `Iterator` 这个全局是 Safari 18.4 才随「迭代器辅助方法」引入的——iOS 16 上该引用直接抛 `Can't find variable: Iterator`，导致 `@deepseek-ai/dsh-client-ui-sidebar-documentpreview` 导入失败，进而整棵客户端插件树加载失败（实测于 iOS 16 真机，并在本机以同构环境复现）。同一批缺口还有 `Promise.withResolvers`（Safari 17.4+）：DSH 宿主 HTML 末尾的启动握手内联脚本、以及审批 / 用户提问 / cordis 运行时 `ctx.timeout`·`ctx.interval` / workspace-files 变更订阅等运行期路径都在用它。现桥在反向代理注入 HTML 时、于宿主所有脚本之前补齐两枚垫片：`Promise.withResolvers`（完整语义）与 `Iterator`（把真实的内置迭代器共享原型 `%IteratorPrototype%` 挂到 `Iterator.prototype`，使 pdf.js 的补丁落到真实迭代器原型而不是一个没用的空对象）。两者都**只在缺失时安装**，iOS 18.4+ / Android / 桌面端零改动；至此 iOS 16 可正常启动并使用。
-- **「重启 DSH」按钮在 systemd 托管下点了没用，DSH 再也没起来（只能手动重启），且不留任何日志**：桥原实现是不识别托管器的「自派生子进程 + `process.exit(0)`」。在 systemd 单元（如 `dsh-web.service`，用户在 user slice 下）里这必然失败：`Restart=on-failure` 不认干净退出的 code 0（systemd 不会拉起），而默认 `KillMode=control-group` 会在主进程退出时把刚派生的子进程一并杀掉；旧实现还把子进程 stdio 设成 `ignore`，所以连失败原因都看不到。现按托管方式分流：从 `/proc/self/cgroup` 取出**最内层** systemd 单元名 → 交给 `systemctl [--user] restart --no-block <unit>`（stop+start 由 systemd 负责，新进程仍在正确 cgroup 内，并尊重单元自身的 Restart 策略）；`DSH_DAEMON` / `PM2_HOME` 仍走守护进程退出；无托管器时派生独立助手 `lib/restart-helper.mjs`，**等旧进程真正退出、端口释放后**才拉起新 DSH，并在最长 120s 内确认端口可连接，全过程写入 `~/.dsh/dsh-bridge/restart.log`（子进程输出另存 `restart-child.log`）。前端在宿主明确返回 `ok:false`（例如 `systemctl` 与助手都派生失败）时**直接报错**，不再假装「正在重连」让用户面对永远转圈。注意：systemd 托管的环境需先手动重启一次让本修复生效，之后按钮即可正常使用。
+- **iOS 16 / 旧 Safari 打不开 DSH**（红屏 `Failed to load plugins … Can't find variable: Iterator`）：代理注入 HTML 时补齐 `Promise.withResolvers` 与 `Iterator` 垫片（Safari 分别是 17.4 / 18.4 才有），只在缺失时安装，其它浏览器零改动。
+- **鸿蒙（HuaweiBrowser / ArkWeb）文档预览一直显示「文件资源服务不可用。」**：该内核解析 `dsh-resource://` 地址取不到 hostname，新增 URL 兼容层兜底；引擎正常时不介入。
+- **移动端顶栏压住全屏面板顶部 52px（#41）**：改为直接位移面板容器本身，并让移动端断点与宿主判据对齐（`≤767px`）。
+- **「重启 DSH」在 systemd 托管下点了没用、DSH 不再自动起来**：改为识别 systemd 单元并交给 `systemctl restart`，按退出码判定成败；失败时保持运行并提示手动重启命令。
 
 ---
 

package/client/client.js

@@ -1067,6 +1067,21 @@ async function unlockAdmin(rpcCall, password) {
   }
 }
 
+// client/picker-yield.js
+var OFFICIAL_WORKSPACE_SEAT = "uiWorkspace";
+function hasOfficialDirectoryPicker(ctx) {
+  try {
+    if (typeof ctx?.get !== "function") return false;
+    const seat = ctx.get(OFFICIAL_WORKSPACE_SEAT);
+    return typeof seat?.pickDirectory === "function";
+  } catch {
+    return false;
+  }
+}
+function shouldYieldToOfficialPicker(facts) {
+  return Boolean(facts?.local) && Boolean(facts?.officialPicker);
+}
+
 // lib/bridge-rpc-constants.js
 var BRIDGE_RPC_CHANNEL = "/dsh-bridge";
 var BRIDGE_ENDPOINTS = {
@@ -5941,60 +5956,64 @@ function showRemoteWorkspaceDialog(rpcCall, onWorkspaceAdded, clientCtx, onPicke
   async function switchToWorkspace(wsId, wsPath) {
     if (isSubmitting) return;
     isSubmitting = true;
-    statusMessage = `\u6B63\u5728\u5207\u6362\u5DE5\u4F5C\u533A\u2026`;
-    isErrorMessage = false;
-    render();
-    if (typeof onPicked === "function" && wsPath) {
-      try {
-        onPicked(wsPath);
-      } catch (e) {
-      }
-    }
-    let switched = false;
-    if (clientCtx?.workspaces?.startSession && wsId) {
-      try {
-        clientCtx.workspaces.startSession(wsId);
-        switched = true;
-      } catch (e) {
-        console.warn("[dsh-bridge] startSession failed:", e);
+    try {
+      statusMessage = `\u6B63\u5728\u5207\u6362\u5DE5\u4F5C\u533A\u2026`;
+      isErrorMessage = false;
+      render();
+      if (typeof onPicked === "function" && wsPath) {
+        try {
+          onPicked(wsPath);
+        } catch (e) {
+        }
       }
-    }
-    if (!switched && wsPath) {
-      try {
-        if (clientCtx?.workspaces?.create) {
-          const ws = await clientCtx.workspaces.create({ path: wsPath });
-          if (ws?.workspaceId && clientCtx?.workspaces?.startSession) {
-            clientCtx.workspaces.startSession(ws.workspaceId);
-            switched = true;
-          }
+      let switched = false;
+      if (clientCtx?.workspaces?.startSession && wsId) {
+        try {
+          clientCtx.workspaces.startSession(wsId);
+          switched = true;
+        } catch (e) {
+          console.warn("[dsh-bridge] startSession failed:", e);
         }
-        if (!switched) {
-          const raw = await authRpc(BRIDGE_ENDPOINTS.addRemoteWorkspace, { path: wsPath });
-          const res = raw?.value || raw;
-          if (res?.workspaceId && clientCtx?.workspaces?.startSession) {
-            try {
-              clientCtx.workspaces.startSession(res.workspaceId);
+      }
+      if (!switched && wsPath) {
+        try {
+          if (clientCtx?.workspaces?.create) {
+            const ws = await clientCtx.workspaces.create({ path: wsPath });
+            if (ws?.workspaceId && clientCtx?.workspaces?.startSession) {
+              clientCtx.workspaces.startSession(ws.workspaceId);
               switched = true;
-            } catch (e) {
             }
           }
-          if (!switched && res?.sessionId && clientCtx?.sessions?.open) {
-            try {
-              clientCtx.sessions.open(res.sessionId);
-              switched = true;
-            } catch (e) {
+          if (!switched) {
+            const raw = await authRpc(BRIDGE_ENDPOINTS.addRemoteWorkspace, { path: wsPath });
+            const res = raw?.value || raw;
+            if (res?.workspaceId && clientCtx?.workspaces?.startSession) {
+              try {
+                clientCtx.workspaces.startSession(res.workspaceId);
+                switched = true;
+              } catch (e) {
+              }
+            }
+            if (!switched && res?.sessionId && clientCtx?.sessions?.open) {
+              try {
+                clientCtx.sessions.open(res.sessionId);
+                switched = true;
+              } catch (e) {
+              }
             }
           }
+        } catch (e) {
         }
-      } catch (e) {
       }
+      statusMessage = `\u2713 \u5DF2\u5207\u6362\u81F3\u5DE5\u4F5C\u533A\uFF01`;
+      render();
+      setTimeout(() => {
+        closeModal();
+        document.body.classList.remove("dsh-drawer-open");
+      }, 400);
+    } finally {
+      isSubmitting = false;
     }
-    statusMessage = `\u2713 \u5DF2\u5207\u6362\u81F3\u5DE5\u4F5C\u533A\uFF01`;
-    render();
-    setTimeout(() => {
-      closeModal();
-      document.body.classList.remove("dsh-drawer-open");
-    }, 400);
   }
   async function loadDirectory(targetPath) {
     if (isSubmitting) return;
@@ -6388,6 +6407,10 @@ function apply(ctx) {
   ctx.slots.inject(
     "conversation.hero.workspace.directoryFlow",
     () => ctx.slots.inject("sidebar.workspaces.directoryFlow", function* () {
+      if (shouldYieldToOfficialPicker({
+        local: isLocalEnvironment(),
+        officialPicker: hasOfficialDirectoryPicker(ctx)
+      })) return;
       yield ctx.slots.register(
         {
           name: "conversation.hero.workspace.directoryFlow",

package/client/index.js

@@ -4,6 +4,7 @@ import {
   queuePendingOperation, unlockAdmin, onUnlocked,
   fetchLoopbackTokenOnce,
 } from './unlock-manager.js'
+import { hasOfficialDirectoryPicker, shouldYieldToOfficialPicker } from './picker-yield.js'
 // dsh-bridge 客户端插件：设置页「远程访问」面板
 
 // 兼容非 HTTPS 环境（如手机局域网 HTTP 访问）：为非安全上下文补齐 crypto.randomUUID
@@ -4545,60 +4546,68 @@ function showRemoteWorkspaceDialog(rpcCall, onWorkspaceAdded, clientCtx, onPicke
   async function switchToWorkspace(wsId, wsPath) {
     if (isSubmitting) return;
     isSubmitting = true;
-    statusMessage = `正在切换工作区…`;
-    isErrorMessage = false;
-    render();
-
-    if (typeof onPicked === 'function' && wsPath) {
-      try {
-        onPicked(wsPath);
-      } catch (e) {}
-    }
+    try {
+      statusMessage = `正在切换工作区…`;
+      isErrorMessage = false;
+      render();
 
-    let switched = false;
-    if (clientCtx?.workspaces?.startSession && wsId) {
-      try {
-        clientCtx.workspaces.startSession(wsId);
-        switched = true;
-      } catch (e) {
-        console.warn('[dsh-bridge] startSession failed:', e);
+      if (typeof onPicked === 'function' && wsPath) {
+        try {
+          onPicked(wsPath);
+        } catch (e) {}
       }
-    }
 
-    if (!switched && wsPath) {
-      try {
-        if (clientCtx?.workspaces?.create) {
-          const ws = await clientCtx.workspaces.create({ path: wsPath });
-          if (ws?.workspaceId && clientCtx?.workspaces?.startSession) {
-            clientCtx.workspaces.startSession(ws.workspaceId);
-            switched = true;
-          }
+      let switched = false;
+      if (clientCtx?.workspaces?.startSession && wsId) {
+        try {
+          clientCtx.workspaces.startSession(wsId);
+          switched = true;
+        } catch (e) {
+          console.warn('[dsh-bridge] startSession failed:', e);
         }
-        if (!switched) {
-          const raw = await authRpc(BRIDGE_ENDPOINTS.addRemoteWorkspace, { path: wsPath });
-          const res = raw?.value || raw;
-          if (res?.workspaceId && clientCtx?.workspaces?.startSession) {
-            try {
-              clientCtx.workspaces.startSession(res.workspaceId);
+      }
+
+      if (!switched && wsPath) {
+        try {
+          if (clientCtx?.workspaces?.create) {
+            const ws = await clientCtx.workspaces.create({ path: wsPath });
+            if (ws?.workspaceId && clientCtx?.workspaces?.startSession) {
+              clientCtx.workspaces.startSession(ws.workspaceId);
               switched = true;
-            } catch (e) {}
+            }
           }
-          if (!switched && res?.sessionId && clientCtx?.sessions?.open) {
-            try {
-              clientCtx.sessions.open(res.sessionId);
-              switched = true;
-            } catch (e) {}
+          if (!switched) {
+            const raw = await authRpc(BRIDGE_ENDPOINTS.addRemoteWorkspace, { path: wsPath });
+            const res = raw?.value || raw;
+            if (res?.workspaceId && clientCtx?.workspaces?.startSession) {
+              try {
+                clientCtx.workspaces.startSession(res.workspaceId);
+                switched = true;
+              } catch (e) {}
+            }
+            if (!switched && res?.sessionId && clientCtx?.sessions?.open) {
+              try {
+                clientCtx.sessions.open(res.sessionId);
+                switched = true;
+              } catch (e) {}
+            }
           }
-        }
-      } catch (e) {}
-    }
+        } catch (e) {}
+      }
 
-    statusMessage = `✓ 已切换至工作区！`;
-    render();
-    setTimeout(() => {
-      closeModal();
-      document.body.classList.remove('dsh-drawer-open');
-    }, 400);
+      statusMessage = `✓ 已切换至工作区！`;
+      render();
+      setTimeout(() => {
+        closeModal();
+        document.body.classList.remove('dsh-drawer-open');
+      }, 400);
+    } finally {
+      // 与 doSubmit 对称：本函数此前只置位、从不复位，导致点过一次「已注册工作区」后，
+      // 同一弹窗实例的 isSubmitting 永久为 true，loadDirectory/doSubmit 的守卫
+      // 让整个弹窗彻底无响应（点目录、点添加都没反应）。用 finally 兜住所有路径，
+      // 包括 render() 抛错以及将来新增的提前 return。
+      isSubmitting = false;
+    }
   }
 
   async function loadDirectory(targetPath) {
@@ -5041,9 +5050,22 @@ function apply(ctx) {
 
   const injected = () => ({ pick: () => ctx.workspaces?.pickDirectory?.() });
 
-  // 注册至 DSH 原生目录选择 Slot（设置 priority: -10 覆盖原生 Electron 选择器，在远程/移动网页端生效）
+  // 注册至 DSH 原生目录选择 Slot（priority: -10 覆盖原生 Electron 选择器，在远程/移动网页端生效）
+  //
+  // 但 DSH 0.1.5 起自带官方目录选择器（@deepseek-ai/dsh-host-directory-picker-auto
+  // 按宿主能力分发 native / browse），且注册到完全相同的两个 Slot。DSH 的 slots 是
+  // shadow 语义（动态注册的插件天然覆盖内置实现，详见 client/picker-yield.js），
+  // 因此本机 + 官方 picker 可用时必须「不注册」才能让位 —— 用低优先级注册是无效的，
+  // 否则本机 127.0.0.1 点「添加工作区」弹的是插件的远程抽屉（issue #28 第 2 条）。
+  // 旧版 DSH（无官方 picker）与远程/移动访问继续由插件接管，后者保留管理密码解锁
+  // 与 local_only 目录策略（换成官方 picker 会绕过插件的访问限制）。
   ctx.slots.inject('conversation.hero.workspace.directoryFlow', () =>
     ctx.slots.inject('sidebar.workspaces.directoryFlow', function* () {
+      if (shouldYieldToOfficialPicker({
+        local: isLocalEnvironment(),
+        officialPicker: hasOfficialDirectoryPicker(ctx),
+      })) return;
+
       yield ctx.slots.register(
         {
           name: 'conversation.hero.workspace.directoryFlow',

package/client/picker-yield.js

@@ -0,0 +1,77 @@
+// DSH 官方目录选择器的「让位」判定（issue #28 第 2 条）
+//
+// 背景：DSH 0.1.5 起自带官方目录选择器，且注册到与 dsh-bridge 完全相同的两个 Slot：
+//   conversation.hero.workspace.directoryFlow
+//   sidebar.workspaces.directoryFlow
+// 后端由 @deepseek-ai/dsh-host-directory-picker-auto 按宿主事实分发：非回环绑定 /
+// SSH / Linux 无 zenity·kdialog 等图形 chooser → browse（网页树形选择器），
+// macOS·Windows 或 Linux 有 chooser → native（系统对话框）。
+//
+// 而 DSH 的 slots 是 shadow 语义：@deepseek-ai/dsh-cordis-client-runner 的注释明确
+//   "Page-local shadowing rank. A later registration receives a lower priority."
+//   "a dynamically registered entry is assigned a lower priority than the shipped
+//    one, which makes it the winner"
+// 即数值越小越优先、后注册者胜。动态加载的 dsh-bridge 因此天然覆盖内置 picker，
+// 叠加本插件显式写的 `priority: -10`，连本机（127.0.0.1 / Electron）也被插件自己的
+// 远程目录选择器接管：点「添加工作区」弹的是插件的远程抽屉而非 DSH 官方选择器。
+//
+// 让位条件（两者同时成立才让位）：
+//   1. 本机访问（isLocalEnvironment()）—— 本机有完整权限，官方 picker 直接可用；
+//   2. DSH 已自带官方 picker —— 旧版 DSH 没有，必须继续由插件兜底，
+//      否则本机点「添加工作区」将彻底没有反应。
+// 远程 / 移动访问一律继续由插件接管：那里需要管理密码解锁与 local_only 目录策略，
+// 不能换成官方 picker（会绕过插件的访问限制）。
+//
+// 为什么探测用 ctx.get() 而不是 ctx.uiWorkspace：
+//   cordis 本体对**未在插件 inject 中声明**的服务做属性访问会直接抛错：
+//     cannot get property "uiWorkspace" without inject   （cordis/lib/index.js）
+//   —— dsh-bridge 的 client half 是静态 client 插件，其 ctx 是真 cordis Context
+//   （不是动态包的 runner guard facade），所以拦在这里的是 cordis 本体的规则。
+//   而 `ctx.get(name)` 是允许的「可选查找」，不要求声明。
+//   又不能把 uiWorkspace 写进 inject：旧版 DSH（无该 seat）会因此把整个插件 park 掉
+//   （provider 缺失即不 apply），所以只能用 ctx.get() 探测。
+//
+// ⚠️ 已知时序依赖（独立验收记录，真机 6/6 冷启动实测未触发）：
+//   cordis 的 ctx.get() 在 provider fiber 尚未进入 ACTIVE 时会返回 undefined。理论上若
+//   本判定早于 ui-workspace 插件 apply 完成，就会把「有官方 picker」误判为「无」而仍然
+//   注册，让位失效。当前稳定是因为 dsh-bridge 自身 inject 的 workspaces / sessions 由
+//   roster 中排在 ui-workspace **之后**的插件提供，插件真正激活时 ui-workspace 早已
+//   apply 完成 —— 这是对 roster 顺序的**隐式耦合，不是显式保证**。若将来调整 roster
+//   顺序或去掉 workspaces 依赖，需重新评估（加固思路：注册后等 uiWorkspace 可用时
+//   再撤销自己的注册）。
+
+/** 官方 workspace seat 的服务名（DSH 0.1.5 起提供 pickDirectory） */
+export const OFFICIAL_WORKSPACE_SEAT = 'uiWorkspace';
+
+/**
+ * 探测 DSH 是否已提供官方目录选择器。
+ *
+ * 用 `ctx.get()` 做可选查找：seat 不存在（旧版 DSH）、宿主未暴露 pickDirectory、
+ * 查询或属性读取抛错时一律返回 false —— 探测本身绝不外抛影响插件加载。
+ *
+ * @param {{ get?: (name: string) => unknown }} [ctx] cordis 客户端 context
+ * @returns {boolean} 官方 picker 是否可用
+ */
+export function hasOfficialDirectoryPicker(ctx) {
+  try {
+    if (typeof ctx?.get !== 'function') return false;
+    const seat = ctx.get(OFFICIAL_WORKSPACE_SEAT);
+    // typeof 也放在 try 内：seat 可能是带异常 getter 的对象或 Proxy，
+    // 读 pickDirectory 本身就可能抛错。
+    return typeof seat?.pickDirectory === 'function';
+  } catch {
+    // ctx.get 抛错（宿主异常），或属性读取抛错（异常 getter / Proxy）：
+    // 一律按「无官方 picker」处理，保持插件原有兜底行为，探测绝不外抛。
+    return false;
+  }
+}
+
+/**
+ * 是否应让位给 DSH 官方目录选择器。
+ *
+ * @param {{ local?: boolean, officialPicker?: boolean }} [facts]
+ * @returns {boolean} true = 不注册插件选择器，本机交给 DSH 官方处理
+ */
+export function shouldYieldToOfficialPicker(facts) {
+  return Boolean(facts?.local) && Boolean(facts?.officialPicker);
+}

package/lib/cloudflared-manager.mjs

@@ -1,11 +1,12 @@
 import { spawn, execSync } from 'node:child_process';
-import { createWriteStream, createReadStream, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { createWriteStream, createReadStream, existsSync, mkdirSync, readFileSync, statSync, renameSync, writeFileSync } from 'node:fs';
 import { chmod, stat, unlink, rename } from 'node:fs/promises';
 import { homedir, platform, arch } from 'node:os';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { createHash } from 'node:crypto';
 import { get as httpsGet } from 'node:https';
+import { get as httpGet } from 'node:http';
 
 const CLOUDFLARED_VERSION = '2024.10.0';
 const DOWNLOAD_TIMEOUT = 5 * 60 * 1000; // 5 分钟
@@ -15,6 +16,47 @@ const RETRY_BASE_MS = 5 * 1000; // 自愈退避起点 5s
 const RETRY_MAX_MS = 5 * 60 * 1000; // 自愈退避封顶 5min
 const DEFAULT_MAX_RETRIES = 12; // 连续失败超过该次数转为 error，不再无限重试
 
+// ── 运行时健康探针 ────────────────────────────────────────────────────────
+// 事故背景：cloudflared 与 Cloudflare 边缘的连接全部掉光后进程仍存活（"半死/假死"），
+// 既不退出也不报错，因此只监听 exit 的旧自愈逻辑永远不会触发，隧道会静默失效
+// （现象：公网 530 + 正文 error code: 1033，持续 2 天无人发现）。
+//
+// 关键约束（一手源码 cloudflared 2024.10.0 `tunnelstate/conntracker.go`）：/ready 的
+// readyConnections 取自 CountActiveConns()，而 Disconnected / Reconnecting /
+// RegisteringTunnel / Unregistering 全部把 IsConnected 置 false —— 即
+// **正常重连期间 /ready 同样是 503**。因此单次 503 无法区分"连接器假死"与
+// "网络暂时全断、cloudflared 正按自身退避重连"。唯一能区分的是"持续多久"，
+// 故采用两级升级，且强制重建永不进入终态（见 _scheduleRestart 的 terminal 选项）。
+const HEALTH_PROBE_INTERVAL_MS = 30 * 1000; // 探活间隔
+const HEALTH_PROBE_TIMEOUT_MS = 5 * 1000; // 单次探活总时限（远程调用防失控）
+const HEALTH_DEGRADED_THRESHOLD = 3; // 连续失败达此数 → 面板可见降级（约 90s 发现）
+const HEALTH_RESTART_THRESHOLD = 10; // 连续失败达此数 → 终止进程强制重建（约 5min）
+
+// ── cloudflared 输出落盘 ──────────────────────────────────────────────────
+// 事故时 journal 里查不到任何 cloudflared 日志，导致事后无法定位断连时间点与原因。
+export const CLOUDFLARED_LOG_NAME = 'cloudflared.log';
+const CLOUDFLARED_LOG_MAX_BYTES = 5 * 1024 * 1024; // 超限轮转为 .1（覆盖旧的）
+
+// 从 cloudflared 自报日志中解析 metrics 服务地址（运行时健康探针的唯一入口）。
+// 真实输出形如：INF Starting metrics server on 127.0.0.1:41143/metrics
+// 解析不到 → 显式告警并跳过探活（绝不静默降级，也绝不因探测不到而误杀进程）。
+//
+// 必须在这里就把非法地址拦掉：node:http 的 get() 对畸形 URL 会**同步抛错**
+// （ERR_INVALID_URL），异常会穿透探针 Promise 造成未处理 rejection ——
+// Node 默认 unhandled-rejections=throw 会直接结束整个 DSH 主进程，
+// 也就是说"本该保护服务的探针"反而会把服务干掉。端口必须落在 1..65535。
+export function parseMetricsAddress(text) {
+  if (!text) return null;
+  const m = /Starting metrics server on (\S+?)\/metrics/.exec(text);
+  if (!m) return null;
+  const addr = m[1];
+  const parts = /^([A-Za-z0-9._-]+|\[[0-9A-Fa-f:]+\]):(\d{1,5})$/.exec(addr);
+  if (!parts) return null;
+  const port = Number(parts[2]);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+  return addr;
+}
+
 // ── 确定性失败特征：cloudflared 因配置/用法错误退出（非网络瞬态）─────────
 // 这类失败重试无意义，识别后直接置 error 让用户看到明确原因，而不是
 // 误判成"意外退出"退避重连 N 次（issue #35 作者建议）。
@@ -138,10 +180,26 @@ export class CloudflaredManager {
    * @param {number} [opts.handshakeTimeoutMs=90000] 等待隧道就绪的握手超时（测试可注入小值）。
    * @param {object} [opts.spawnOptions] 透传给 child_process.spawn 的额外选项（测试注入用，
    *   如 Windows 下需 shell:true 才能运行 .cmd mock；生产不传）。
+   * @param {number} [opts.healthProbeIntervalMs=30000] 就绪后运行时探活间隔。
+   * @param {number} [opts.healthProbeTimeoutMs=5000] 单次探活总时限。
+   * @param {number} [opts.healthDegradedThreshold=3] 连续失败达此数即在面板上显示降级
+   *   （默认约 90s——这是"发现故障"的时点）。
+   * @param {number} [opts.healthRestartThreshold=10] 连续失败达此数才终止进程强制重建
+   *   （默认约 5min）。必须显著大于 degraded 阈值：/ready 无法区分"假死"与
+   *   "正在自行重连"，只有持续时长能区分，过早重建会误杀本可自愈的连接器。
+   * @param {string|null} [opts.logFilePath=null] cloudflared stdout/stderr 落盘路径；
+   *   null 表示不落盘（默认）。生产由调用方显式传入（见 lib/index.js），
+   *   避免库的默认行为在单测里往真实运维日志目录写测试内容。
+   * @param {number} [opts.logMaxBytes=5242880] 单文件超限后轮转为 `<logFilePath>.1`。
    */
   constructor({ port, home, token, hostname, onStateChange, logger,
     binaryPath, retryPolicy, noAutoupdate = true, binaryVersion = CLOUDFLARED_VERSION,
-    handshakeTimeoutMs = HANDSHAKE_TIMEOUT_MS, spawnOptions = null }) {
+    handshakeTimeoutMs = HANDSHAKE_TIMEOUT_MS, spawnOptions = null,
+    healthProbeIntervalMs = HEALTH_PROBE_INTERVAL_MS,
+    healthProbeTimeoutMs = HEALTH_PROBE_TIMEOUT_MS,
+    healthDegradedThreshold = HEALTH_DEGRADED_THRESHOLD,
+    healthRestartThreshold = HEALTH_RESTART_THRESHOLD,
+    logFilePath = null, logMaxBytes = CLOUDFLARED_LOG_MAX_BYTES }) {
     this.port = port;
     this.home = home || join(homedir(), '.dsh-bridge');
     this.token = token ? String(token).trim() : null;
@@ -170,18 +228,42 @@ export class CloudflaredManager {
     // 测试注入的 spawn 选项（如 Windows 的 shell）；生产为 null 不影响默认行为
     this._spawnOptions = spawnOptions || null;
 
+    // 运行时健康探针参数（测试可注入小值）
+    this.healthProbeIntervalMs = healthProbeIntervalMs;
+    this.healthProbeTimeoutMs = healthProbeTimeoutMs;
+    this.healthDegradedThreshold = healthDegradedThreshold;
+    this.healthRestartThreshold = healthRestartThreshold;
+    this.logFilePath = logFilePath || null;
+    this.logMaxBytes = logMaxBytes;
+
     this.process = null;
     this.url = null;
     this.binaryPath = null;
     this._stopped = false;
     this._retryTimer = null;
     this._restartCount = 0; // 连续启动失败/意外退出次数，就绪后清零
+
+    this._metricsAddress = null; // 本次 spawn 的 cloudflared metrics 地址（探活入口）
+    this._metricsParseTail = ''; // metrics 日志行的跨 chunk 拼接缓冲
+    this._probeTimer = null;
+    this._probeFailures = 0;
+    this._probeInFlight = false; // 防重叠探活堆积
+    this._probeCount = 0; // 已完成的探活次数（供测试断言探针确实在跑）
+    this._probeLogFailures = 0; // 探针日志通道自身抛错的次数（供自查是否丢过日志）
+    this._spawnSeq = 0; // spawn 代数：探活结果据此作废，避免算到新进程头上
+    this._healthRecovering = false; // 健康探针触发的重建链路中（此期间不允许终态）
+    this._readyState = null; // 最近一次 ready 状态，供探活恢复后回写
+    this._logStream = null;
+    this._logBytesWritten = 0;
+    this._redactCarry = ''; // 跨 chunk 的脱敏残留（防 Token 被切分而漏网）
   }
 
   // 异步启动，立即返回——调用方不需要 await
   start() {
     this._stopped = false;
     this._restartCount = 0;
+    this._healthRecovering = false;
+    this._probeInFlight = false;
     if (this._retryTimer) {
       clearTimeout(this._retryTimer);
       this._retryTimer = null;
@@ -206,6 +288,9 @@ export class CloudflaredManager {
   }
 
   // 退避自愈调度：唯一入口在"启动失败"与"就绪后意外退出"。stop()/超限 终止。
+  // _healthRecovering 期间（健康探针判定假死后触发的整条重建链路，含重启后握手失败）
+  // 永不进入终态——必须覆盖整条链路而不只是那次 kill：重启时网络往往仍不通，
+  // 新进程握手失败仍会走这里，若在此处转 error 就把"可自愈的断网"变成人工故障。
   _scheduleRestart(reason) {
     if (this._stopped) return; // 用户已停止，绝不复活
     if (this._retryTimer) return; // 已在倒计时中，避免叠加调度
@@ -215,15 +300,25 @@ export class CloudflaredManager {
     }
     this._restartCount++;
     if (this._restartCount > this.retry.maxRetries) {
-      this._setState('error', `${reason}（已自动重试 ${this.retry.maxRetries} 次仍失败，请检查网络/Token，或点击「关闭」停止）`);
-      return;
+      if (!this._healthRecovering) {
+        this._setState('error', `${reason}（已自动重试 ${this.retry.maxRetries} 次仍失败，请检查网络/Token，或点击「关闭」停止）`);
+        return;
+      }
+      // 健康探针触发的重建链路永不进入终态：长时断网时 cloudflared 自身也是无限退避
+      // 重连，这里保持同样语义。退避仍随 _restartCount 增长并封顶 maxDelayMs，
+      // 不会退化成高频重启风暴；重新就绪（tryResolve）后该标记自动清除。
     }
     const delay = Math.min(
       this.retry.baseDelayMs * 2 ** (this._restartCount - 1),
       this.retry.maxDelayMs
     );
-    this._setState('reconnecting',
-      `${reason}，${Math.max(1, Math.round(delay / 1000))}s 后自动重连（第 ${this._restartCount}/${this.retry.maxRetries} 次）`);
+    // 文案必须如实：健康重建链路会故意突破 maxRetries 持续重试，
+    // 若沿用"第 N/M 次"会出现"第 9/2 次"这种自相矛盾的提示，反而误导排障。
+    const delayText = delay >= 1000 ? `${Math.round(delay / 1000)}s` : `${delay}ms`;
+    const beyondCap = this._restartCount > this.retry.maxRetries;
+    this._setState('reconnecting', beyondCap
+      ? `${reason}，${delayText} 后继续自动重连（已重试 ${this._restartCount} 次；隧道长时间无法建立，请检查网络与 Token）`
+      : `${reason}，${delayText} 后自动重连（第 ${this._restartCount}/${this.retry.maxRetries} 次）`);
     this._retryTimer = setTimeout(() => {
       this._retryTimer = null;
       this._restartAttempt();
@@ -402,6 +497,14 @@ export class CloudflaredManager {
       });
       this.process = proc;
 
+      // 本次 spawn 独立状态：metrics 地址与日志流都随进程生命周期重建；
+      // 代数（_spawnSeq）用于让飞行中的旧探活结果作废——重启后 cloudflared 很
+      // 可能复用同一个 metrics 端口，仅比对地址字符串不足以识别"这是新进程"。
+      this._metricsAddress = null;
+      this._metricsParseTail = '';
+      this._spawnSeq++;
+      this._openLogStream();
+
       let resolved = false;
       let timeoutTimer = null;
       // 累积 stderr 尾部（供 exit 时判断确定性失败：CLI 用法错误 / 配置错误）
@@ -418,8 +521,10 @@ export class CloudflaredManager {
             clearTimeout(timeoutTimer);
             timeoutTimer = null;
           }
-          // 就绪即证明链路可用，连续失败计数清零
+          // 就绪即证明链路可用：连续失败计数清零，并退出"健康重建"模式
           this._restartCount = 0;
+          this._healthRecovering = false;
+          this._startHealthProbe(); // 就绪后才探活：启动阶段的问题由握手超时/exit 负责
           resolve();
         }
       };
@@ -460,10 +565,34 @@ export class CloudflaredManager {
         }
       };
 
-      proc.stdout.on('data', (d) => parseUrl(d.toString()));
+      // metrics 地址必须先于就绪文本被记录：cloudflared 是先起 metrics 服务再注册连接。
+      // 两处稳健性处理：
+      //  1) 该日志行本身也可能被 chunk 切断 → 用滚动缓冲拼接后再匹配；
+      //  2) 地址可能"迟到"（就绪时还没解析到）→ 一旦补上就补启探活，否则安全网永久不启用。
+      const captureMetricsAddress = (text) => {
+        if (this._metricsAddress) return;
+        const buffered = (this._metricsParseTail + text).slice(-512);
+        this._metricsParseTail = buffered;
+        const addr = parseMetricsAddress(buffered);
+        if (!addr) return;
+        this._metricsAddress = addr;
+        if (resolved && !this._stopped && !this._probeTimer) {
+          this._probeLog('info', 'metrics 地址在就绪后才解析到，补启运行时健康探活: %s', addr);
+          this._startHealthProbe();
+        }
+      };
+
+      proc.stdout.on('data', (d) => {
+        const text = d.toString();
+        this._appendCloudflaredLog(text);
+        captureMetricsAddress(text);
+        parseUrl(text);
+      });
       proc.stderr.on('data', (d) => {
         const text = d.toString();
         this.logger?.debug('cloudflared: %s', text.trim());
+        this._appendCloudflaredLog(text);
+        captureMetricsAddress(text);
         stderrTail = (stderrTail + text).slice(-2000); // 只保留尾部 2KB
         parseUrl(text);
         if (text.includes('Registered tunnel') && !resolved) {
@@ -476,6 +605,9 @@ export class CloudflaredManager {
           clearTimeout(timeoutTimer);
           timeoutTimer = null;
         }
+        // 探活定时器与日志流都绑定本次 spawn，退出即回收（自愈会重新建立）
+        this._stopHealthProbe();
+        this._closeLogStream();
         // exit 时"仍是当前进程"才允许清理引用 + 调度自愈。
         // 自愈已 spawn 新进程后，旧进程迟到的 exit 不满足 stillCurrent → 静默，
         // 避免"新进程连接中、旧 exit 又触发一次重启"的竞态（否则会叠出第三进程）。
@@ -491,7 +623,8 @@ export class CloudflaredManager {
           if (isFatalCloudflaredError(stderrTail)) err.fatal = true;
           reject(err);
         } else if (!this._stopped && stillCurrent) {
-          // 就绪后的意外退出（崩溃 / OOM / 误杀 / autoupdate 残留自替换）→ 退避自愈
+          // 就绪后的意外退出（崩溃 / OOM / 误杀 / autoupdate 残留自替换 / 健康探针判定假死）
+          // → 退避自愈。是否允许终态由 _scheduleRestart 依 _healthRecovering 判定。
           this._scheduleRestart(`cloudflared 进程意外退出 (code=${code ?? ''}${signal ? `, ${signal}` : ''})`);
         } else {
           this._setState('idle', '');
@@ -503,6 +636,8 @@ export class CloudflaredManager {
           clearTimeout(timeoutTimer);
           timeoutTimer = null;
         }
+        this._stopHealthProbe();
+        this._closeLogStream();
         if (!resolved) reject(err);
       });
 
@@ -518,7 +653,298 @@ export class CloudflaredManager {
     });
   }
 
-  _setState(phase, detail) {
+  // ── cloudflared 输出落盘（含 Token 脱敏与大小轮转）──────────────────────
+
+  // Token 属敏感凭据，落盘前一律替换；不依赖上游是否会自行脱敏。
+  //
+  // 关键：stderr 的 'data' 事件不保证按行对齐，Token 可能被切分在两个块之间。
+  // 这里用**逐字符扫描**而不是"整块 split 替换"：
+  //   - 任意位置命中完整 Token → 替换为 ***（完整 Token 绝不会明文落盘）；
+  //   - 只在"剩余不足一个 Token 长度、且恰好是 Token 前缀"时才扣住，等下一块补齐。
+  // 不能退化成"扣掉最长的 Token 前缀后缀"这种简化写法：若 Token 自身存在 border
+  // （例如首尾字符相同），完整 Token 结尾处也会被误判成前缀而扣下一截，结果前半段
+  // 与扣下的那截先后写出、在文件里重新拼成完整 Token（已实测的泄漏路径）。
+  _redactToken(text) {
+    if (!this.token) return text;
+    const token = this.token;
+    const L = token.length;
+    const combined = this._redactCarry + text;
+    this._redactCarry = '';
+    let out = '';
+    let i = 0;
+    while (i < combined.length) {
+      if (i + L <= combined.length && combined.startsWith(token, i)) {
+        out += '***';
+        i += L;
+        continue;
+      }
+      if (i + L > combined.length) {
+        const rest = combined.slice(i);
+        if (token.startsWith(rest)) {
+          this._redactCarry = rest; // 可能是被切开的 Token 前半段
+          break;
+        }
+      }
+      out += combined[i];
+      i++;
+    }
+    return out;
+  }
+
+  _openLogStream() {
+    this._closeLogStream(); // 幂等：自愈重启时先关掉上一个进程的流，避免句柄堆积
+    if (!this.logFilePath) return;
+    try {
+      mkdirSync(dirname(this.logFilePath), { recursive: true });
+      // 同步把文件建出来：createWriteStream 是异步 open，若不在此时落地，
+      // 紧随其后的轮转判定会遇到"文件还没存在"而 rename 落空（运行中轮转失效）。
+      writeFileSync(this.logFilePath, '', { flag: 'a' });
+      this._rotateIfOversize();
+      this._logBytesWritten = existsSync(this.logFilePath) ? statSync(this.logFilePath).size : 0;
+    } catch (err) {
+      // 目录创建/建文件/取大小失败：不阻断日志写入，但必须让问题可见
+      this.logger?.warn('cloudflared 日志目录或文件准备失败（本次可能不落盘）: %s', err.message);
+    }
+    try {
+      const stream = createWriteStream(this.logFilePath, { flags: 'a' });
+      stream.on('error', (err) => {
+        // 流已不可写：置空引用，避免后续继续往死流写并重复刷同一条告警
+        this._logStream = null;
+        this.logger?.warn('cloudflared 日志写入失败: %s', err.message);
+      });
+      this._logStream = stream;
+    } catch (err) {
+      this._logStream = null;
+      this.logger?.warn('无法打开 cloudflared 日志文件 %s: %s', this.logFilePath, err.message);
+    }
+  }
+
+  _rotateIfOversize() {
+    if (!this.logFilePath) return;
+    try {
+      if (existsSync(this.logFilePath) && statSync(this.logFilePath).size >= this.logMaxBytes) {
+        renameSync(this.logFilePath, `${this.logFilePath}.1`);
+        this._logBytesWritten = 0;
+      }
+    } catch (err) {
+      this.logger?.warn('cloudflared 日志轮转失败（继续追加写）: %s', err.message);
+    }
+  }
+
+  _closeLogStream() {
+    // 无论流是否可用，carry 都必须清空——否则残留的 Token 片段会污染下一个
+    // 进程的第一行日志（流先报 error 置空、随后 close 早退的场景实测可复现）。
+    const carry = this._redactCarry;
+    this._redactCarry = '';
+    if (!this._logStream) return;
+    // 流关闭时仍扣着的必然是 Token 的一个前缀（见 _redactToken）：以占位符收尾。
+    // 取舍说明：这会牺牲最多 token.length-1 个正常字符的日志保真度，
+    // 但换来"任何 Token 片段都不落盘"。极端情况下宁可少一行尾巴，不可留密钥片段。
+    if (carry) this._logStream.write('***');
+    this._logStream.end();
+    this._logStream = null;
+  }
+
+  _appendCloudflaredLog(text) {
+    if (!this._logStream || !text) return;
+    const out = this._redactToken(text);
+    if (!out) return;
+    const bytes = Buffer.byteLength(out, 'utf8');
+    // 运行中也检查轮转：只在 spawn 时检查会让长寿命进程把日志写爆。
+    // 这里按"本次运行已写入字节数"判定，不依赖 statSync——写流是异步的，
+    // 刚写完就 stat 可能仍是旧大小，会造成轮转判定抖动。
+    if (this._logBytesWritten + bytes >= this.logMaxBytes) {
+      this._closeLogStream();
+      this._renameToRotated();
+      this._openLogStream();
+      if (!this._logStream) return;
+    }
+    this._logStream.write(out);
+    this._logBytesWritten += bytes;
+  }
+
+  _renameToRotated() {
+    if (!this.logFilePath) return;
+    try {
+      if (existsSync(this.logFilePath)) renameSync(this.logFilePath, `${this.logFilePath}.1`);
+    } catch (err) {
+      this.logger?.warn('cloudflared 日志轮转失败（继续追加写）: %s', err.message);
+    }
+    this._logBytesWritten = 0;
+  }
+
+  // ── 运行时健康探针 ──────────────────────────────────────────────────────
+
+  // 就绪后启动探活。metrics 地址解析失败时显式告警并跳过——绝不静默降级，
+  // 也绝不在没有可信探活通道的情况下误杀进程；同时把降级写进面板可见的状态详情，
+  // 否则"整个安全网失效"只会是一行没人看的 journal warning（本次事故的教训）。
+  // 探针专用安全日志：探针跑在定时器与子进程数据回调里，异常没有任何上层接住，
+  // 一旦 logger 自身抛错就会变成未处理 rejection —— Node 默认 unhandled-rejections=throw
+  // 会直接结束宿主进程，即"本该保护服务的探针把服务干掉"。故此处绝不允许抛出。
+  _probeLog(level, msg, ...args) {
+    try {
+      this.logger?.[level]?.(msg, ...args);
+    } catch (logErr) {
+      // 日志通道本身故障：此处再抛就会拖垮宿主进程，故刻意吞掉。
+      // 这不是"静默降级"——要输出的降级信息本身就在这条已损坏的通道上，无处可写；
+      // 且关键降级仍经 _setState → 面板独立可见，不依赖 logger。
+      // 注意：该计数目前只在单测中被读取，生产尚无出口（后续可接入面板/统计），
+      // 因此不要把它当作"生产可自查"的手段。
+      this._probeLogFailures++;
+    }
+  }
+
+  _startHealthProbe() {
+    this._stopHealthProbe();
+    if (!this._metricsAddress) {
+      const detail = `${this._readyState?.detail || '隧道已建立'}；⚠️ 运行时健康探活未启用`
+        + '（未识别到 cloudflared metrics 地址），连接器若静默假死将无法自动发现';
+      this._probeLog('warn', '未从 cloudflared 输出识别到 metrics 地址，本次运行跳过健康探活'
+        + '（连接器若静默假死将无法自动发现，请检查 cloudflared 版本是否变更了 metrics 日志文案）');
+      // record:false —— 这是降级提示，不能污染"纯净的 ready 详情"，
+      // 否则地址迟到后补启探活时将无法把面板文案恢复成正常状态。
+      this._setState('ready', detail, { record: false });
+      return;
+    }
+    // 地址迟到后补启探活：把面板文案恢复为正常的 ready 详情
+    if (this._readyState) this._setState(this._readyState.phase, this._readyState.detail);
+    this._probeTimer = setInterval(() => {
+      // 必须显式 catch：探针里任何逃逸的异常（如畸形 metrics 地址让 http.get 同步抛错）
+      // 都会变成未处理 rejection，而 Node 默认 unhandled-rejections=throw 会直接
+      // 结束整个 DSH 主进程 —— 那正是探针本该防止的"服务整体消失"。
+      // 用 _probeLog 而非 logger 直调：catch 处理器自身也不允许再抛。
+      this._probeOnce().catch((err) => {
+        this._probeLog('warn', '健康探活出现未预期异常（已忽略，不影响连接器运行）: %s', err?.message ?? err);
+      });
+    }, this.healthProbeIntervalMs);
+    this._probeTimer.unref?.(); // 不因探活定时器而阻止进程退出
+  }
+
+  _stopHealthProbe() {
+    if (this._probeTimer) {
+      clearInterval(this._probeTimer);
+      this._probeTimer = null;
+    }
+    this._probeFailures = 0;
+  }
+
+  async _probeOnce() {
+    // 防重叠：单次探活最长 healthProbeTimeoutMs，若上一轮还没结论就不再叠加请求
+    if (this._probeInFlight) return;
+    const addr = this._metricsAddress;
+    if (!addr) return;
+    const seq = this._spawnSeq; // spawn 代数：据此识别"结果属于哪个进程"
+
+    this._probeInFlight = true;
+    let result;
+    try {
+      result = await this._checkTunnelReady(addr);
+    } catch (err) {
+      // 兜底：探针内部任何异常都不得向外逃逸（见 setInterval 处的说明）
+      result = { healthy: false, reason: `探针内部异常: ${err?.message ?? err}` };
+    } finally {
+      this._probeInFlight = false;
+    }
+    this._probeCount++;
+
+    // 探活期间可能已被 stop()、或已自愈重启到新进程 → 结果作废。
+    // 必须比对代数而非地址：重启后 cloudflared 很可能复用同一个 metrics 端口。
+    if (this._stopped || this._spawnSeq !== seq) return;
+
+    if (result.healthy) {
+      if (this._probeFailures >= this.healthDegradedThreshold) {
+        this._probeLog('info', '隧道健康探活已自行恢复（此前连续失败 %d 次）', this._probeFailures);
+        if (this._readyState) this._setState(this._readyState.phase, this._readyState.detail);
+      }
+      this._probeFailures = 0;
+      return;
+    }
+
+    this._probeFailures++;
+    const fails = this._probeFailures;
+    const why = result.reason || '未知原因';
+
+    if (fails === this.healthDegradedThreshold) {
+      // 第一级：可见降级。此时不杀进程——/ready 为 503 也可能只是 cloudflared
+      // 正在按自身退避重连，过早介入反而会把本可自愈的故障变成人工故障。
+      this._probeLog('warn', '隧道健康探活连续 %d 次失败（%s）：连接器可能已无健康边缘连接，'
+        + '转入降级观察，达 %d 次将强制重建', fails, why, this.healthRestartThreshold);
+      this._setState('reconnecting', `健康探活连续 ${fails} 次失败：连接器已无健康边缘连接，`
+        + `正在观察能否自行恢复（${fails}/${this.healthRestartThreshold}）`);
+    } else if (fails < this.healthDegradedThreshold) {
+      this._probeLog('warn', '隧道健康探活失败（第 %d/%d 次）: %s；原因: %s',
+        fails, this.healthRestartThreshold, addr, why);
+    } else {
+      this._probeLog('warn', '隧道健康探活仍失败（第 %d/%d 次）: %s', fails, this.healthRestartThreshold, why);
+    }
+
+    if (fails < this.healthRestartThreshold) return;
+
+    // 第二级：持续不恢复 → 判定假死，强制重建。
+    // 置 _healthRecovering：整条重建链路（含重启后握手失败）都不允许进入终态。
+    this._probeLog('error', '隧道连接器连续 %d 次探活失败（约 %d 分钟）：判定为假死，'
+      + '终止进程以触发重建；该重建不设终态上限，网络恢复后仍会自愈',
+    fails, Math.round(fails * this.healthProbeIntervalMs / 60000));
+    this._stopHealthProbe();
+    this._healthRecovering = true;
+    this._terminateProcess(); // 不自行重启：交给 exit → _scheduleRestart 既有链路
+  }
+
+  // 探活判据：HTTP 200 且 readyConnections > 0（与 cloudflared 官方 /ready 语义一致）。
+  // 返回 { healthy, reason }：reason 会进入 warn 级日志，生产关闭 debug 时也能看到原因。
+  // 注意：http 的 timeout 选项只是 **socket 不活动** 超时，不是总时限——对"持续滴流
+  // 字节"的响应永不触发，因此这里额外加一个绝对截止时间兜底。
+  _checkTunnelReady(addr) {
+    return new Promise((resolve) => {
+      let settled = false;
+      let deadline = null;
+      let req = null;
+      const done = (healthy, reason) => {
+        if (settled) return;
+        settled = true;
+        if (deadline) clearTimeout(deadline);
+        try { req?.destroy(); } catch { /* 已结束的请求 destroy 无害 */ }
+        resolve({ healthy, reason });
+      };
+
+      deadline = setTimeout(() => {
+        done(false, `探活超过总时限 ${this.healthProbeTimeoutMs}ms`);
+      }, this.healthProbeTimeoutMs);
+
+      // httpGet 对畸形 URL 会同步抛错；虽然 parseMetricsAddress 已在入口校验，
+      // 这里再兜一层，确保该函数永不向外抛（否则会变成未处理 rejection 拖垮主进程）。
+      try {
+        req = httpGet(`http://${addr}/ready`, { timeout: this.healthProbeTimeoutMs }, (res) => {
+          let body = '';
+          res.setEncoding('utf8');
+          res.on('data', (chunk) => { body += chunk; });
+          res.on('end', () => {
+            if (res.statusCode !== 200) {
+              done(false, `HTTP ${res.statusCode}`);
+              return;
+            }
+            try {
+              const parsed = JSON.parse(body);
+              const conns = Number(parsed?.readyConnections);
+              done(conns > 0, conns > 0 ? '' : `HTTP 200 但 readyConnections=${parsed?.readyConnections}`);
+            } catch (err) {
+              done(false, `响应无法解析为 JSON: ${err.message}`);
+            }
+          });
+        });
+      } catch (err) {
+        done(false, `无法发起探活请求（地址可能非法）: ${err.message}`);
+        return;
+      }
+      req.on('timeout', () => { done(false, `socket 不活动超过 ${this.healthProbeTimeoutMs}ms`); });
+      req.on('error', (err) => { done(false, `请求失败: ${err.message}`); });
+    });
+  }
+
+  _setState(phase, detail, { record = true } = {}) {
+    // 记住最近一次"纯净"的 ready 状态：探活由降级恢复、或地址迟到后补启探活时
+    // 要回写它，避免面板长期停留在降级文案上（record:false 用于降级提示本身）。
+    if (phase === 'ready' && record) this._readyState = { phase, detail };
     this.onStateChange?.({ phase, detail });
   }
 
@@ -529,6 +955,8 @@ export class CloudflaredManager {
       this._retryTimer = null;
     }
     this._restartCount = 0;
+    this._stopHealthProbe();
+    this._closeLogStream();
     if (this.process) {
       this.logger?.info('停止 cloudflared...');
       this._terminateProcess();

package/lib/index.js

@@ -16,7 +16,7 @@ import { spawn } from 'node:child_process';
 import QRCode from 'qrcode';
 import { installBridgeRpc } from './bridge-rpc.js';
 import { CustomTunnelClient } from './tunnel-client.mjs';
-import { CloudflaredManager } from './cloudflared-manager.mjs';
+import { CloudflaredManager, CLOUDFLARED_LOG_NAME } from './cloudflared-manager.mjs';
 import { PlatformManager } from './platform/manager.js';
 import { applyRestoredPlatformConfig, RESTORED_STRING_FIELDS, PLATFORM_TIMING_FIELDS } from './platform/config-restore.js';
 import { WechatService } from './wechat/index.js';
@@ -177,7 +177,7 @@ const PWA_ICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 5
   <circle cx="256" cy="80" r="16" fill="#4f6ef7"/>
 </svg>`;
 
-const HTML_HEAD_INJECTIONS = `<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
+const HTML_HEAD_ASSETS = `<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
 <meta name="apple-mobile-web-app-capable" content="yes">
 <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
 <meta name="apple-mobile-web-app-title" content="DSH">
@@ -187,9 +187,14 @@ const HTML_HEAD_INJECTIONS = `<meta name="viewport" content="width=device-width,
 <link rel="apple-touch-icon" href="/__dsh_bridge__/pwa-icon.svg">
 <style data-dsh-bridge-overscroll="1">html,body{overscroll-behavior-y:none;-webkit-overflow-scrolling:touch}</style>
 <script data-dsh-bridge-polyfill="1">!function(){try{if(self.crypto&&!self.crypto.randomUUID){self.crypto.randomUUID=function(){var b=new Uint8Array(16);self.crypto.getRandomValues(b);b[6]=b[6]&15|64;b[8]=b[8]&63|128;var h="";for(var i=0;i<16;i++){var x=b[i].toString(16);h+=(x.length<2?"0":"")+x;if(i===3||i===5||i===7||i===9)h+="-";}return h;}}}catch(e){}}();</script>
-${BROWSER_ABORT_SIGNAL_POLYFILL}
-${BROWSER_PROMISE_ITERATOR_POLYFILL}`;
-const INJECT_MARK = 'data-dsh-bridge-polyfill="1"';
+`;
+/** 可分别判重注入的三段：各自的 data 标记即去重键（旧版只按 marker 1 判重，
+ *  两层桥串联时会出现"上游有 1 没有 2/3 → 整段跳过"的漏注入）。 */
+const HTML_INJECTION_PARTS = [
+  { mark: 'data-dsh-bridge-polyfill="1"', html: HTML_HEAD_ASSETS },
+  { mark: 'data-dsh-bridge-polyfill="2"', html: BROWSER_ABORT_SIGNAL_POLYFILL },
+  { mark: 'data-dsh-bridge-polyfill="3"', html: BROWSER_PROMISE_ITERATOR_POLYFILL },
+];
 
 function isCompressed(headers) {
   return /(^|,\s*)(gzip|br|deflate)(\s*,|$)/i.test(String(headers['content-encoding'] ?? ''));
@@ -274,10 +279,11 @@ function sanitizeProxyHeaders(headers, extra) {
  */
 export function parseSystemdUnit(cgroup) {
   const parts = String(cgroup || '').split('/').filter(Boolean);
-  for (let i = parts.length - 1; i >= 0; i -= 1) {
-    if (parts[i].endsWith('.service')) return parts[i];
-  }
-  return '';
+  // 只认**最内层**组件：若最内层不是 .service（例如 .scope、或 docker/k8s 的容器目录），
+  // 说明本进程不是被某个 service 直接托管，绝不能向上游误取祖先单元
+  // （否则会把 docker.service / cron.service 之类重启掉）。
+  const innermost = parts[parts.length - 1] ?? '';
+  return innermost.endsWith('.service') ? innermost : '';
 }
 
 /**
@@ -508,8 +514,10 @@ class ProxyServer {
               const outHeaders = { ...proxyRes.headers };
               if (contentType.includes('text/html') && !isCompressed(proxyRes.headers)) {
                 let html = out.toString('utf8');
-                if (!html.includes(INJECT_MARK)) {
-                  html = html.replace(/<head[^>]*>/i, (m) => `${m}${HTML_HEAD_INJECTIONS}`);
+                const missingParts = HTML_INJECTION_PARTS.filter((part) => !html.includes(part.mark));
+                if (missingParts.length > 0) {
+                  const payload = missingParts.map((part) => part.html).join('\n');
+                  html = html.replace(/<head[^>]*>/i, (m) => `${m}${payload}`);
                 }
                 out = Buffer.from(html, 'utf8');
               } else if (isSessionProjection) {
@@ -997,6 +1005,9 @@ class BridgeService {
       home: this.home,
       token: this.cloudflaredConfig?.token,
       hostname: this.cloudflaredConfig?.hostname,
+      // cloudflared 自身的 stdout/stderr 落盘：事故时 journal 里没有任何连接器日志，
+      // 导致断连时间点与原因完全无法定位（内含 Token 脱敏与 5MB 轮转）。
+      logFilePath: join(this.home ?? join(homedir(), '.dsh-bridge'), CLOUDFLARED_LOG_NAME),
       onStateChange: (state) => {
         this.cloudflaredState = state;
         // 注意：不在 error 时清空 this.cloudflared 引用。
@@ -1378,26 +1389,39 @@ class BridgeService {
 
     if (plan.kind === 'systemd') {
       const args = [...(plan.scope === 'user' ? ['--user'] : []), 'restart', '--no-block', plan.unit];
-      const spawnError = await new Promise((resolve) => {
+      // 关键：必须以 **systemctl 的退出码** 判定成败，而不是"派生成功"。
+      // `--no-block` 下 systemctl 只发请求就返回（实测往返 ~6ms），但单元名不存在会 rc=5、
+      // 权限不足会 rc=1；旧写法只看 'spawn' 事件 → 必然失败也返回 ok:true 再 exit(0)，
+      // 而干净退出不满足 Restart=on-failure → DSH 直接下线且不自动拉起。
+      const outcome = await new Promise((resolve) => {
         let settled = false;
         const settle = (value) => { if (!settled) { settled = true; resolve(value); } };
         try {
           const child = spawnImpl('systemctl', args, { detached: true, stdio: 'ignore', env });
-          child.once?.('error', (err) => settle(err));
-          child.once?.('spawn', () => settle(null));
+          child.once?.('error', (err) => settle({ error: err }));
+          child.once?.('close', (code) => settle({ code }));
           child.unref?.();
         } catch (err) {
-          settle(err);
+          settle({ error: err });
         }
       });
 
-      if (!spawnError) {
-        writeLog(`已请求 systemd 重启：systemctl ${args.join(' ')}`);
+      if (!outcome.error && (outcome.code === 0 || outcome.code === null || outcome.code === undefined)) {
+        writeLog(`已请求 systemd 重启（systemctl 退出码 ${outcome.code ?? 'n/a'}）：systemctl ${args.join(' ')}`);
         scheduleExit(1500);
         const scopeText = plan.scope === 'user' ? '用户会话' : '系统';
         return { ok: true, message: `已请求 systemd 重启 ${plan.unit}（${scopeText}），由 systemd 负责停止与拉起…` };
       }
-      writeLog(`调用 systemctl 失败：${spawnError.message}；回退到独立助手方式`);
+
+      // 失败时**不退化为自派生**：systemd 下主进程干净退出既不会被拉起，
+      // 默认 KillMode=control-group 还会把 detached 助手一起杀掉 —— 那等于"报着重启却永久下线"。
+      // 因此保持现状（DSH 继续运行）并如实报错，由用户手动处理。
+      const reason = outcome.error ? outcome.error.message : `systemctl 退出码 ${outcome.code}`;
+      writeLog(`systemctl 重启失败（${reason}），为不让 DSH 掉线未做任何退出`);
+      return {
+        ok: false,
+        error: `systemctl ${args.join(' ')} 失败：${reason}。DSH 仍在运行；请手动执行「systemctl ${plan.scope === 'user' ? '--user ' : ''}restart ${plan.unit}」或检查单元。`,
+      };
     } else if (plan.kind === 'daemon') {
       writeLog(`交由守护进程拉起（${plan.reason}）`);
       scheduleExit(600);

package/lib/restart-helper.mjs

@@ -81,15 +81,33 @@ async function main() {
 
   let stdio = 'ignore';
   try { stdio = openSync(childLog, 'a'); } catch { /* 打不开就用 ignore */ }
-  let child;
-  try {
-    child = spawn(execPath, argv, { cwd, env: process.env, detached: true, stdio: ['ignore', stdio, stdio] });
-  } catch (err) {
-    log(`派生新 dsh 失败：${err?.message ?? err}`);
-    process.exit(4);
-  }
-  log(`已派生新 dsh：pid=${child.pid ?? '(未知)'}（输出见 ${childLog}）`);
-  child.unref();
+
+  // spawn 的失败是异步 'error' 事件（例如 execPath 不存在 → ENOENT），只 try/catch 抓不到；
+  // 不挂监听会变成未捕获异常，而且父进程给助手设的是 stdio:'ignore' → 失败细节全部丢失。
+  // 这里挂监听并把原因写进日志，且**确认 spawn 成功后才**记录"已派生"。
+  const spawned = await new Promise((resolve) => {
+    let settled = false;
+    const settle = (value) => { if (!settled) { settled = true; resolve(value); } };
+    let child;
+    try {
+      child = spawn(execPath, argv, { cwd, env: process.env, detached: true, stdio: ['ignore', stdio, stdio] });
+    } catch (err) {
+      log(`派生新 dsh 失败（同步异常）：${err?.message ?? err}`);
+      settle(null);
+      return;
+    }
+    child.once('error', (err) => {
+      log(`派生新 dsh 失败：${err?.message ?? err}`);
+      settle(null);
+    });
+    child.once('spawn', () => {
+      log(`已派生新 dsh：pid=${child.pid ?? '(未知)'}（输出见 ${childLog}）`);
+      settle(child);
+    });
+  });
+
+  if (!spawned) process.exit(4);
+  spawned.unref();
 
   const up = await waitUntil(() => portAccepts(port), readyTimeoutMs, `新 dsh 监听 ${port}`);
   log(up

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@wenbin_wb/dsh-bridge",
-  "version": "2.10.11",
+  "version": "2.10.13",
   "description": "手机扫码即可在移动端/公网继续用 DeepSeek Harness，人不在电脑前也能接着干。一键局域网二维码、Cloudflare 公网隧道、自建隧道与微信 / QQ / 飞书 / Telegram Bot（多工作区/会话持久化/媒体/卡片审批/流式输出），无需自己搭公网服务器。",
-  "releaseNotes": "【v2.10.11】\n• 修复：移动端顶栏压住 position:fixed 全屏面板顶部 52px（#41）——桥的让位方式此前只给内容框架加 padding-top，而 fixed 元素的包含块是视口、不跟随祖先内边距；官方右侧栏在窄视口（<768px）自动全屏（fixed; inset:0），顶部标签栏因此落进顶栏覆盖区，面板右端的「全屏 / 收起」按钮右半还会被顶栏「+」夺走点击，误触会直接新建会话。现按 [data-sidebar-right-panel=fullscreen] 直接位移面板容器本身（top 下移 52px 并同步收窄高度），不依赖宿主 CSS 模块哈希类名，宿主升级不失效。**若你此前用用户侧 CSS 以 top 手动让位过，本次修复与之同属性，级联只会生效一条、不会叠加；但若你用的是 padding-top / margin-top / transform 位移，请撤掉旧规则以免叠加下移 52px。**\n• 修复：移动端断点与宿主判据对齐——桥原按 ≤768px（运行时亦为 innerWidth<=768），宿主按 viewportWidth<768 判定右侧栏自动全屏，恰在 768px 出现「桥渲染移动端顶栏、宿主按桌面布局」的错位；现移动端统一为 ≤767px，768px 起彻底交还桌面布局。\n• 修复：鸿蒙（HuaweiBrowser / ArkWeb）手机上图右侧栏文件与对话生成文档的预览全部显示「文件资源服务不可用。」——该内核解析非特殊 scheme 时 new URL('dsh-resource://file/…').hostname 返回空串，而 DSH 的客户端资源注册表正是拿 hostname 当协议键，于是资源记录被判成「没有 provider」并永久停在 none（注册表只在 provider 注册那一刻回挂一次已有记录，之后不再重试，故刷新也不恢复）。现桥侧新增 dsh-resource 地址的 URL 兼容层：先做特性探测，只有引擎确有差异时才包装 window.URL，且仅对 hostname 为空的 dsh-resource 地址补上兜底 host；引擎正常时完全不介入。iOS / Android / 桌面端行为不变。\n• 修复：iOS 16 / 旧 Safari 完全打不开 DSH（红屏 Failed to load plugins … Can't find variable: Iterator）——DSH 自带 pdf.js 在模块顶层引用 Safari 18.4 才有的 Iterator 全局，iOS 16 上直接抛错并使整个客户端插件树加载失败；同类缺口还有 Promise.withResolvers（Safari 17.4+，DSH 启动握手与多个插件运行期都在用）。现桥在代理注入 HTML 时、于宿主所有脚本之前补齐这两枚垫片（Iterator 会把真实的内置迭代器共享原型挂到 Iterator.prototype），只在缺失时安装，iOS 18.4+ / Android / 桌面端零改动。\n• 修复：「重启 DSH」按钮在 systemd 托管下点了没用（DSH 没起来、只能手动重启、且不留日志）——旧实现不识别托管器，直接自派生子进程后 process.exit(0)：systemd 下 Restart=on-failure 不认干净退出、默认 KillMode=control-group 又会把刚派生的子进程一起杀掉，加上 stdio 被 ignore，失败完全无声。现从 /proc/self/cgroup 识别 systemd 单元并交给 systemctl [--user] restart --no-block <unit>；DSH_DAEMON/PM2 仍走守护进程；无托管器时派生独立助手，等旧进程退出与端口释放后再拉起新 DSH，并在 120s 内确认端口可连接，全过程写入 ~/.dsh/dsh-bridge/restart.log。前端在宿主返回 ok:false 时直接报错，不再假装重连。systemd 环境需先手动重启一次让本修复生效。",
+  "releaseNotes": "【v2.10.13】可靠性加固 + 跟随 DSH 0.1.5 目录选择器\n• 新增：cloudflared 运行时健康探针——每 30s 探活官方 /ready，连续 3 次失败（约 90s）面板可见降级，连续 10 次（约 5min）判定假死自动强制重建，重建永不进终态（网络恢复后自愈）\n• 新增：cloudflared 输出落盘 ~/.dsh/dsh-bridge/cloudflared.log（5MB 轮转 .1），Token 跨 chunk 强制脱敏\n• 修复：连接器假死时公网入口静默失效数天无人发现（HTTP 530 / error code 1033），旧逻辑只监听进程退出故永不触发\n• 修复：本机点「添加工作区」误弹插件的远程抽屉（issue #28）——DSH 0.1.5 自带官方目录选择器且 slots 为 shadow 语义，插件同名 Slot 覆盖了官方实现；现本机 + 官方 picker 可用时不再注册该 Slot（macOS/Windows 走系统原生对话框、无桌面 Linux 走官方网页选择器），旧版 DSH 与远程/移动仍由插件兜底\n• 修复：添加工作区弹窗点过「已注册工作区」后永久卡死（PR #42）——switchToWorkspace 只置位 isSubmitting 从不复位，改为与 doSubmit 对称的 try/finally\n• 修复：探针路径任何异常（畸形地址、日志通道抛错）都不会拖垮 DSH 主进程\n• 测试：新增 18 条探针 + 12 条目录选择器让位 + 3 条弹窗状态复位回归测试\n• 说明：本版需重启一次 dsh（systemctl --user restart dsh-web.service）才生效",
   "type": "module",
   "main": "lib/index.js",
   "exports": {