dsh-over-ssh 0.2.2 → 0.2.3

package/README.md

@@ -19,6 +19,12 @@ npm i && npm run build
 dsh plugin --profile web add /绝对路径/dsh-over-ssh
 ```
 
+> **GUI 安装提示**：pnpm 会问是否允许安装脚本，列表里是 `ssh2` 与 `cpu-features`：允许后重试即可。
+> 它们是 `ssh2` 传输的可选原生加速，拒绝会让 pnpm 中止本次安装（插件源码本身没有安装脚本）。
+>
+> 0.2.2 及更早在运行中的页面上启用插件时出现过 `2 entries did not activate`（`workingDirectory` /
+> `fileReferences` 链）；0.2.3 删掉了那条私有域克隆链（审计 0134），不再需要为它重启。
+
 **远端终端**要额外配一次 `terminalController.Config.shell`——`Config.shell` 是静态单值，连哪台只能由 wrapper 运行时决定：
 
 | 装法 | 指向 |
@@ -35,6 +41,30 @@ shell:
 
 不配也能用，只是 Web 终端永远开在本地（远程文件、远端执行、`@` 补全不受影响）。
 
+## 0.2.3 更新
+
+> 下面这些内容相对 npm 上的 **0.2.2** 一起生效。
+
+- **热启用不再失败**：移除私有域里对平台 `@deepseek-ai/dsh-file-reference-local` 的克隆与 `localFileReferences` 桥：
+  根作用域的 `file-references` 本来就自己实现本地有界走查，那份克隆没有消费者。效果是启用插件时
+  不再出现 `2 entries did not activate`（`workingDirectory` / `fileReferences` 等待链），热启用可以直接
+  完成，不必为它完整重启。
+- 组合层因此只剩 6 个条目（原 8 个）：私有域只保留 `fs-sandbox` 克隆 + `localFs` 桥，本地写入围栏仍由
+  平台沙箱执行。
+- 文件引用补全复查（审计 0135）：单个远端来源失败只降级该来源，不再让整个 `@` 补全失败；缓存命中后
+  的取消仍按取消处理；Windows 本地根的反斜杠路径参与文件名/深度排序；符号链接目录按目录处理，只有
+  指向根内的链接会被展开（根外链接只列链接本身，不把工作区外的文件带进 `@`），并带环检测与 Windows
+  忽略目录大小写处理；打字快于一次走查时，同根并发调用共享一次树枚举、不再重复扫树（探针：6 次击键
+  = 1 次走查）。
+- LSP 复查（审计 0136）：`remote_lsp` 的 `server` 支持带空格的路径（引号切分，`"/opt/my tools/server" --stdio`，
+  未闭合引号明确报错）；宿主 `lsp.read` 每轮只取 256 KiB，不再吃满代理 2 MiB 默认块；客户端卡片的初始
+  焦点与 Tab 集合跳过不可见控件。
+- 回收站与锁（审计 0137）：索引记录父子关系，**还原父会话会连带还原子会话**（失败留在垃圾并回报）；
+  会话/回收站锁加心跳，跨设备大目录 copy 超过 60 s 也不会被当成陈旧锁抢走；缺 `entryId` 的回收站条目
+  现在可见但不可操作并说明原因；连接被删除后编辑对话框不再提交请求。
+- 构建：删掉的宿主入口产物会被清理，不再随包发出（0.2.3 首次打包曾多带一个 `local-bridge-refs.js`）。
+- 其余行为不变；远端 `@`、本地 `@`、文件工具、会话面板均未改动。
+
 ## 0.2.2 更新
 
 - 「添加目录」按会话作用域显示与删除，fork 子会话继承父会话的目录且立即可见。
@@ -54,10 +84,10 @@ shell:
 
 | 平台 | 字节 | sha256 |
 |---|---|---|
-| linux-amd64 | 4,944,032 | `d45237ef1bfec1955fb5e6a2391bd651ffeaffb89e781e1c518e9e9836eec974` |
-| linux-arm64 | 4,653,216 | `237a3cc9f5ae57f752f62eee4f8a57bd8c4684fd4d3fa6ab5851115baa844ccd` |
+| linux-amd64 | 4,944,032 | `a1272e45a8213d4725a9eb91f9d08f1b5f460623e38730abef735c4569339d8d` |
+| linux-arm64 | 4,653,216 | `1a8c20619fc335f6135a87e4f854a30a93a5d227e867fbf0eee1820f36840cf4` |
 
-- 代理版本：`0.2.2-e019f2d`
+- 代理版本：`0.2.3-e019f2d`
 - 源码提交：`e019f2d`（Go 仓 `dsh-over-ssh-agent` 的这个提交）
 - 清单原文：包内 `agents/agent-manifest.json`
 - 核对：`sha256sum agents/<平台>/dsh-over-ssh-agent` 与上表比对；按上面的提交检出 Go 仓后

package/agents/agent-manifest.json

@@ -1,19 +1,19 @@
 {
   "version": 1,
-  "generatedAt": "2026-11-06T16:15:01.747Z",
-  "agentVersion": "0.2.2-e019f2d",
+  "generatedAt": "2026-11-07T05:49:15.687Z",
+  "agentVersion": "0.2.3-e019f2d",
   "sourceCommit": "e019f2d",
   "artifacts": [
     {
       "platform": "linux-amd64",
       "path": "linux-amd64/dsh-over-ssh-agent",
-      "sha256": "d45237ef1bfec1955fb5e6a2391bd651ffeaffb89e781e1c518e9e9836eec974",
+      "sha256": "a1272e45a8213d4725a9eb91f9d08f1b5f460623e38730abef735c4569339d8d",
       "bytes": 4944032
     },
     {
       "platform": "linux-arm64",
       "path": "linux-arm64/dsh-over-ssh-agent",
-      "sha256": "237a3cc9f5ae57f752f62eee4f8a57bd8c4684fd4d3fa6ab5851115baa844ccd",
+      "sha256": "1a8c20619fc335f6135a87e4f854a30a93a5d227e867fbf0eee1820f36840cf4",
       "bytes": 4653216
     }
   ]

package/cordis.patch.yml

@@ -12,10 +12,14 @@
 #     ctx.fs             ← dsh-over-ssh/fs（多根路由）
 #     ctx.fileReferences ← dsh-over-ssh/file-references（多根 @ 补全）
 #
-#   私有域（isolate: fs / fileReferences）：
+#   私有域（isolate: fs）：
 #     ctx.fs             ← @deepseek-ai/dsh-fs-sandbox（**原版**，继续服务本地路径）
-#     ctx.fileReferences ← @deepseek-ai/dsh-file-reference-local（**原版**）
-#     两个 bridge 把域内实例以 localFs / localFileReferences 暴露给根作用域。
+#     一个 bridge 把域内实例以 localFs 暴露给根作用域。
+#
+#   文件引用**不再克隆平台实现**：根作用域的 dsh-over-ssh/file-references 自己实现了本地有界走查
+#   （见 integration/fs/file-reference-provider.ts），平台侧的 localFileReferences 没有任何消费者。
+#   2026-11-07 审计 0134 删掉了那条克隆链：它让私有域多等一个 workingDirectory 服务，而 DSH 热启用
+#   时这个依赖会短暂缺失，表现为「启用失败：2 entries did not activate」。
 #
 # 为什么是「接管」而不是「共存」：`ctx.fs` 是 Cordis 单例服务，同一隔离作用域只能有一个提供方，
 # 再注册第二个会抛 `service "fs" has been registered`。`isolate` 让原版实现能在私有域里继续跑，
@@ -24,8 +28,9 @@
 # 已实测的前提（cordis 0.2.1-rc.2）：域内 `fs` 解析到域内实例；根 `fs` 不受影响；可以同时存在多个域；
 # 根作用域的消费者能注入到域内 bridge 暴露出来的 `localFs`。任何一条不成立这套组合都不成立。
 #
-# 这两组行必须**同时**生效或同时不生效：只禁用核心行而不启用本插件的行，会让 `ctx.fs` /
-# `ctx.fileReferences` 无人提供，所有文件能力一起失效。
+# `ctx.fs` 与 `ctx.fileReferences` 两级都要有提供方：核心 fs-sandbox / file-reference-local 被本包
+# 禁用后，根作用域由 dsh-over-ssh/fs 与 dsh-over-ssh/file-references 接管；本地路径的写入围栏由私有域
+# 里那份原版 fs-sandbox 经 localFs 桥接执行。
 #
 # 还原：禁用整个 bundle。不要只删其中一行。
 #
@@ -57,19 +62,12 @@
       group: true
       isolate:
         fs: true
-        fileReferences: true
       config:
         - id: 远程工作区-平台沙箱副本
           name: '@deepseek-ai/dsh-fs-sandbox'
-        - id: 远程工作区-平台文件引用副本
-          name: '@deepseek-ai/dsh-file-reference-local'
-        # 两个 bridge 分开：file-reference-local 依赖 workingDirectory（在下游），不能和 fs 挤在同一行。
         - id: 远程工作区-桥接fs
           name: dsh-over-ssh/local-bridge
           inject: [fs]
-        - id: 远程工作区-桥接文件引用
-          name: dsh-over-ssh/local-bridge-refs
-          inject: [fileReferences]
 
     # 根作用域的提供方。两个入口都是「路由型」：本地路径与远端路径由同一套表分发。
     - id: 远程工作区-路由fs

package/lib/client.js

@@ -82,6 +82,8 @@ var OVER_SSH_DICTS = {
     sessionPanelSessions: "\u4F1A\u8BDD",
     sessionPanelBin: "\u56DE\u6536\u7AD9",
     sessionPanelBinEmpty: "\u56DE\u6536\u7AD9\u4E3A\u7A7A\u3002",
+    sessionPanelBinUnreadable: "\u53E6\u6709 {count} \u6761\u56DE\u6536\u7AD9\u6761\u76EE\u65E0\u6CD5\u663E\u793A\uFF08\u7F3A\u5C11\u4F1A\u8BDD\u6807\u8BC6\uFF09\uFF1B\u53EF\u91CD\u542F\u5BBF\u4E3B\u6216\u68C0\u67E5\u56DE\u6536\u7AD9\u7D22\u5F15\u3002",
+    sessionPanelBinRowUnaddressable: "\u8BE5\u6761\u76EE\u7F3A\u5C11\u6807\u8BC6\uFF0C\u65E0\u6CD5\u8FD8\u539F\u6216\u6E05\u9664",
     sessionPanelSelectAll: "\u5168\u9009\u53EF\u5220\u7684",
     sessionPanelClear: "\u6E05\u7A7A\u9009\u62E9",
     sessionPanelDeleteRecycle: "\u5220\u9664\u5230\u56DE\u6536\u7AD9",
@@ -159,6 +161,7 @@ var OVER_SSH_DICTS = {
     rootsErrorIdRequired: "\u8BF7\u586B\u5199\u8FDE\u63A5 id\u3002",
     rootsErrorIdInvalid: "\u8FDE\u63A5 id \u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u70B9\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF\uFF0C\u4E14\u5FC5\u987B\u4EE5\u5B57\u6BCD\u6216\u6570\u5B57\u5F00\u5934\u3002",
     rootsErrorIdDuplicate: "\u8FD9\u4E2A\u8FDE\u63A5 id \u5DF2\u7ECF\u5B58\u5728\u3002",
+    rootsErrorConnectionMissing: "\u8BE5\u8FDE\u63A5\u5DF2\u88AB\u5220\u9664\uFF0C\u65E0\u6CD5\u4FDD\u5B58\uFF1B\u8BF7\u5173\u95ED\u7F16\u8F91\u5E76\u5237\u65B0\u5217\u8868\u3002",
     rootsErrorHostRequired: "\u8BF7\u586B\u5199\u4E3B\u673A\u540D\u3002",
     rootsErrorUserRequired: "\u8BF7\u586B\u5199\u7528\u6237\u540D\u3002",
     rootsErrorPort: "\u7AEF\u53E3\u5FC5\u987B\u662F 1 \u5230 65535 \u4E4B\u95F4\u7684\u6574\u6570\u3002",
@@ -276,6 +279,9 @@ var OVER_SSH_DICTS = {
     sessionResultWorkspaceRecycled: "\u5DF2\u628A\u8BE5\u5DE5\u4F5C\u533A {count} \u4E2A\u4F1A\u8BDD\u79FB\u5165\u56DE\u6536\u7AD9\uFF0C{size}\uFF08\u53EF\u6062\u590D\uFF09",
     sessionResultWorkspaceRecycledRefused: "\u5DF2\u628A\u8BE5\u5DE5\u4F5C\u533A {count} \u4E2A\u4F1A\u8BDD\u79FB\u5165\u56DE\u6536\u7AD9\uFF0C{size}\uFF08\u53EF\u6062\u590D\uFF1B{refused} \u4E2A\u88AB\u62D2\u7EDD\uFF09",
     sessionResultRestored: "\u5DF2\u8FD8\u539F\u8BE5\u4F1A\u8BDD",
+    sessionResultRestoredWithSubsessions: "\u5DF2\u8FD8\u539F\u8BE5\u4F1A\u8BDD\uFF0C\u5E76\u8FDE\u5E26\u8FD8\u539F {count} \u4E2A\u5B50\u4F1A\u8BDD",
+    sessionResultRestoredPartial: "\u5DF2\u8FD8\u539F\u8BE5\u4F1A\u8BDD\uFF0C\u53E6\u6709 {failed} \u4E2A\u5B50\u4F1A\u8BDD\u4ECD\u7559\u5728\u56DE\u6536\u7AD9",
+    sessionResultRestoredParentBinned: "\u5DF2\u8FD8\u539F\u8BE5\u4F1A\u8BDD\uFF08\u5176\u7236\u4F1A\u8BDD\u4ECD\u5728\u56DE\u6536\u7AD9\uFF09",
     sessionResultPurged: "\u5DF2\u6C38\u4E45\u6E05\u9664\u8BE5\u6761\u76EE",
     sessionResultSweepNone: "\u6CA1\u6709\u9700\u8981\u6E05\u7406\u7684\u6761\u76EE",
     sessionResultSweepDone: "\u5DF2\u6E05\u7406 {count} \u4E2A\u6761\u76EE",
@@ -329,6 +335,8 @@ var OVER_SSH_DICTS = {
     sessionPanelSessions: "Sessions",
     sessionPanelBin: "Recycle bin",
     sessionPanelBinEmpty: "The recycle bin is empty.",
+    sessionPanelBinUnreadable: "{count} more bin entr(y/ies) cannot be shown (no session id); restart the host or check the bin index.",
+    sessionPanelBinRowUnaddressable: "This entry has no id, so it cannot be restored or purged",
     sessionPanelSelectAll: "Select deletable",
     sessionPanelClear: "Clear selection",
     sessionPanelDeleteRecycle: "Delete to bin",
@@ -401,6 +409,7 @@ var OVER_SSH_DICTS = {
     rootsErrorIdRequired: "Enter a connection id.",
     rootsErrorIdInvalid: "A connection id may contain letters, digits, dots, underscores and dashes, and must start with a letter or a digit.",
     rootsErrorIdDuplicate: "That connection id already exists.",
+    rootsErrorConnectionMissing: "That connection has been deleted; close the editor and refresh.",
     rootsErrorHostRequired: "Enter a host name.",
     rootsErrorUserRequired: "Enter a user name.",
     rootsErrorPort: "The port must be an integer between 1 and 65535.",
@@ -518,6 +527,9 @@ var OVER_SSH_DICTS = {
     sessionResultWorkspaceRecycled: "Moved {count} sessions of that workspace to the recycle bin, {size} (recoverable)",
     sessionResultWorkspaceRecycledRefused: "Moved {count} sessions of that workspace to the recycle bin, {size} (recoverable; {refused} refused)",
     sessionResultRestored: "Restored that session",
+    sessionResultRestoredWithSubsessions: "Restored that session and {count} sub-session(s)",
+    sessionResultRestoredPartial: "Restored that session; {failed} sub-session(s) stayed in the bin",
+    sessionResultRestoredParentBinned: "Restored that session (its parent is still in the bin)",
     sessionResultPurged: "Permanently removed that entry",
     sessionResultSweepNone: "Nothing to sweep",
     sessionResultSweepDone: "Swept {count} entries",
@@ -1438,15 +1450,29 @@ function createCardPortal(options) {
   };
 }
 function focusFirstControl(container) {
+  const all = container?.querySelectorAll?.(CARD_FOCUS_SELECTOR);
+  if (all !== void 0 && all !== null) {
+    for (const candidate of Array.from(all)) {
+      if (!isVisibleControl(candidate)) continue;
+      candidate.focus?.();
+      return true;
+    }
+    return false;
+  }
   const target = container?.querySelector?.(CARD_FOCUS_SELECTOR) ?? void 0;
   if (target === void 0 || typeof target.focus !== "function") return false;
   target.focus();
   return true;
 }
+function isVisibleControl(element) {
+  const measurable = element.getClientRects;
+  if (typeof measurable === "function") return measurable.call(element).length > 0;
+  return element.hidden !== true;
+}
 function focusableWithin(container) {
   const found = container?.querySelectorAll?.(CARD_FOCUS_SELECTOR);
   if (found === null || found === void 0) return [];
-  return Array.from(found);
+  return Array.from(found).filter(isVisibleControl);
 }
 function trapTab(event, container, active) {
   const focusables = focusableWithin(container);
@@ -2726,6 +2752,11 @@ function createRootsPanelController(options) {
     const editingId = state.editingId;
     if (editingId === void 0) return;
     if (!canEdit(state)) return;
+    if (!(state.snapshot?.connections ?? []).some((row) => row.id === editingId)) {
+      dispatch({ type: "edit-ended" });
+      dispatch({ type: "refused", scope: "edit", message: { key: "rootsErrorConnectionMissing" } });
+      return;
+    }
     const editDrafts = state.editDrafts;
     const portText = editDrafts.port.trim();
     const port = portText === "" ? void 0 : Number(portText);
@@ -3869,10 +3900,10 @@ function toSessionRowView(raw) {
   };
 }
 function toBinRowView(raw) {
-  const entryId = raw["entryId"];
+  const rawEntryId = raw["entryId"];
   const sessionId = raw["sessionId"];
-  if (typeof entryId !== "string" || entryId === "") return void 0;
   if (typeof sessionId !== "string" || sessionId === "") return void 0;
+  const entryId = typeof rawEntryId === "string" ? rawEntryId : "";
   return {
     entryId,
     sessionId,
@@ -3887,6 +3918,8 @@ function emptySnapshot() {
     available: false,
     sessions: [],
     bin: [],
+    binUnaddressable: 0,
+    binUnreadable: 0,
     policy: { maxEntries: 0, maxBytes: 0, maxAgeMs: 0 },
     totals: { sessions: 0, bytes: 0, subsessions: 0, live: 0, running: 0 }
   };
@@ -3958,13 +3991,28 @@ function parseSessionSnapshot(value) {
   const available = body["available"] === true;
   const sessions = Array.isArray(body["sessions"]) ? body["sessions"].flatMap((raw) => typeof raw === "object" && raw !== null ? [toSessionRowView(raw)].filter((row) => row !== void 0) : []) : [];
   const unblocked = unblockOrphanSubsessions(sessions);
-  const bin = Array.isArray(body["bin"]) ? body["bin"].flatMap((raw) => typeof raw === "object" && raw !== null ? [toBinRowView(raw)].filter((row) => row !== void 0) : []) : [];
+  let binUnreadable = 0;
+  const bin = Array.isArray(body["bin"]) ? body["bin"].flatMap((raw) => {
+    if (typeof raw !== "object" || raw === null) {
+      binUnreadable += 1;
+      return [];
+    }
+    const row = toBinRowView(raw);
+    if (row === void 0) {
+      binUnreadable += 1;
+      return [];
+    }
+    return [row];
+  }) : [];
+  const binUnaddressable = bin.filter((row) => row.entryId === "").length;
   const rawPolicy = typeof body["policy"] === "object" && body["policy"] !== null ? body["policy"] : {};
   const numberOr = (key) => typeof rawPolicy[key] === "number" && Number.isFinite(rawPolicy[key]) ? rawPolicy[key] : 0;
   return {
     available,
     sessions: unblocked,
     bin,
+    binUnaddressable,
+    binUnreadable,
     policy: { maxEntries: numberOr("maxEntries"), maxBytes: numberOr("maxBytes"), maxAgeMs: numberOr("maxAgeMs") },
     totals: {
       sessions: unblocked.length,
@@ -4049,7 +4097,14 @@ async function deleteWorkspaceSessions(io, cwd, options = {}) {
 }
 async function restoreSession(io, entryId) {
   if (entryId === "") return { kind: "error", message: { key: "sessionResultMissingEntryId" } };
-  return postAction(io, { action: "restore", entryId }, () => ({ key: "sessionResultRestored" }));
+  return postAction(io, { action: "restore", entryId }, (value) => {
+    const failed = typeof value["failedSubsessions"] === "number" ? value["failedSubsessions"] : 0;
+    const restored = typeof value["restoredSubsessions"] === "number" ? value["restoredSubsessions"] : 0;
+    if (failed > 0) return { key: "sessionResultRestoredPartial", params: { failed } };
+    if (restored > 0) return { key: "sessionResultRestoredWithSubsessions", params: { count: restored } };
+    if (value["parentStillBinned"] === true) return { key: "sessionResultRestoredParentBinned" };
+    return { key: "sessionResultRestored" };
+  });
 }
 async function purgeSession(io, entryId) {
   if (entryId === "") return { kind: "error", message: { key: "sessionResultMissingEntryId" } };
@@ -4158,9 +4213,10 @@ var SessionRow = (0, import_react7.memo)(function SessionRow2(props) {
 });
 function renderBinRow(props) {
   const { row, copy, busy } = props;
+  const unaddressable = row.entryId === "";
   return (0, import_react7.createElement)(
     "li",
-    { key: row.entryId },
+    { key: unaddressable ? `unaddressable:${row.sessionId}` : row.entryId },
     (0, import_react7.createElement)(
       "div",
       { className: CLASS.row },
@@ -4172,20 +4228,22 @@ function renderBinRow(props) {
       (0, import_react7.createElement)(
         "span",
         { className: CLASS.rowActions },
-        Button({
-          variant: "secondary",
-          size: "compact",
-          disabled: busy,
-          onClick: () => props.onRestore(row.entryId),
-          children: copy.restore
-        }),
-        Button({
-          variant: "ghost",
-          size: "compact",
-          disabled: busy,
-          onClick: () => props.onPurge(row.entryId),
-          children: copy.purge
-        })
+        ...unaddressable ? [(0, import_react7.createElement)("span", { className: CLASS.rowMeta, title: copy.binRowUnaddressable }, copy.binRowUnaddressable)] : [
+          Button({
+            variant: "secondary",
+            size: "compact",
+            disabled: busy,
+            onClick: () => props.onRestore(row.entryId),
+            children: copy.restore
+          }),
+          Button({
+            variant: "ghost",
+            size: "compact",
+            disabled: busy,
+            onClick: () => props.onPurge(row.entryId),
+            children: copy.purge
+          })
+        ]
       )
     )
   );
@@ -4463,10 +4521,10 @@ function SessionPanel({ copy, io, close }) {
     (0, import_react7.createElement)("h3", { className: CLASS.blockTitle }, copy.binHeading),
     // Same rule as the inventory: 「回收站为空」 is a claim about an **answer**. While nothing has been read (or the
     // read failed) the status line above says what is happening (audit 2026-11-01b ui P1-3).
-    phase.kind !== "ready" ? null : snapshot.bin.length === 0 ? (0, import_react7.createElement)("p", { className: CLASS.empty }, copy.binEmpty) : (0, import_react7.createElement)(
+    phase.kind !== "ready" ? null : snapshot.bin.length === 0 && snapshot.binUnreadable === 0 ? (0, import_react7.createElement)("p", { className: CLASS.empty }, copy.binEmpty) : (0, import_react7.createElement)(
       "div",
       { className: CLASS.block },
-      (0, import_react7.createElement)(
+      snapshot.bin.length === 0 ? null : (0, import_react7.createElement)(
         "ul",
         { className: CLASS.list },
         ...snapshot.bin.map(
@@ -4479,6 +4537,7 @@ function SessionPanel({ copy, io, close }) {
           })
         )
       ),
+      snapshot.binUnreadable > 0 ? (0, import_react7.createElement)("p", { className: CLASS.empty }, copy.binUnreadable(snapshot.binUnreadable)) : null,
       Button({
         variant: "secondary",
         size: "compact",
@@ -6634,6 +6693,8 @@ function apply(ctx) {
         sessionsHeading: dict.sessionPanelSessions,
         binHeading: dict.sessionPanelBin,
         binEmpty: dict.sessionPanelBinEmpty,
+        binUnreadable: (count) => resolveMessage2(dict, { key: "sessionPanelBinUnreadable", params: { count } }),
+        binRowUnaddressable: dict.sessionPanelBinRowUnaddressable,
         selectAll: dict.sessionPanelSelectAll,
         clearSelection: dict.sessionPanelClear,
         deleteRecycle: dict.sessionPanelDeleteRecycle,

package/lib/file-references.js

@@ -2,7 +2,7 @@
 import "@deepseek-ai/cordis";
 
 // src/host/integration/fs/file-reference-provider.ts
-import { readdir } from "node:fs/promises";
+import { readdir, realpath, stat } from "node:fs/promises";
 import { join } from "node:path";
 import "@deepseek-ai/cordis";
 import FileReferenceService from "@deepseek-ai/dsh-file-reference";
@@ -47,7 +47,7 @@ var DEFAULTS = {
   outputCap: 8 * 1024 * 1024
 };
 function rankMatches(paths, query, limit) {
-  const needle = query.trim().toLowerCase();
+  const needle = separatorsForMatching(query.trim().toLowerCase());
   if (needle === "") {
     const top = [];
     const better = (left, right) => {
@@ -72,7 +72,8 @@ function rankMatches(paths, query, limit) {
   }
   const scored = [];
   for (const path of paths) {
-    const lower = path.toLowerCase();
+    const normalized = separatorsForMatching(path);
+    const lower = normalized.toLowerCase();
     const base = lower.slice(lower.lastIndexOf("/") + 1);
     let score;
     if (base.startsWith(needle)) score = 0;
@@ -87,11 +88,15 @@ function rankMatches(paths, query, limit) {
   );
   return scored.slice(0, limit).map((entry) => entry.path);
 }
+function separatorsForMatching(path) {
+  return path.includes("\\") && !path.includes("/") ? path.replaceAll("\\", "/") : path;
+}
 function depth(path) {
   let segments = 0;
   let inSegment = false;
   for (let index = 0; index < path.length; index += 1) {
-    if (path.charCodeAt(index) === 47) {
+    const code = path.charCodeAt(index);
+    if (code === 47 || code === 92) {
       inSegment = false;
       continue;
     }
@@ -153,6 +158,14 @@ function makeLocalRoot(path, options = {}) {
 function normalizeLocalPath2(path, options = {}) {
   return normalizeLocalPath(path, { caseInsensitive: options.caseInsensitive ?? process.platform === "win32" });
 }
+function localPathContains(root, candidate, options = {}) {
+  const normalizedRoot = normalizeLocalPath2(root, options);
+  const normalizedCandidate = normalizeLocalPath2(candidate, options);
+  if (normalizedRoot === "/" || /^[a-z]:\/$/.test(normalizedRoot)) {
+    return normalizedCandidate.startsWith(normalizedRoot);
+  }
+  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}/`);
+}
 
 // src/host/integration/session-fork-pending.ts
 var pending = /* @__PURE__ */ new Map();
@@ -248,6 +261,17 @@ var RemoteFileReferenceService = class extends FileReferenceService {
    * (`local-backend.ts:53`), so there is no change signal to hook — only a short TTL.
    */
   #localCache = /* @__PURE__ */ new Map();
+  /**
+   * 正在进行中的本地走查，按根合并。
+   *
+   * 为什么需要它：缓存只覆盖"上一次走查**已完成**"的情况。用户敲 `@mo` 时的间隔可能短于一次走查
+   * （10 000 条目约 68 ms），于是几次击键会各自发起一次全树走查——同一棵树在宿主事件循环上被重复
+   * 扫描。这里让并发的同根调用共享一次走查；查询不同不影响，因为**排序仍按每次调用自己的 query 现算**，
+   * 共享的只有与 query 无关的树枚举。
+   */
+  #inflight = /* @__PURE__ */ new Map();
+  /** 已经告警过的来源标签；一次故障只提示一次，避免每个按键都刷一行日志。 */
+  #warned = /* @__PURE__ */ new Set();
   constructor(ctx, options = {}) {
     super(ctx);
     this.#options = options;
@@ -279,20 +303,53 @@ var RemoteFileReferenceService = class extends FileReferenceService {
    *   without an index, or a cwd that is not an absolute host path.
    */
   async list(agent, query, signal) {
+    signal.throwIfAborted();
     const cwd = agent.session.header.cwd ?? process.cwd();
     const registry = this.ctx.sshDevRoots;
     if (registry === void 0) return [];
     const identity = sessionIdentityOf(this.ctx, agent.session.header.id);
     const gated = identity.sessionId === void 0 ? registry.routed.tryResolve(cwd) : registry.routed.tryResolve(cwd, { session: identity });
-    const addedTask = this.#addedRemoteCandidates(cwd, identity, query, signal);
+    const addedTask = this.#degrade(
+      "\u672C\u4F1A\u8BDD\u6DFB\u52A0\u7684\u8FDC\u7AEF\u6839",
+      void 0,
+      () => this.#addedRemoteCandidates(cwd, identity, query, signal)
+    );
     const ungated = gated.ok ? void 0 : registry.routed.tryResolve(cwd);
     const implicit = gated.ok || ungated?.ok === true ? void 0 : sessionLocalRoot(cwd);
-    const namedTask = gated.ok ? this.#namedCandidates(gated.target.root, query, signal) : implicit === void 0 ? void 0 : this.#localCandidates(implicit.path, query, signal);
+    const namedTask = gated.ok ? this.#degrade("cwd \u547D\u540D\u7684\u6839", [], () => this.#namedCandidates(gated.target.root, query, signal)) : implicit === void 0 ? void 0 : this.#degrade("cwd \u81EA\u8EAB\u76EE\u5F55", [], () => this.#localCandidates(implicit.path, query, signal));
     const [added, named] = await Promise.all([addedTask, namedTask]);
+    signal.throwIfAborted();
     if (gated.ok) return this.#merge(added, named ?? []);
     if (ungated?.ok === true) return added ?? [];
     return this.#merge(added, named ?? []);
   }
+  /**
+   * Run one candidate source, degrading a failure to `fallback`.
+   *
+   * 为什么不让一次失败冒到上层：`@` 补全有两个独立来源（本会话「添加目录」的远端根、cwd 命名的根）。
+   * 旧写法直接 `Promise.all`，其中**任何一个**失败（连接断、远端超时、walk 抛错）都会让整个 `list()`
+   * 拒绝——明明本地候选已经拿到，也会一起消失。取消是例外：调用方已经取消时必须继续抛出，不能把
+   * "取消"伪装成"空结果"。
+   *
+   * @param label - 日志里标识来源的短名，同一来源只告警一次。
+   * @param fallback - 失败时返回的降级值。
+   * @param task - 真正的枚举任务。
+   * @returns 任务结果，或降级值。
+   */
+  async #degrade(label, fallback, task) {
+    try {
+      return await task();
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      if (!this.#warned.has(label)) {
+        this.#warned.add(label);
+        this.ctx.logger?.warn?.(
+          `file-references: ${label} \u53D6\u5019\u9009\u5931\u8D25\uFF0C\u672C\u6B21\u53EA\u8DF3\u8FC7\u8BE5\u6765\u6E90\uFF1A${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      return fallback;
+    }
+  }
   /** cwd 命名的那个根自己的候选：远端走索引，本地走有界走查。 */
   #namedCandidates(root, query, signal) {
     return root.location === "remote" && root.connectionId !== void 0 ? this.#remoteCandidates(root.connectionId, root.path, query, signal) : this.#localCandidates(root.path, query, signal);
@@ -359,6 +416,7 @@ var RemoteFileReferenceService = class extends FileReferenceService {
    * @returns the entries, from cache when the previous walk is still fresh.
    */
   async #walkCached(root, walk, signal) {
+    signal.throwIfAborted();
     const started = this.#now();
     const cached = this.#localCache.get(root);
     if (cached !== void 0) {
@@ -369,10 +427,33 @@ var RemoteFileReferenceService = class extends FileReferenceService {
       }
       this.#localCache.delete(root);
     }
-    const entries = await walk(root, signal);
-    signal.throwIfAborted();
-    this.#rememberLocal(root, entries, started);
-    return entries;
+    let shared = this.#inflight.get(root);
+    if (shared === void 0) {
+      const controller = new AbortController();
+      const entry = { controller, waiters: 0, promise: Promise.resolve([]) };
+      const promise = (async () => {
+        const entries = await walk(root, controller.signal);
+        controller.signal.throwIfAborted();
+        this.#rememberLocal(root, entries, started);
+        return entries;
+      })();
+      entry.promise = promise;
+      void promise.catch(() => void 0).finally(() => {
+        if (this.#inflight.get(root) === entry) this.#inflight.delete(root);
+      });
+      this.#inflight.set(root, entry);
+      shared = entry;
+    }
+    shared.waiters += 1;
+    try {
+      return await raceAbort(shared.promise, signal);
+    } finally {
+      shared.waiters -= 1;
+      if (shared.waiters === 0 && this.#inflight.get(root) === shared) {
+        this.#inflight.delete(root);
+        shared.controller.abort(new DOMException("no active @ completion callers", "AbortError"));
+      }
+    }
   }
   /** Store one local enumeration, evicting the least recently used root past the cap. */
   #rememberLocal(root, entries, at) {
@@ -388,6 +469,12 @@ var RemoteFileReferenceService = class extends FileReferenceService {
     const maxEntries = this.#options.maxEntries ?? LOCAL_MAX_ENTRIES;
     const maxDepth = this.#options.maxDepth ?? LOCAL_MAX_DEPTH;
     const found = [];
+    const visited = /* @__PURE__ */ new Set();
+    const rootReal = await realpath(root).catch(() => root);
+    const caseInsensitive = process.platform === "win32";
+    const withinRoot = (candidate) => localPathContains(rootReal, candidate, { caseInsensitive });
+    visited.add(rootReal);
+    const excluded = (name) => LOCAL_EXCLUDED_DIRECTORIES.includes(caseInsensitive ? name.toLowerCase() : name);
     let frontier = [{ path: root, depth: 0 }];
     while (frontier.length > 0 && found.length < maxEntries) {
       signal.throwIfAborted();
@@ -403,11 +490,27 @@ var RemoteFileReferenceService = class extends FileReferenceService {
         }
         for (const child of children) {
           if (found.length >= maxEntries) break;
-          const isDirectory = child.isDirectory();
-          if (isDirectory && LOCAL_EXCLUDED_DIRECTORIES.includes(child.name)) continue;
+          let isDirectory = child.isDirectory();
+          let traversable = child.isDirectory();
           const path = join(entry.path, child.name);
+          if (!isDirectory && child.isSymbolicLink()) {
+            try {
+              const target = await stat(path);
+              isDirectory = target.isDirectory();
+              if (isDirectory) {
+                const real = await realpath(path);
+                if (visited.has(real) || !withinRoot(real)) traversable = false;
+                else {
+                  visited.add(real);
+                  traversable = true;
+                }
+              }
+            } catch {
+            }
+          }
+          if (isDirectory && excluded(child.name)) continue;
           found.push({ path, kind: isDirectory ? "directory" : "file" });
-          if (isDirectory) next.push({ path, depth: entry.depth + 1 });
+          if (traversable) next.push({ path, depth: entry.depth + 1 });
         }
       }
       frontier = next;
@@ -415,6 +518,26 @@ var RemoteFileReferenceService = class extends FileReferenceService {
     return found;
   }
 };
+function raceAbort(promise, signal) {
+  if (signal.aborted) return Promise.reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+function isAbortError(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError") || typeof error === "object" && error !== null && "name" in error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
 function sessionLocalRoot(cwd) {
   if (cwd === "" || !isAbsoluteLocalPath(cwd)) return void 0;
   return makeLocalRoot(cwd);

package/lib/index.js

@@ -4372,6 +4372,7 @@ function parseSessionTrashIndex(text8) {
       segment: record2["segment"],
       originalSegment: record2["originalSegment"],
       title: typeof record2["title"] === "string" ? record2["title"] : void 0,
+      ...typeof record2["parentSessionId"] === "string" && record2["parentSessionId"] !== "" ? { parentSessionId: record2["parentSessionId"] } : {},
       bytes: typeof record2["bytes"] === "number" && Number.isFinite(record2["bytes"]) ? record2["bytes"] : 0,
       deletedAtMs: record2["deletedAtMs"],
       movedBy: record2["movedBy"] === "copy" ? "copy" : "rename",
@@ -4418,6 +4419,7 @@ function makeSessionTrashEntry(input) {
     segment: input.segment,
     originalSegment: input.originalSegment,
     title: input.title,
+    ...input.parentSessionId === void 0 ? {} : { parentSessionId: input.parentSessionId },
     bytes: input.bytes,
     deletedAtMs: input.deletedAtMs,
     movedBy: input.movedBy,
@@ -4693,6 +4695,7 @@ function createSessionAdminDelete(ctx) {
             segment: entryId,
             originalSegment: record2.segment,
             title: record2.title,
+            parentSessionId: record2.parentSessionId,
             bytes: record2.bytes,
             deletedAtMs,
             movedBy,
@@ -4810,31 +4813,63 @@ function createSessionAdminService(deps) {
     if (entry === void 0) {
       throw new SshDevError("TRASH_NOT_FOUND", `\u56DE\u6536\u7AD9\u6761\u76EE\u4E0D\u5B58\u5728\uFF1A${entryId}`, { entryId });
     }
-    const target = joinPath(sessionsRoot, entry.projectDir, entry.originalSegment);
-    const occupied = await deps.stat(target) !== void 0;
-    const plan = planRestoreSession(entry, { occupied });
-    if (plan.kind === "refuse") {
-      throw new SshDevError("TRANSFER_CONFLICT", `\u539F\u8DEF\u5F84\u5DF2\u88AB\u5360\u7528\uFF0C\u62D2\u7EDD\u9759\u9ED8\u6362\u540D\u8FD8\u539F\uFF1A${target}`, {
-        entryId,
-        suggestedId: plan.suggestedId,
-        target
-      });
-    }
-    const from = entryDir(entry.segment);
-    let movedBy;
-    try {
-      movedBy = await deps.moveDir(from, target);
-    } catch (error) {
-      const landed = await deps.stat(target) !== void 0;
-      if (!landed) {
-        throw new SshDevError("REMOTE_COMMAND_FAILED", `\u8FD8\u539F\u4F1A\u8BDD\u5931\u8D25\uFF1A${entry.sessionId}`, {
-          entryId,
-          cause: error instanceof Error ? error.message : String(error)
+    const restoreOne = async (item) => {
+      const target = joinPath(sessionsRoot, item.projectDir, item.originalSegment);
+      const occupied = await deps.stat(target) !== void 0;
+      const plan = planRestoreSession(item, { occupied });
+      if (plan.kind === "refuse") {
+        throw new SshDevError("TRANSFER_CONFLICT", `\u539F\u8DEF\u5F84\u5DF2\u88AB\u5360\u7528\uFF0C\u62D2\u7EDD\u9759\u9ED8\u6362\u540D\u8FD8\u539F\uFF1A${target}`, {
+          entryId: item.id,
+          suggestedId: plan.suggestedId,
+          target
+        });
+      }
+      const from = entryDir(item.segment);
+      let movedBy;
+      try {
+        movedBy = await deps.moveDir(from, target);
+      } catch (error) {
+        const landed = await deps.stat(target) !== void 0;
+        if (!landed) {
+          throw new SshDevError("REMOTE_COMMAND_FAILED", `\u8FD8\u539F\u4F1A\u8BDD\u5931\u8D25\uFF1A${item.sessionId}`, {
+            entryId: item.id,
+            cause: error instanceof Error ? error.message : String(error)
+          });
+        }
+        movedBy = "copy";
+      }
+      return { entry: item, restoredPath: target, movedBy };
+    };
+    const parentStillBinned = entry.parentSessionId !== void 0 && entries.some((item) => item.sessionId === entry.parentSessionId);
+    const restored = await restoreOne(entry);
+    const childrenOf = /* @__PURE__ */ new Map();
+    for (const item of entries) {
+      if (item.id === entry.id || item.parentSessionId === void 0) continue;
+      const bucket = childrenOf.get(item.parentSessionId);
+      if (bucket === void 0) childrenOf.set(item.parentSessionId, [item]);
+      else bucket.push(item);
+    }
+    const restoredSubsessions = [];
+    const failedSubsessions = [];
+    const removedIds = /* @__PURE__ */ new Set([entry.id]);
+    const queue = [...childrenOf.get(entry.sessionId) ?? []];
+    while (queue.length > 0) {
+      const child = queue.shift();
+      if (child === void 0) break;
+      if (removedIds.has(child.id)) continue;
+      try {
+        const childRestored = await restoreOne(child);
+        restoredSubsessions.push({ sessionId: child.sessionId, restoredPath: childRestored.restoredPath });
+        removedIds.add(child.id);
+        queue.push(...childrenOf.get(child.sessionId) ?? []);
+      } catch (error) {
+        failedSubsessions.push({
+          sessionId: child.sessionId,
+          reason: error instanceof Error ? error.message : String(error)
         });
       }
-      movedBy = "copy";
     }
-    const remaining = entries.filter((item) => item.id !== entryId);
+    const remaining = entries.filter((item) => !removedIds.has(item.id));
     try {
       await writeIndex(remaining);
     } catch (error) {
@@ -4843,7 +4878,7 @@ function createSessionAdminService(deps) {
         cause: error instanceof Error ? error.message : String(error)
       });
     }
-    return { entry, restoredPath: target, movedBy };
+    return { ...restored, restoredSubsessions, failedSubsessions, parentStillBinned };
   });
   const purge = (entryId, options = {}) => {
     void options;
@@ -8753,9 +8788,16 @@ var AgentTransport = class extends TransportBase {
       state: typeof record2["state"] === "string" ? record2["state"] : "unknown"
     };
   }
-  /** Read a language server's output from `offset`: `lsp.read`. Same offset semantics as {@link procOutput}. */
-  async lspRead(id, offset = 0, signal) {
-    const result = await this.#rpc("lsp.read", { id, offset }, signal);
+  /**
+   * Read a language server's output from `offset`: `lsp.read`. Same offset semantics as {@link procOutput}.
+   *
+   * `maxBytes` bounds one response. The agent defaults it to its 2 MiB chunk; callers that poll (the LSP pump)
+   * pass a smaller cap so a quiet server does not cost 2 MiB of transient host memory per poll. Agents older
+   * than the field ignore it (Go's JSON decoder ignores unknown fields), so it is safe to always send.
+   */
+  async lspRead(id, offset = 0, signal, maxBytes) {
+    const params = maxBytes === void 0 ? { id, offset } : { id, offset, maxBytes: Math.max(1, Math.floor(maxBytes)) };
+    const result = await this.#rpc("lsp.read", params, signal);
     return readLspRead(result);
   }
   /** One language-server session's state: `lsp.status`. */
@@ -12613,7 +12655,7 @@ function directoryProbeCommand(root) {
   return `test -d ${shellQuote(root)}`;
 }
 function rankMatches(paths, query, limit) {
-  const needle = query.trim().toLowerCase();
+  const needle = separatorsForMatching(query.trim().toLowerCase());
   if (needle === "") {
     const top = [];
     const better = (left, right) => {
@@ -12638,7 +12680,8 @@ function rankMatches(paths, query, limit) {
   }
   const scored = [];
   for (const path of paths) {
-    const lower = path.toLowerCase();
+    const normalized = separatorsForMatching(path);
+    const lower = normalized.toLowerCase();
     const base = lower.slice(lower.lastIndexOf("/") + 1);
     let score;
     if (base.startsWith(needle)) score = 0;
@@ -12653,11 +12696,15 @@ function rankMatches(paths, query, limit) {
   );
   return scored.slice(0, limit).map((entry) => entry.path);
 }
+function separatorsForMatching(path) {
+  return path.includes("\\") && !path.includes("/") ? path.replaceAll("\\", "/") : path;
+}
 function depth2(path) {
   let segments = 0;
   let inSegment = false;
   for (let index = 0; index < path.length; index += 1) {
-    if (path.charCodeAt(index) === 47) {
+    const code = path.charCodeAt(index);
+    if (code === 47 || code === 92) {
       inSegment = false;
       continue;
     }
@@ -13763,6 +13810,8 @@ function sessionToolDefinitions(service) {
             sessions: { type: "array", items: { type: "string" }, description: "`list`: one formatted line per session." },
             entries: { type: "array", items: { type: "string" }, description: "`restore` without an id: bin entry ids." },
             restoredPath: { type: "string", description: "`restore` with an id: where the entry went back to." },
+            restoredSubsessions: { type: "integer", description: "`restore`: sub-sessions restored together with the entry." },
+            failedSubsessions: { type: "integer", description: "`restore`: sub-sessions that stayed in the bin (path occupied / move failed)." },
             matched: { type: "integer", description: "`delete_workspace`: how many sessions belonged to the directory." },
             mode: { type: "string", description: "`delete` / `delete_workspace`: the mode that was applied." },
             recoverable: { type: "boolean", description: "`delete`: whether the bin can bring it back." },
@@ -13798,10 +13847,16 @@ function sessionToolDefinitions(service) {
           }
           if (typeof entryId !== "string" || entryId === "") throw new Error("entryId \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u7701\u7565\u5219\u5217\u51FA\u56DE\u6536\u7AD9\uFF09");
           const result = await service.restore(entryId);
+          const extra = [];
+          if (result.restoredSubsessions.length > 0) extra.push(`\u5E76\u8FD8\u539F\u5B50\u4F1A\u8BDD ${result.restoredSubsessions.length} \u4E2A`);
+          if (result.failedSubsessions.length > 0) extra.push(`${result.failedSubsessions.length} \u4E2A\u5B50\u4F1A\u8BDD\u4ECD\u5728\u56DE\u6536\u7AD9`);
+          if (result.parentStillBinned) extra.push("\u5176\u7236\u4F1A\u8BDD\u4ECD\u5728\u56DE\u6536\u7AD9");
           return {
             action: "restore",
             restoredPath: result.restoredPath,
-            summary: `\u5DF2\u8FD8\u539F\u4F1A\u8BDD ${result.entry.sessionId} -> ${result.restoredPath}`
+            restoredSubsessions: result.restoredSubsessions.length,
+            failedSubsessions: result.failedSubsessions.length,
+            summary: `\u5DF2\u8FD8\u539F\u4F1A\u8BDD ${result.entry.sessionId} -> ${result.restoredPath}${extra.length === 0 ? "" : `\uFF08${extra.join("\uFF0C")}\uFF09`}`
           };
         }
         const mode = record2["mode"] ?? "recycle";
@@ -16027,7 +16082,7 @@ async function serveAction(req, res, deps) {
 
 // src/host/integration/session/session-bin-lock.ts
 init_errors();
-import { mkdir as mkdir5, open as open3, readFile as readFile6, rm as rm3, stat as stat5 } from "node:fs/promises";
+import { mkdir as mkdir5, open as open3, readFile as readFile6, rm as rm3, stat as stat5, utimes } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
 var DEFAULT_STALE_LOCK_MS = 6e4;
 var DEFAULT_LOCK_RETRY_MS = 25;
@@ -16036,6 +16091,7 @@ function createSessionBinLock(options) {
   const staleMs = options.staleMs ?? DEFAULT_STALE_LOCK_MS;
   const retryMs = options.retryMs ?? DEFAULT_LOCK_RETRY_MS;
   const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+  const heartbeatMs = options.heartbeatMs ?? (staleMs > 0 ? Math.max(1e3, Math.floor(staleMs / 4)) : 0);
   const sleep2 = options.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms)));
   const now = options.now ?? (() => Date.now());
   const owner = options.owner ?? `${process.pid}@${hostnameOf()}`;
@@ -16116,6 +16172,17 @@ function createSessionBinLock(options) {
     }
     return true;
   };
+  const refreshLock = async (token) => {
+    try {
+      const text8 = await readFile6(options.path, "utf8");
+      const record2 = JSON.parse(text8);
+      if (record2.token !== token) return;
+      const at = new Date(now());
+      await utimes(options.path, at, at);
+    } catch (error) {
+      options.onHeartbeatError?.(error);
+    }
+  };
   const withLock = async (_key, operation) => {
     const deadline = now() + timeoutMs;
     let token;
@@ -16132,9 +16199,17 @@ function createSessionBinLock(options) {
       }
       await sleep2(retryMs);
     }
+    let heartbeat;
+    if (token !== void 0 && heartbeatMs > 0) {
+      heartbeat = setInterval(() => {
+        void refreshLock(token);
+      }, heartbeatMs);
+      heartbeat.unref?.();
+    }
     try {
       return await operation();
     } finally {
+      if (heartbeat !== void 0) clearInterval(heartbeat);
       if (token !== void 0) await releaseIfOwned(token);
     }
   };
@@ -16626,7 +16701,14 @@ async function serveActionWithSignal(action, body, req, res, deps, service, sign
         return;
       }
       const result = await service.restore(entryId, options);
-      send(req, res, 200, { ok: true, restoredPath: result.restoredPath, movedBy: result.movedBy });
+      send(req, res, 200, {
+        ok: true,
+        restoredPath: result.restoredPath,
+        movedBy: result.movedBy,
+        restoredSubsessions: result.restoredSubsessions.length,
+        failedSubsessions: result.failedSubsessions.length,
+        parentStillBinned: result.parentStillBinned
+      });
       return;
     }
     case "purge": {
@@ -17018,7 +17100,7 @@ function registerPanelRoutes(env, hooks) {
 }
 
 // src/wiring/fs.ts
-var LOCAL_WORLD_MISSING_WARNING = 'dsh-over-ssh: \u79C1\u6709\u57DF\u7684 bridge \u672A\u5C31\u4F4D\uFF08ctx.get("localFs") === undefined\uFF09\uFF1A\u672C\u5730\u8DEF\u5F84\u7684\u5199\u5165\u56F4\u680F\u9000\u56DE\u672C\u63D2\u4EF6\u81EA\u5DF1\u7684 LocalBackend\u2014\u2014\u529F\u80FD\u770B\u8D77\u6765\u6B63\u5E38\uFF0C\u4F46\u56F4\u680F\u6362\u4E86\u6267\u884C\u8005\u3002\u8BF7\u68C0\u67E5 cordis.patch.yml \u91CC \u8FDC\u7A0B\u5DE5\u4F5C\u533A-\u79C1\u6709\u57DF \u7EC4\uFF08fs/fileReferences \u7684 isolate \u4E0E\u4E24\u4E2A bridge \u884C\uFF09\u662F\u5426\u88AB\u7981\u7528\u6216\u52A0\u8F7D\u5931\u8D25\u3002';
+var LOCAL_WORLD_MISSING_WARNING = 'dsh-over-ssh: \u79C1\u6709\u57DF\u7684 bridge \u672A\u5C31\u4F4D\uFF08ctx.get("localFs") === undefined\uFF09\uFF1A\u672C\u5730\u8DEF\u5F84\u7684\u5199\u5165\u56F4\u680F\u9000\u56DE\u672C\u63D2\u4EF6\u81EA\u5DF1\u7684 LocalBackend\u2014\u2014\u529F\u80FD\u770B\u8D77\u6765\u6B63\u5E38\uFF0C\u4F46\u56F4\u680F\u6362\u4E86\u6267\u884C\u8005\u3002\u8BF7\u68C0\u67E5 cordis.patch.yml \u91CC \u8FDC\u7A0B\u5DE5\u4F5C\u533A-\u79C1\u6709\u57DF \u7EC4\uFF08fs \u7684 isolate \u4E0E \u8FDC\u7A0B\u5DE5\u4F5C\u533A-\u6865\u63A5fs \u884C\uFF09\u662F\u5426\u88AB\u7981\u7528\u6216\u52A0\u8F7D\u5931\u8D25\u3002';
 function installClientDataChannel(ctx) {
   try {
     installRemoteFace(ctx);
@@ -17849,6 +17931,10 @@ function wireRoots(env) {
         ctx.logger?.warn?.(
           `\u56DE\u6536\u7AD9\u7D22\u5F15\u9501\u5DF2\u8FC7\u671F\u88AB\u56DE\u6536\uFF1A\u6301\u6709\u8005 ${JSON.stringify(event.holder)}\uFF0C\u5DF2\u8FC7\u671F ${Math.round(event.ageMs / 1e3)} \u79D2`
         );
+      },
+      // 心跳失败只警告：锁仍然有效，操作继续；但网络盘 EIO/EPERM 值得在日志里留下痕迹。
+      onHeartbeatError: (error) => {
+        ctx.logger?.warn?.(`\u56DE\u6536\u7AD9\u7D22\u5F15\u9501\u5FC3\u8DF3\u5237\u65B0\u5931\u8D25\uFF08\u9501\u4ECD\u6301\u6709\uFF09\uFF1A${error instanceof Error ? error.message : String(error)}`);
       }
     });
     binLocks.set(key, created);
@@ -19930,6 +20016,7 @@ function parseContentLength(header) {
 }
 
 // src/host/integration/lsp/lsp-session.ts
+var LSP_READ_CHUNK_BYTES = 256 * 1024;
 var IDLE_POLL_MS = 60;
 var BUSY_POLL_MS = 0;
 var DEFAULT_REQUEST_TIMEOUT_MS = 2e4;
@@ -20218,7 +20305,7 @@ var LspSession = class _LspSession {
       if (this.#stopped) return;
       let delay = IDLE_POLL_MS;
       try {
-        const chunk = await this.#transport.lspRead(this.#id, this.#offset, signal);
+        const chunk = await this.#transport.lspRead(this.#id, this.#offset, signal, LSP_READ_CHUNK_BYTES);
         this.#offset = chunk.nextOffset;
         if (chunk.lost) {
           this.#failAll(new LspSessionError("\u8BED\u8A00\u670D\u52A1\u5668\u8F93\u51FA\u5DF2\u88AB\u4E22\u5F03\uFF08\u73AF\u5F62\u7F13\u51B2\u6EA2\u51FA\uFF09\uFF0C\u6D41\u4E0D\u53EF\u6062\u590D"));
@@ -21180,9 +21267,44 @@ function readArgs(args) {
     ...typeof record2["server"] === "string" && record2["server"] !== "" ? { server: record2["server"] } : {}
   };
 }
+function splitCommandLine(value) {
+  const parts = [];
+  let current = "";
+  let started = false;
+  let quote2;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (quote2 !== void 0) {
+      if (char === quote2) quote2 = void 0;
+      else if (char === "\\" && quote2 === '"' && index + 1 < value.length) {
+        current += value[index + 1];
+        index += 1;
+      } else current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote2 = char;
+      started = true;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (started) {
+        parts.push(current);
+        current = "";
+        started = false;
+      }
+      continue;
+    }
+    current += char;
+    started = true;
+  }
+  if (quote2 !== void 0) throw new Error('server \u7684\u5F15\u53F7\u6CA1\u6709\u95ED\u5408\uFF1B\u5E26\u7A7A\u683C\u7684\u8DEF\u5F84\u8BF7\u5199\u6210 "/opt/my tools/server" --stdio');
+  if (started) parts.push(current);
+  return parts;
+}
 function parseServer(value) {
   if (value === void 0) return void 0;
-  const parts = value.split(/\s+/).filter((part) => part !== "");
+  const parts = splitCommandLine(value);
   if (parts.length === 0) return void 0;
   return parts.length === 1 ? { command: parts[0] } : { command: parts[0], args: parts.slice(1) };
 }
@@ -21204,7 +21326,7 @@ function remoteLspToolDefinitions(deps) {
         column: { type: "integer", description: "Column for `hover` / `definition`, 1-based. Required for those two actions." },
         server: {
           type: "string",
-          description: "Executable to run, with optional arguments (`gopls`, `rust-analyzer`, `pylsp -v`). Defaults to the table entry for the file language; required when the language has no entry."
+          description: 'Executable to run, with optional arguments (`gopls`, `rust-analyzer`, `pylsp -v`). Defaults to the table entry for the file language; required when the language has no entry. Quote a path that contains spaces: `"/opt/my tools/server" --stdio`.'
         }
       },
       output: {
@@ -21463,6 +21585,10 @@ function wireSessionAdmin(env) {
       ctx.logger?.warn?.(
         `\u4F1A\u8BDD\u56DE\u6536\u7AD9\u7D22\u5F15\u9501\u5DF2\u8FC7\u671F\u88AB\u56DE\u6536\uFF1A\u6301\u6709\u8005 ${JSON.stringify(event.holder)}\uFF0C\u5DF2\u8FC7\u671F ${Math.round(event.ageMs / 1e3)} \u79D2`
       );
+    },
+    // 心跳失败只警告：锁仍有效，操作继续；网络盘 EIO/EPERM 需要留下痕迹。
+    onHeartbeatError: (error) => {
+      ctx.logger?.warn?.(`\u4F1A\u8BDD\u56DE\u6536\u7AD9\u7D22\u5F15\u9501\u5FC3\u8DF3\u5237\u65B0\u5931\u8D25\uFF08\u9501\u4ECD\u6301\u6709\uFF09\uFF1A${error instanceof Error ? error.message : String(error)}`);
     }
   });
   const sessionAdmin = createSessionAdminService({

package/lib/types/src/host/app/session-admin/session-admin-contract.d.ts

@@ -163,6 +163,23 @@ export interface RestoreSessionResult {
     /** Absolute path the session directory was moved back to. */
     readonly restoredPath: string;
     readonly movedBy: 'rename' | 'copy';
+    /**
+     * Sub-sessions restored **together with** the requested entry.
+     *
+     * Restoring a parent used to leave its deleted children in the bin with no discoverable link back to the
+     * parent, so the user could never learn they were still there. They are now restored in the same call.
+     */
+    readonly restoredSubsessions: readonly {
+        readonly sessionId: string;
+        readonly restoredPath: string;
+    }[];
+    /** Sub-sessions that could not be restored (path occupied, move failed); they stay in the bin. */
+    readonly failedSubsessions: readonly {
+        readonly sessionId: string;
+        readonly reason: string;
+    }[];
+    /** True when the restored entry is a sub-session whose parent is still in the bin. */
+    readonly parentStillBinned: boolean;
 }
 /** One purge outcome. */
 export interface PurgeSessionResult {

package/lib/types/src/host/domain/session/session-admin.d.ts

@@ -227,6 +227,13 @@ export interface SessionTrashEntry {
      */
     readonly originalSegment: string;
     readonly title: string | undefined;
+    /**
+     * Parent session id from the header, when this deleted session was a sub-session.
+     *
+     * Optional so an index written by 0.2.2 (which did not record it) still parses; restoring a parent then
+     * cannot find children recorded before the field existed, which is exactly the old behaviour.
+     */
+    readonly parentSessionId?: string | undefined;
     /** Total bytes of the moved log files, for the retention policy. */
     readonly bytes: number;
     readonly deletedAtMs: number;
@@ -342,6 +349,7 @@ export declare function makeSessionTrashEntry(input: {
     readonly segment: string;
     readonly originalSegment: string;
     readonly title: string | undefined;
+    readonly parentSessionId?: string | undefined;
     readonly bytes: number;
     readonly deletedAtMs: number;
     readonly movedBy: 'rename' | 'copy';

package/lib/types/src/local-bridge.d.ts

@@ -1,10 +1,10 @@
 /**
  * The `./local-bridge` entry: republish the private realm's stock `fs` under a name the router can inject.
  *
- * Composition (see `cordis.patch.yml`): a `cordis:group` with `isolate: { fs: true, fileReferences: true }`
- * instantiates the **stock** `fs-sandbox` a second time. Because that realm owns its own `fs` slot, the stock
- * sandbox keeps running and keeps enforcing the platform's write fences for local paths — this plugin no
- * longer re-implements them.
+ * Composition (see `cordis.patch.yml`): a `cordis:group` with `isolate: { fs: true }` instantiates the
+ * **stock** `fs-sandbox` a second time. Because that realm owns its own `fs` slot, the stock sandbox keeps
+ * running and keeps enforcing the platform's write fences for local paths — this plugin no longer
+ * re-implements them.
  *
  * The bridge is what carries that instance back out. It is provided under a **new name** (`localFs`), which is
  * not in the realm's `isolate` list, so the value reaches the root scope where the router injects it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-over-ssh",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "SSH remote development for DeepSeek Harness: connections (key/password/ProxyJump/ssh config), remote files without sync, remote terminal, remote workspaces, remote @-completion, upload/download.",
   "type": "module",
   "main": "lib/index.js",
@@ -26,10 +26,6 @@
       "types": "./lib/types/src/local-bridge.d.ts",
       "default": "./lib/local-bridge.js"
     },
-    "./local-bridge-refs": {
-      "types": "./lib/types/src/local-bridge-refs.d.ts",
-      "default": "./lib/local-bridge-refs.js"
-    },
     "./package.json": "./package.json"
   },
   "dsh": {

package/lib/local-bridge-refs.js

@@ -1,16 +0,0 @@
-// src/local-bridge-refs.ts
-import "@deepseek-ai/cordis";
-var LocalFileReferencesBridge = class {
-  static inject = ["fileReferences"];
-  constructor(ctx) {
-    const local = ctx.get("fileReferences");
-    if (local === void 0) {
-      ctx.logger?.warn?.("local-bridge-refs: \u9694\u79BB\u57DF\u91CC\u6CA1\u6709 fileReferences\uFF1B\u8DEF\u7531\u5668\u5C06\u6CA1\u6709\u672C\u5730\u540E\u7AEF");
-      return;
-    }
-    ctx.provide("localFileReferences", local);
-  }
-};
-export {
-  LocalFileReferencesBridge as default
-};

package/lib/types/src/local-bridge-refs.d.ts

@@ -1,25 +0,0 @@
-/**
- * The `./local-bridge-refs` entry: republish the private realm's stock `fileReferences` as `localFileReferences`.
- *
- * A **separate row** from `./local-bridge`, and that separation is load-bearing: the stock
- * `file-reference-local` injects `workingDirectory`, which sits downstream of the routed `fs`. If one bridge
- * gated both services it would have to wait for `fileReferences` too, and `fileReferences` cannot activate
- * until `workingDirectory` does — which cannot happen until the router it is waiting behind exists. Two rows
- * keep that dependency out of the way: `localFs` appears as soon as `fs` does, `localFileReferences` as soon as
- * `fileReferences` does.
- *
- * @module dsh-over-ssh/local-bridge-refs
- */
-import { Context } from '@deepseek-ai/cordis';
-import type { FileReferenceService } from '@deepseek-ai/dsh-file-reference';
-declare module '@deepseek-ai/cordis' {
-    interface Context {
-        /** The stock `file-reference-local` instance living in this plugin's private realm. */
-        localFileReferences?: FileReferenceService;
-    }
-}
-/** Publish the realm's `fileReferences` as `localFileReferences`. */
-export default class LocalFileReferencesBridge {
-    static inject: readonly ["fileReferences"];
-    constructor(ctx: Context);
-}