dsh-session-remover 1.0.0 → 1.0.2

package/README.en.md

@@ -3,6 +3,7 @@
 Adds "Delete conversation" and "Batch delete…" to the sidebar session row "…" menu, moving a conversation and its subagent sessions into the Windows recycle bin, from which they can be restored.
 
 - Package: `dsh-session-remover`
+- Version: `1.0.2`
 - Repository: <https://github.com/sailoumili/dsh-session-remover>
 - Compatible with DSH 0.1.7 and later; available for the web and desktop editions
 - Interface text follows the DSH interface language; Chinese and English are both provided
@@ -10,27 +11,17 @@ Adds "Delete conversation" and "Batch delete…" to the sidebar session row "…
 
 ## Installation
 
-### Web
-
 1. Click **Plugins** in the left sidebar.
 2. Click **Add plugin**.
-3. Enter `dsh-session-remover` in the package field, click **Install**, and wait for the installation to complete.
-4. Enable the plugin on its page.
-5. Restart DSH.
-
-Equivalent command line:
-
-```cmd
-dsh plugin --profile web add dsh-session-remover
-```
-
-### Desktop
+3. Enter the following in the package field:
 
-The desktop edition uses a separate plugin manifest (`~/.dsh/profiles/desktop`) and is independent of the web edition, so it requires a separate installation. The steps are identical: sidebar **Plugins** → **Add plugin** → enter the package name → **Install** → enable → restart.
+   ```text
+   dsh-session-remover
+   ```
 
-```cmd
-dsh plugin --profile desktop add dsh-session-remover
-```
+4. Click **Install** and wait for the installation to complete.
+5. Enable the plugin on its page.
+6. Restart DSH.
 
 ## Usage
 
@@ -43,18 +34,19 @@ dsh plugin --profile desktop add dsh-session-remover
 
 ## Notes
 
-- **Deletion moves the data to the recycle bin; it does not erase it.** The move stays on the same volume, so no data is copied and nothing is left behind in `.dsh`. Before deleting, the plugin checks whether the recycle bin is disabled for the volume that holds the session (Windows stores this setting per drive); if "Don't move files to the Recycle Bin. Remove files immediately when deleted" is ticked, the plugin **refuses to delete** rather than falling back to permanent deletion. Afterwards each item is verified in the recycle bin by original location and name.
+- **Deletion moves the data to the recycle bin; it does not erase it.** The move stays on the same volume, so no data is copied and nothing is left behind in `.dsh`. Before deleting, the plugin checks two things on the volume that holds the session (Windows stores the recycle-bin setting per drive): whether the recycle bin has been disabled, and whether the volume has a usable recycle bin at all; if either check fails the plugin **refuses to delete** rather than falling back to permanent deletion. Afterwards each item is verified by original location and name; the verification reads the local recycle bin index directly (listing file names only, not reading each entry), so its cost is essentially independent of how many items the bin already holds.
 - **Subagent sessions are removed together.** Subagent sessions are not shown in the sidebar or search, so they accumulate unless removed together. Forked conversations are independent and are **never** deleted along with their source.
+- **The session directory is located by session id.** The id recorded in the session log header is authoritative. If one id maps to more than one session directory (for example a bare id and a directory with the `session-` prefix side by side), the directory whose name equals the requested id exactly is deleted; when a unique target cannot be determined, the plugin **refuses to delete** and reports an error without changing any data.
 - **Three records are cleaned:** the projection cache, the workspace registry, and the archived set. The projection cache is derived data that DSH rebuilds after a restore; the other two are cleared to avoid leaving traces locally, at the cost of a restored conversation being filed under "Ungrouped" in the sidebar.
 - **Deleting the currently open conversation is supported.** Its running task is stopped and flushed to disk first, and no DSH restart is required.
 
 ## Known limitations
 
 - **Windows only.** Moving to the recycle bin relies on the system script host `cscript.exe`, which ships with Windows; on other systems the plugin refuses to delete and reports an error rather than falling back to permanent deletion.
+- **Deletion is refused when the volume has no recycle bin.** If the session directory sits on a network drive, a USB stick, or a volume with no usable recycle bin (such as FAT/exFAT), moving it to the recycle bin would degrade into permanent deletion, so the plugin always refuses. To proceed, move the session directory to a local disk, or delete any file on that volume once to initialise its recycle bin, and try again.
 - **An emptied recycle bin cannot be restored.** The plugin only moves the files into the bin; whether to empty it is the user's decision. The bin also has a size cap, and Windows discards the oldest entries once the quota is exceeded.
-- **A restored conversation may not be in its original workspace.** The plugin clears the workspace registry entry, so a restored conversation appears under "Ungrouped". To restore it to its original workspace, edit `~/.dsh/storages/workspace.json` by hand while DSH is stopped.
+- **A restored conversation may not be in its original workspace.** The plugin clears the workspace registry entry, so a restored conversation appears under "Ungrouped". To restore it to its original workspace, ask the AI assistant to update `~/.dsh/storages/workspace.json` while DSH is stopped.
 - **Attachments are not reclaimed.** DSH attachments are content-addressed, shared across conversations, and carry no reference counting, so the plugin cannot safely determine whether they can be reclaimed.
-- **On a failed delete, the reason text returned by the server also follows the interface language**: the server returns only an error code and parameters, and the interface text is resolved by the front end in the active language.
 - **The endpoint accepts loopback requests only.** `/api/session.delete` allows only `127.0.0.1` / `localhost` / `[::1]` and returns 403 for LAN origins. The plugin registers its route outside the official authentication fence, while the official browser-cookie check depends on a signing secret the plugin cannot obtain; deleting data is high-risk, so it fails closed. If DSH is bound to `0.0.0.0` and accessed from another machine, deletion returns 403.
 - **Nothing is touched when the session directory cannot be read.** A failed session-tree scan aborts the deletion as a whole and never treats "read failure" as "absent from disk".
 - The batch delete panel does not trap focus; `Tab` may move to page elements behind the panel.

package/README.md

@@ -3,6 +3,7 @@
 在侧栏会话行的「…」菜单中增加「删除对话」与「批量删除…」两项，将对话及其子代理会话移入 Windows 回收站，需要时可予以还原。
 
 - 包名：`dsh-session-remover`
+- 版本：`1.0.2`
 - 仓库：<https://github.com/sailoumili/dsh-session-remover>
 - 兼容 DSH 0.1.7 及以上版本，适用于网页版与桌面版
 - 界面文字随 DSH 界面语言切换，提供中文与英文两套
@@ -10,27 +11,17 @@
 
 ## 安装
 
-### 网页版
-
 1. 在左侧栏单击「插件」。
 2. 单击「添加插件」。
-3. 在「包名或地址」输入框中填写 `dsh-session-remover`，单击「安装」，等待安装完成。
-4. 在该插件页面中启用该插件。
-5. 重启 DSH。
-
-等效命令行：
-
-```cmd
-dsh plugin --profile web add dsh-session-remover
-```
-
-### 桌面版
+3. 在「包名或地址」输入框中填写：
 
-桌面版使用独立的插件清单（`~/.dsh/profiles/desktop`），与网页版互不影响，须单独安装一次。操作步骤与网页版一致：左侧栏「插件」→「添加插件」→ 填写包名 →「安装」→ 启用 → 重启。
+   ```text
+   dsh-session-remover
+   ```
 
-```cmd
-dsh plugin --profile desktop add dsh-session-remover
-```
+4. 单击「安装」，等待安装完成。
+5. 在该插件页面中启用该插件。
+6. 重启 DSH。
 
 ## 用法
 
@@ -43,18 +34,19 @@ dsh plugin --profile desktop add dsh-session-remover
 
 ## 说明
 
-- **删除为移入回收站，并非抹除**：同盘移动，不复制数据，`.dsh` 内不留副本。删除前先按会话所在磁盘核对回收站是否被关闭（Windows 该开关按磁盘逐个设置）；已勾选「不将文件移到回收站中，直接删除」时，插件**拒绝删除**，不会退化为永久删除。移入后另按「原位置 + 名字」在回收站中逐项核对，确认确实进入回收站。
+- **删除为移入回收站，并非抹除**：同盘移动，不复制数据，`.dsh` 内不留副本。删除前先按会话所在磁盘核对两件事：该磁盘是否关闭了回收站（Windows 该开关按磁盘逐个设置）、该磁盘是否有可用的回收站；任一不满足即**拒绝删除**，不会退化为永久删除。移入后另按「原位置 + 名字」逐项核对，确认确实进入回收站；核对直接读取本机回收站索引（只列文件名，不逐项读取），耗时基本不受回收站已存项数影响。
 - **一并删除子代理会话**：子代理会话不显示于侧栏与搜索，未一并清理将持续累积。由 fork 产生的分叉会话属独立对话，**不被连带删除**。
+- **按会话编号定位目录**：编号以会话日志头部记录的编号为准。同一编号若对应多个会话目录（例如裸编号与带 `session-` 前缀的目录并存），优先删除目录名与所传编号完全一致的那个；无法确定唯一目标时**拒绝删除**并报错，不改动任何数据。
 - **清理三处记录**：投影缓存、工作区记账、归档集合。投影缓存为派生数据，还原后由 DSH 自动重建；后两处予以清理以避免在本地留存痕迹，代价是还原后的对话归入侧栏的「未分组」。
 - **支持删除当前打开的对话**：删除前先停止其运行中的任务并落盘，无需重启 DSH。
 
 ## 已知限制
 
 - **仅支持 Windows**。移入回收站依赖系统脚本宿主 `cscript.exe`（Windows 自带）；在其他系统上插件拒绝删除并报错，不会退化为永久删除。
+- **所在磁盘没有回收站时拒绝删除**。会话目录若位于网络盘、U 盘或未启用回收站的磁盘（如 FAT/exFAT），移入回收站会退化为永久删除，插件一律拒绝。处理办法：先把会话目录搬到本地磁盘，或在该磁盘上删除任意一个文件以启用回收站，再重试。
 - **回收站清空后不可还原**。插件仅负责将文件移入回收站，是否清空由用户决定；回收站存在容量上限，超出配额时 Windows 将丢弃最早的项。
-- **还原后可能不在原工作区**。插件清除了工作区记账，还原的对话将出现在「未分组」中。如需恢复至原工作区，须在 DSH 停止运行时手工编辑 `~/.dsh/storages/workspace.json`。
+- **还原后可能不在原工作区**。插件清除了工作区记账，还原的对话将出现在「未分组」中。如需恢复至原工作区，可在 DSH 停止运行后请 AI 助手协助修改 `~/.dsh/storages/workspace.json`。
 - **附件不予回收**。DSH 附件按内容寻址、跨会话共享，且无引用计数，插件无法安全判断其可否回收。
-- **删除失败时服务端返回的原因文本同样随界面语言切换**：服务端只回错误码与参数，界面文字统一由前端按当前语言取词。
 - **端点仅接受本机请求**。`/api/session.delete` 仅放行回环地址（`127.0.0.1` / `localhost` / `[::1]`），局域网来源一律返回 403。本插件的路由位于官方鉴权栅栏之外，而官方基于浏览器 cookie 的鉴权依赖插件无法获取的签名密钥；删除数据属高风险操作，故从严处理。将 DSH 绑定至 `0.0.0.0` 并从其他机器访问时，删除将返回 403。
 - **无法读取会话目录时不作任何改动**。会话树收集失败即整体放弃删除，不会将「读取失败」视为「磁盘上不存在」。
 - 批量删除浮层不锁定焦点，按 `Tab` 键可能移至浮层后方的页面元素。

package/lib/client.js

@@ -94,13 +94,13 @@ window.__ModuleLoader__.load({
         "err.E_RECYCLE_SPAWN_FAILED": "调用回收站失败：{reason}",
         "err.E_RECYCLE_NO_RESULT": "回收站未返回结果，脚本未执行完",
         "err.E_RECYCLE_DISABLED": "本机已关闭回收站（已勾选「不将文件移到回收站中，直接删除」），插件拒绝删除，以免数据无法还原",
+        "err.E_NO_RECYCLE_BIN": "磁盘 {volume} 上没有可用的回收站（网络盘、U 盘或该磁盘尚未启用回收站），插件拒绝删除，以免数据无法还原。可先把会话目录搬到本地磁盘，或在该磁盘上删除任意一个文件以启用回收站后再试",
         "err.E_RECYCLE_UNRECOGNIZED": "无法识别回收站返回的结果",
         "err.E_RECYCLE_LEFT": "共 {total} 个会话目录，已移入回收站 {moved} 个，仍有 {left} 个未能移入",
         "err.E_RECYCLE_LEFT_REASON": "共 {total} 个会话目录，已移入回收站 {moved} 个，仍有 {left} 个未能移入：{reason}",
         "err.E_RECYCLE_MISMATCH": "回收站中仅找到 {matched}/{total} 个会话，可能有目录已被永久删除，请立即检查回收站",
         "err.E_WS_DETACH_FAILED": "从工作区摘除失败：{reason}",
         "err.E_DETACH_FAILED": "会话 {id} 未能从工作区摘除：{reason}",
-        "err.E_ABORTED_NO_CHANGE": "{reason}；已放弃删除，未改动任何数据",
         "err.E_NOT_FOUND": "未找到该会话",
         "err.E_MOVE_ABORTED": "{reason}；已中止，存储域与登记表保持原样",
         "err.E_LOOPBACK_ONLY": "已拒绝：该接口仅接受本机（回环）请求",
@@ -109,6 +109,7 @@ window.__ModuleLoader__.load({
         "err.E_BODY_READ_FAILED": "读取请求体失败",
         "err.E_SESSION_ID_REQUIRED": "缺少会话编号",
         "err.E_SESSION_ID_INVALID": "会话编号格式不正确：{id}",
+        "err.E_AMBIGUOUS_TARGET": "会话编号 {id} 对应多个会话目录（{dirs}），无法确定删除哪一个，已拒绝删除，未改动任何数据",
         "err.E_INTERNAL": "服务端内部错误：{reason}",
         "leftover.L_SESSION_DIR": "会话目录",
         "leftover.L_PROJ_CACHE": "投影缓存",
@@ -170,13 +171,13 @@ window.__ModuleLoader__.load({
         "err.E_RECYCLE_SPAWN_FAILED": "Failed to invoke the recycle bin: {reason}",
         "err.E_RECYCLE_NO_RESULT": "The recycle bin returned no result; the script did not finish",
         "err.E_RECYCLE_DISABLED": "The recycle bin is disabled on this machine (\"Don't move files to the Recycle Bin. Remove files immediately when deleted\" is selected), so the plugin refuses to delete rather than leave the data unrestorable",
+        "err.E_NO_RECYCLE_BIN": "Volume {volume} has no usable recycle bin (a network drive, a USB stick, or a volume where the recycle bin has not been initialised), so the plugin refuses to delete rather than leave the data unrestorable. Move the session directory to a local disk, or delete any file on that volume once to initialise its recycle bin, and try again",
         "err.E_RECYCLE_UNRECOGNIZED": "The result returned by the recycle bin could not be recognised",
         "err.E_RECYCLE_LEFT": "Of {total} session directories, {moved} were moved to the recycle bin and {left} could not be moved",
         "err.E_RECYCLE_LEFT_REASON": "Of {total} session directories, {moved} were moved to the recycle bin and {left} could not be moved: {reason}",
         "err.E_RECYCLE_MISMATCH": "Only {matched}/{total} sessions were found in the recycle bin; some directories may have been permanently deleted, so check the recycle bin immediately",
         "err.E_WS_DETACH_FAILED": "Failed to detach from the workspace: {reason}",
         "err.E_DETACH_FAILED": "Session {id} could not be detached from the workspace: {reason}",
-        "err.E_ABORTED_NO_CHANGE": "{reason}; deletion was abandoned and no data was changed",
         "err.E_NOT_FOUND": "Session not found",
         "err.E_MOVE_ABORTED": "{reason}; the operation was stopped and no records were deleted",
         "err.E_LOOPBACK_ONLY": "Refused: this endpoint accepts loopback requests only",
@@ -185,6 +186,7 @@ window.__ModuleLoader__.load({
         "err.E_BODY_READ_FAILED": "Failed to read the request body",
         "err.E_SESSION_ID_REQUIRED": "Missing session id",
         "err.E_SESSION_ID_INVALID": "Invalid session id format: {id}",
+        "err.E_AMBIGUOUS_TARGET": "Session id {id} matches more than one session directory ({dirs}), so the target is ambiguous. Deletion was refused and no data was changed",
         "err.E_INTERNAL": "Internal server error: {reason}",
         "leftover.L_SESSION_DIR": "session directory",
         "leftover.L_PROJ_CACHE": "projection cache",
@@ -237,7 +239,7 @@ window.__ModuleLoader__.load({
 
     function t(key, params) {
       var table = DICT[i18n.active] || DICT.zh;
-      // 词表是普通对象，键可能撞上原型链上的名字（如 constructor），故一律走自有属性判定。
+      // 词表为普通对象，键可能与原型链上的属性同名（如 constructor），故一律按自有属性判定。
       var text = Object.prototype.hasOwnProperty.call(table, key) ? table[key] : undefined;
       if (text === undefined) {
         text = Object.prototype.hasOwnProperty.call(DICT.zh, key) ? DICT.zh[key] : undefined;
@@ -257,11 +259,11 @@ window.__ModuleLoader__.load({
       return Object.prototype.hasOwnProperty.call(table, key) || Object.prototype.hasOwnProperty.call(DICT.zh, key);
     }
 
-    // 服务端的失败是「错误码 + 参数」；嵌套原因（reason）本身也可能是失败对象，故递归展开。
+    // 服务端的失败为「错误码 + 参数」；嵌套原因（reason）本身也可能为失败对象，故递归展开。
     function renderFailure(value) {
       if (value === null || value === undefined) return "";
       if (typeof value === "string") {
-        // 参数里也可能直接嵌一个裸码（而非对象），认得出来就一并取词。
+        // 参数中也可能直接嵌入错误码原文（而非对象），可识别时一并取词。
         var bare = /^(E|L)_[A-Z0-9_]+$/.test(value) ? (value.indexOf("L_") === 0 ? "leftover." : "err.") + value : null;
         return bare !== null && hasKey(bare) ? t(bare) : value;
       }
@@ -281,7 +283,7 @@ window.__ModuleLoader__.load({
       return "";
     }
 
-    // 浮层挂在自己另起的 React 根上（不经官方插槽），故自行订阅语言变化后重渲染。
+    // 浮层挂载于自行创建的 React 根上（不经官方插槽），故自行订阅语言变化后重渲染。
     function useI18nRevision() {
       var state = react.useState(i18n.revision);
       var setValue = state[1];
@@ -357,7 +359,7 @@ window.__ModuleLoader__.load({
           window.alert(renderFailure(result) || t("error.http", { status: response.status }));
           return;
         }
-        // 残留（leftover）与警告都要报出来，只报 warnings 会让「有记录没清掉」静默消失。
+        // 残留（leftover）与警告均须报出，仅报 warnings 将使「有记录未清理」静默消失。
         var notes = collectNotes(result);
         if (notes.length > 0) {
           window.alert(t("error.leftover", { list: notes.map(renderFailure).join("\n") }));
@@ -368,7 +370,7 @@ window.__ModuleLoader__.load({
       }
     }
 
-    // 残留与警告合并成一串：两者都表示「目录已移走，但本地还有东西没清干净」。
+    // 残留与警告合并为一串：两者均表示「目录已移走，但本地仍有数据未清理」。
     function collectNotes(result) {
       var notes = [];
       if (result && Array.isArray(result.warnings)) notes = notes.concat(result.warnings);
@@ -428,7 +430,7 @@ window.__ModuleLoader__.load({
       return value;
     }
 
-    // origin === "subagent" 过滤是安全关键：漏了会把子代理会话列给用户。
+    // origin === "subagent" 过滤是安全关键：遗漏会将子代理会话列给用户。
     function selectBatchRows(listState, workspaceState, currentId) {
       var rows = [];
       if (!listState || !listState.byId) return rows;
@@ -486,7 +488,7 @@ window.__ModuleLoader__.load({
       return undefined;
     }
 
-    // 官方组件（Button/Checkbox/Modal）取不到时有朴素兜底，键盘与语义仍可用。
+    // 官方组件（Button/Checkbox/Modal）取不到时有朴素降级实现，键盘与语义仍可用。
     function uiButton(props) {
       if (Button) return react.createElement(Button, props);
       return react.createElement("button", {
@@ -621,7 +623,7 @@ window.__ModuleLoader__.load({
         setAcknowledged(false);
       }
 
-      // 关闭闸门：删除进行中（busy）时不响应关闭，等跑完。
+      // 关闭闸门：删除进行中（busy）时不响应关闭，待其结束。
       function requestClose() {
         if (busy) return;
         onClose();
@@ -741,9 +743,7 @@ window.__ModuleLoader__.load({
                 if (row.workspace) meta.push(react.createElement("span", { key: "ws" }, row.workspace));
                 if (row.fork) meta.push(react.createElement("span", { key: "fork", className: "dsh-session-remover-tag" }, t("tag.fork")));
                 if (row.current) meta.push(react.createElement("span", { key: "cur", className: "dsh-session-remover-tag" }, t("tag.current")));
-                // label 传元素而非字符串：官方 Checkbox 的运行时是 jsx("span", { children: label })，
-                // 元素能正常渲染，只有这样才显示得出「标题 + 分支/当前打开」这一整行。
-                // 官方类型声明写的是 string，将来若给本插件加类型检查会在此报错，属预期差异。
+                // label 传元素：官方 Checkbox 运行时按 children 渲染，传字符串将无法显示这一整行。
                 var label = react.createElement("span", { className: "dsh-session-remover-rowmain" }, [
                   react.createElement("span", { key: "t", className: "dsh-session-remover-title" }, row.title),
                   meta.length > 0 ? react.createElement("span", { key: "m", className: "dsh-session-remover-meta" }, meta) : null
@@ -816,7 +816,7 @@ window.__ModuleLoader__.load({
       });
     }
 
-    // 本插件往官方侧栏插槽注册菜单项；批量浮层是自己另起的 React 根（官方没有多选插槽）。
+    // 本插件向官方侧栏插槽注册菜单项；批量浮层为自行创建的 React 根（官方无多选插槽）。
     var host = { ctx: null, container: null, root: null, seq: 0 };
 
     function ensureHost() {
@@ -866,9 +866,7 @@ window.__ModuleLoader__.load({
       host.container = null;
     }
 
-    // 插槽注册声明了 locale 命名空间，官方框架会把 t 随界面语言变化重新派发；
-    // 万一没给 t，退回模块内的同一套词表。
-    // 官方 t 查不到词条时会把 key 原样返回，故必须把「等于 key」也当作没取到，否则菜单会露出裸码。
+    // 官方 t 查不到词条时会将 key 原样返回，故「等于 key」同样视为未取到，否则菜单将显示错误码原文。
     function menuText(props, key) {
       if (props && typeof props.t === "function") {
         try {
@@ -949,8 +947,8 @@ window.__ModuleLoader__.load({
       }
       host.ctx = ctx;
 
-      // locale 服务软取：取不到就维持中文，不阻塞插件启用。
-      // 注册与订阅各自独立降级——订阅失败不该把已注册成功的词典一并废掉。
+      // locale 服务软取：取不到则维持中文，不阻塞插件启用。
+      // 注册与订阅各自独立降级——订阅失败不应使已注册成功的词典一并失效。
       var localeService = null;
       try { localeService = ctx.get("locale") || ctx.locale || null; } catch (e) { localeService = null; }
       var localeReady = false;
@@ -972,8 +970,8 @@ window.__ModuleLoader__.load({
           }
         }
       }
-      // 只有 locale 服务确实就位时才声明 locale：官方在没有 locale face 时渲染该条目会抛错，
-      // 恒带 locale 会把「软取、拿不到就退回中文」的设计变成整条侧栏报错。
+      // 仅当 locale 服务确实就位时才声明 locale：官方在无 locale face 时渲染该条目会抛出异常，
+      // 恒带 locale 将使「软取、取不到即退回中文」的设计变成整条侧栏报错。
       function entryOptions(id, order) {
         return localeReady
           ? { name: SLOT, id: id, order: order, locale: NS }

package/lib/index.js

@@ -1,6 +1,6 @@
 // dsh-session-remover —— 宿主半（node 侧），浏览器半见同包 lib/client.js。
-//   POST /api/session.delete  body { sessionId } —— 把该对话及其子代理后代移入系统回收站
-// 会动用户数据：只放行回环来源，非回环一律拒。
+//   POST /api/session.delete  body { sessionId } —— 将该对话及其子代理后代移入系统回收站
+// 本插件改动用户数据，故仅放行回环来源，非回环请求一律拒绝。
 import { closeSync, existsSync, mkdtempSync, openSync, readFileSync, readdirSync, readSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { homedir, tmpdir } from "node:os";
@@ -23,11 +23,11 @@ function json(res, status, value, extraHeaders) {
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
-// 失败一律回「错误码 + 参数」，由浏览器半按界面语言取词：服务端不产出面向界面的自然语言，
-// 否则英文界面下会冒出中文。params 的值可以是字符串，也可以是另一个失败对象，供嵌套原因递归展开。
+// 失败一律返回「错误码 + 参数」，由浏览器半按界面语言取词：服务端不产出面向界面的自然语言，
+// 否则英文界面下将显示中文。params 的值可为字符串，也可为另一个失败对象，供嵌套原因递归展开。
 const fail = (code, params, extra) => ({ ok: false, code, params: params || {}, ...(extra || {}) });
 
-// 自注册路由在官方 /api 信任栅栏之外，须自补判据。只放行回环来源：官方第二道浏览器 cookie 鉴权依赖插件拿不到的签名密钥。0 = 放行；403 = 拒。
+// 自注册路由位于官方 /api 信任栅栏之外，须自行补充判据。仅放行回环来源：官方第二道浏览器 cookie 鉴权依赖插件无法取得的签名密钥。0 = 放行；403 = 拒绝。
 function isLoopbackHostname(hostname) {
   if (hostname === "localhost" || hostname === "[::1]") return true;
   const parts = String(hostname).split(".");
@@ -74,31 +74,9 @@ function isInside(root, target) {
   const t = resolve(target).toLowerCase();
   return t.startsWith(r + "\\") || t.startsWith(r + "/");
 }
-// 读磁盘的函数一律：读失败返回 ok:false。把「读不出来」当成「磁盘上没有」，会误判活会话。
-function findSessionDirs(sessionId) {
-  const root = sessionsRoot();
-  const variants = idVariants(sessionId);
-  const out = [];
-  let slugs = [];
-  try {
-    slugs = readdirSync(root, { withFileTypes: true });
-  } catch (error) {
-    return { ...fail("E_SESSION_ROOT_UNREADABLE", { reason: String(error?.message || error) }), dirs: out };
-  }
-  for (const slug of slugs) {
-    if (!slug.isDirectory()) continue;
-    for (const v of variants) {
-      const p = join(root, slug.name, v);
-      try {
-        if (statSync(p).isDirectory() && !out.includes(p)) out.push(p);
-      } catch {}
-    }
-  }
-  return { ok: true, dirs: out };
-}
 
 const ZSTD_MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
-// 复用一块头缓冲：readSessionHeader 是同步函数，不会重入；几百个会话逐个 new 会白扔上百 MB。
+// 复用同一块头缓冲：readSessionHeader 为同步函数，不会重入；数百个会话逐个分配将浪费上百 MB。
 const HEAD_BUF = Buffer.allocUnsafe(HEAD_BYTES);
 
 function sessionLogFiles(dir) {
@@ -134,14 +112,16 @@ function readSessionHeader(dir) {
   }
   return null;
 }
+const normId = (value) => String(value).replace(/^session-/, "");
+const sessionKey = (value) => "session-" + normId(value);
+// 读磁盘的函数一律在读失败时返回 ok:false。将「读不出来」当作「磁盘上没有」会误判活动会话。
 function indexSessionsOnDisk() {
-  const byKey = new Map();
-  const byDir = new Map();
+  const entries = [];
   let slugs = [];
   try {
     slugs = readdirSync(sessionsRoot(), { withFileTypes: true });
   } catch (error) {
-    return { ...fail("E_SESSION_ROOT_UNREADABLE", { reason: String(error?.message || error) }), byKey, byDir };
+    return { ...fail("E_SESSION_ROOT_UNREADABLE", { reason: String(error?.message || error) }), entries };
   }
   for (const slug of slugs) {
     if (!slug.isDirectory()) continue;
@@ -150,17 +130,29 @@ function indexSessionsOnDisk() {
     try {
       dirs = readdirSync(slugDir, { withFileTypes: true });
     } catch (error) {
-      return { ...fail("E_WORKSPACE_DIR_UNREADABLE", { name: slug.name, reason: String(error?.message || error) }), byKey, byDir };
+      return { ...fail("E_WORKSPACE_DIR_UNREADABLE", { name: slug.name, reason: String(error?.message || error) }), entries };
     }
     for (const d of dirs) {
       if (!d.isDirectory()) continue;
       const dir = join(slugDir, d.name);
-      const entry = { dir, dirName: d.name, id: "session-" + d.name.replace(/^session-/, ""), header: readSessionHeader(dir) };
-      byDir.set(d.name, entry);
-      byKey.set(entry.id, entry);
+      const header = readSessionHeader(dir);
+      // 编号以 header 为权威：目录名可能是另一种写法，归一化后两者会撞成同一个编号。
+      const id = typeof header?.id === "string" && header.id.length > 0 ? header.id : sessionKey(d.name);
+      entries.push({ dir, dirName: d.name, id, header });
     }
   }
-  return { ok: true, byKey, byDir };
+  return { ok: true, entries };
+}
+// 点名优先：同一编号可能对应多个目录（裸名与带前缀并存），取目录名与请求完全一致的那个；
+// 没有完全一致的才取唯一候选；仍有多个即拒绝，一个字节都不动。
+function resolveSessionRoot(sessionId, entries) {
+  const want = normId(sessionId);
+  const candidates = entries.filter((e) => normId(e.id) === want);
+  if (candidates.length === 0) return { ok: true, entry: null };
+  const exact = candidates.filter((e) => e.dirName === sessionId);
+  if (exact.length === 1) return { ok: true, entry: exact[0] };
+  if (candidates.length === 1) return { ok: true, entry: candidates[0] };
+  return fail("E_AMBIGUOUS_TARGET", { id: sessionId, dirs: candidates.map((e) => e.dirName).join(", ") }, { status: 409 });
 }
 function permanentSessionKeys(ctx) {
   const keys = new Set();
@@ -187,53 +179,63 @@ function permanentSessionKeys(ctx) {
   }
   return { ok: true, keys };
 }
-// 收集该会话及其磁盘上的全部子代理后代，返回「后代在前、父在后」的目录清单。
+// 收集该会话及其磁盘上的全部子代理后代，返回「后代在前、父在后」的目录与编号清单。
 function collectSessionTree(ctx, sessionId) {
   const perm = permanentSessionKeys(ctx);
   if (!perm.ok) return fail("E_PROTECTED_LIST_UNREADABLE", { reason: perm });
   const protectedKeys = perm.keys;
   const index = indexSessionsOnDisk();
   if (!index.ok) return fail("E_INDEX_UNREADABLE", { reason: index });
-  const { byKey, byDir } = index;
-  const rootKey = "session-" + sessionId.replace(/^session-/, "");
+  const root = resolveSessionRoot(sessionId, index.entries);
+  if (!root.ok) return root;
+  if (!root.entry) return { ok: true, dirs: [], ids: [] };
+  const dirs = [];
+  const ids = [];
+  // 空壳目录没有日志，不可能有子代理，只删它自己。
+  if (!root.entry.header) {
+    dirs.push(root.entry.dir);
+    ids.push(root.entry.id);
+    return { ok: true, dirs, ids };
+  }
   const childrenOf = new Map();
-  for (const entry of byKey.values()) {
-    if (protectedKeys.has(entry.id)) continue;
-    // 只收 origin === "subagent"：fork 出来的分叉会话 header 里也有 parentSession，但它是独立对话，绝不能连带删。
-    if (entry.header?.origin !== "subagent") continue;
-    const parent = entry.header?.parentSession;
+  for (const entry of index.entries) {
+    if (!entry.header) continue;
+    // 仅收 origin === "subagent"：由 fork 产生的分叉会话 header 中同样有 parentSession，但其属独立对话，不得连带删除。
+    if (entry.header.origin !== "subagent") continue;
+    const parent = entry.header.parentSession;
     if (typeof parent !== "string" || parent.length === 0) continue;
-    const parentKey = "session-" + parent.replace(/^session-/, "");
-    const list = childrenOf.get(parentKey) ?? [];
-    list.push(entry.id);
-    childrenOf.set(parentKey, list);
+    if (protectedKeys.has(sessionKey(entry.id))) continue;
+    const list = childrenOf.get(parent) ?? [];
+    list.push(entry);
+    childrenOf.set(parent, list);
   }
-  const ordered = [];
+  // 先按 header 里的原样编号配对，配不上再试另一种写法，避免两种写法混用时漏掉后代。
+  const childrenFor = (entry) => {
+    for (const k of [entry.id, normId(entry.id), sessionKey(entry.id)]) {
+      const list = childrenOf.get(k);
+      if (list && list.length > 0) return list;
+    }
+    return [];
+  };
   const seen = new Set();
-  const stack = [rootKey];
+  const stack = [[root.entry, false]];
   while (stack.length > 0) {
-    const key = stack.pop();
-    if (seen.has(key)) continue;
-    seen.add(key);
-    ordered.push(key);
-    for (const child of childrenOf.get(key) ?? []) stack.push(child);
-  }
-  const targetKeys = ordered.filter((key) => key === rootKey || !protectedKeys.has(key));
-  const dirs = [];
-  for (const key of targetKeys.reverse()) {
-    const entry = byKey.get(key);
-    if (entry) dirs.push(entry.dir);
-  }
-  const rootDirs = new Set(dirs);
-  for (const name of idVariants(sessionId)) {
-    const entry = byDir.get(name);
-    if (entry && !rootDirs.has(entry.dir)) { dirs.push(entry.dir); rootDirs.add(entry.dir); }
+    const [entry, expanded] = stack.pop();
+    if (expanded) {
+      dirs.push(entry.dir);
+      ids.push(entry.id);
+      continue;
+    }
+    if (seen.has(entry.dir)) continue;
+    seen.add(entry.dir);
+    stack.push([entry, true]);
+    for (const child of childrenFor(entry)) if (!seen.has(child.dir)) stack.push([child, false]);
   }
-  return { ok: true, dirs };
+  return { ok: true, dirs, ids };
 }
 
-// 移入回收站要靠系统脚本宿主 cscript：node 没有回收站接口，PowerShell 每次启动太慢。
-// 结果写文件而非 stdout——管道在受限环境里拿不到，写文件到哪都能读。
+// 移入回收站依赖系统脚本宿主 cscript：node 无回收站接口，PowerShell 每次启动开销过大。
+// 结果写入文件而非 stdout——受限环境中无法取得管道输出，写入文件不受此限制。
 function cscriptPath() {
   const root = process.env.SystemRoot || "C:\\Windows";
   for (const p of [join(root, "System32", "cscript.exe"), join(root, "SysWOW64", "cscript.exe")]) {
@@ -241,10 +243,9 @@ function cscriptPath() {
   }
   return "";
 }
-// 回收站被关掉（NukeOnDelete=1）时 MoveHere 会直接永久删除，与「可还原」的承诺相反 → 先拒绝。
-// 注意：该开关是「按卷」存的（回收站属性按驱动器逐个勾选），根键下通常没有这个值，
-// 故必须先由盘符查到卷 GUID，再读该卷的值；只读根键会让这道闸门形同虚设。
-// 移完后按「原位置 + 名字」回回收站里点名核对，确认真的进去了，而不是被静默永久删掉。
+// 回收站被关闭（NukeOnDelete=1）时 MoveHere 将直接永久删除，与「可还原」的承诺相反，故先行拒绝。
+// 该开关按卷存储（回收站属性按驱动器逐个勾选），根键下通常没有此值，
+// 故须先由盘符查出卷 GUID，再读该卷的值；仅读根键将使此闸门失效。
 function recycleScript(paths, resultFile) {
   return [
     "var paths = " + JSON.stringify(paths) + ";",
@@ -253,7 +254,7 @@ function recycleScript(paths, resultFile) {
     'var wsh = new ActiveXObject("WScript.Shell");',
     "function write(line) { var o = fso.CreateTextFile(resultFile, true, false); o.WriteLine(line); o.Close(); }",
     "function readNuke(key) { try { return wsh.RegRead(key); } catch (e) { return 0; } }",
-    // 反斜杠用 fromCharCode 拼，避免多层转义出错。
+    // 反斜杠以 fromCharCode 拼接，避免多层转义出错。
     "var BS = String.fromCharCode(92);",
     'var ROOT_KEY = ["HKCU","Software","Microsoft","Windows","CurrentVersion","Explorer","BitBucket"].join(BS);',
     // 盘符 → 卷 GUID：Win32_Volume 的 DeviceID 形如 \\?\Volume{GUID}\
@@ -272,7 +273,7 @@ function recycleScript(paths, resultFile) {
     "  } catch (err) {}",
     "  return \"\";",
     "}",
-    // 卷级值读不到时退回根键值（旧版 Windows 把开关放在根键）。
+    // 卷级值读不到时退回根键值（旧版 Windows 将该开关置于根键）。
     "function isNukeOn(p) {",
     "  var volKey = volumeKeyOf(p);",
     "  if (volKey !== \"\") {",
@@ -285,10 +286,8 @@ function recycleScript(paths, resultFile) {
     "}",
     'var sh = new ActiveXObject("Shell.Application");',
     "var bin = sh.NameSpace(10);",
-    "function baseName(p) { var a = p.split(\"\\\\\"); return a[a.length - 1]; }",
-    "function dirName(p) { var a = p.split(\"\\\\\"); a.pop(); return a.join(\"\\\\\").toLowerCase(); }",
-    // 摘内存后落盘句柄的关闭是异步的，一次 MoveHere 可能撞上「目录仍被占用」而失败，
-    // 故在截止时间内反复重试，只对仍存在的路径再搬一次。
+    // 摘内存后落盘句柄的关闭是异步的，一次 MoveHere 可能因「目录仍被占用」而失败，
+    // 故在截止时间内反复重试，仅对仍存在的路径再次搬移。
     "var deadline = (new Date()).getTime() + " + RECYCLE_TIMEOUT_MS + ";",
     "var left = paths.length;",
     "var lastErr = \"\";",
@@ -303,53 +302,143 @@ function recycleScript(paths, resultFile) {
     "  if ((new Date()).getTime() > deadline) break;",
     "  WScript.Sleep(200);",
     "}",
-    // 逐项容错：回收站里个别项取属性会抛错，一处抛错不能带塌整轮核对。
-    "var matched = 0;",
-    "var e = new Enumerator(bin.Items());",
-    "for (; !e.atEnd(); e.moveNext()) {",
-    "  try {",
-    "    var it = e.item();",
-    "    var nm = String(it.Name);",
-    "    for (var k = 0; k < paths.length; k++) {",
-    "      if (nm !== baseName(paths[k])) continue;",
-    '      if (String(bin.GetDetailsOf(it, 1)).toLowerCase() === dirName(paths[k])) { matched++; break; }',
-    "    }",
-    "  } catch (err2) {}",
-    "}",
-    'write("RS|" + left + "|" + matched + "|" + lastErr.replace(/[\\r\\n|]/g, " "));',
+    'write("RS|" + left + "|" + lastErr.replace(/[\\r\\n|]/g, " "));',
   ].join("\r\n");
 }
+function recycleIndexSnapshot() {
+  const seen = new Set();
+  for (let code = 65; code <= 90; code++) {
+    const root = String.fromCharCode(code) + ":\\$Recycle.Bin";
+    let sids;
+    try { if (!statSync(root).isDirectory()) continue; sids = readdirSync(root, { withFileTypes: true }); } catch { continue; }
+    for (const sid of sids) {
+      if (!sid.isDirectory()) continue;
+      let names;
+      try { names = readdirSync(join(root, sid.name)); } catch { continue; }
+      for (const name of names) if (name.startsWith("$I")) seen.add(join(root, sid.name, name));
+    }
+  }
+  return seen;
+}
+// $I 为回收站索引文件，版本 2（Win10 起）布局：0-7 版本、8-15 原大小、16-23 删除时间、
+// 24-27 路径字符数（含结尾 NUL）、28 起为 UTF-16LE 原始路径。
+// 不可用 indexOf(0) 查找结尾：UTF-16LE 中 ASCII 字符为「XX 00」，将在每个字符的高字节处停止。
+function recycleOriginalPath(file) {
+  let buf;
+  try { buf = readFileSync(file); } catch { return ""; }
+  if (buf.length < 28) return "";
+  if (buf.readUInt32LE(0) === 1) {
+    const end = buf.indexOf(0, 0);
+    return buf.subarray(0, end < 0 ? buf.length : end).toString("latin1");
+  }
+  const start = 28;
+  const chars = buf.readUInt32LE(24);
+  if (chars > 1 && start + (chars - 1) * 2 <= buf.length) {
+    return buf.subarray(start, start + (chars - 1) * 2).toString("utf16le");
+  }
+  // 长度字段不可信时，退回按 2 字节步进查找结尾 NUL。
+  for (let i = start; i + 1 < buf.length; i += 2) {
+    if (buf[i] === 0 && buf[i + 1] === 0) return buf.subarray(start, i).toString("utf16le");
+  }
+  return buf.subarray(start).toString("utf16le");
+}
+function parentDir(p) {
+  const parts = String(p).split(/[\\/]/).filter(Boolean);
+  parts.pop();
+  return parts.join("\\").toLowerCase();
+}
+// 核对是否确实进入回收站：仅认本次新增的 $I 项，按「原位置 + 名字」逐条比对。
+// 采用差集而非全站按名字搜索：同名同路径的旧项可能早已存在于回收站中，将被误判为本次搬移成功。
+function verifyRecycled(before, dirs) {
+  const want = dirs.map((d) => ({ name: dirName(d).toLowerCase(), parent: parentDir(d) }));
+  // 按目标目录去重计数：同一目录在窗口内出现两条新增 $I 时仅计一次，否则将顶替另一个未搬移成功的目录。
+  const hit = new Set();
+  let added = 0;
+  for (const file of recycleIndexSnapshot()) {
+    if (before.has(file)) continue;
+    added++;
+    const orig = recycleOriginalPath(file);
+    if (orig === "") continue;
+    const name = dirName(orig).toLowerCase();
+    const parent = parentDir(orig);
+    for (let i = 0; i < want.length; i++) {
+      if (!hit.has(i) && want[i].name === name && want[i].parent === parent) { hit.add(i); break; }
+    }
+  }
+  return { matched: hit.size, added };
+}
+// 判定整批确已进入回收站须同时满足两条：索引中新增的项命中每一个目标，且原路径已从磁盘消失。
+function recycledAll(before, dirs) {
+  return verifyRecycled(before, dirs).matched === dirs.length && !dirs.some((d) => existsSync(d));
+}
+// cscript 无回应不等于搬移失败：先查一次索引，全部命中即按成功收尾，否则将误报失败并留下残留记录。
+function salvageMoved(before, dirs) {
+  return recycledAll(before, dirs) ? { ok: true, moved: dirs.length, salvaged: true } : null;
+}
+// 回收站按卷生效：网络共享与 FAT/exFAT 盘上 MoveHere 为永久删除，与「可还原」的承诺相反，故先行拒绝。
+function volumeRootOf(dir) {
+  const m = /^([A-Za-z]):[\\/]/.exec(resolve(dir));
+  return m ? m[1].toUpperCase() + ":\\" : "";
+}
+function recycleBinUsable(dir) {
+  const root = volumeRootOf(dir);
+  if (root === "") return false;
+  try { return statSync(join(root, "$Recycle.Bin")).isDirectory(); } catch { return false; }
+}
 async function recycleBinMove(dirs) {
   if (dirs.length === 0) return { ok: true, moved: 0 };
   const exe = cscriptPath();
   if (exe === "") return fail("E_CSCRIPT_MISSING");
   const root = sessionsRoot();
   if (dirs.some((d) => !isInside(root, d))) return fail("E_DIR_OUTSIDE_ROOT");
+  for (const d of dirs) {
+    if (!recycleBinUsable(d)) return fail("E_NO_RECYCLE_BIN", { volume: volumeRootOf(d) || d });
+  }
   const work = mkdtempSync(join(tmpdir(), "dsh-session-remover-"));
   const script = join(work, "recycle.js");
   const resultFile = join(work, "result.txt");
   try {
-    // cscript 按 BOM 判编码，UTF-16LE 才认得出中文路径。
+    const before = recycleIndexSnapshot();
+    // cscript 按 BOM 判定编码，UTF-16LE 方能识别中文路径。
     writeFileSync(script, "\uFEFF" + recycleScript(dirs, resultFile), "utf16le");
     const r = spawnSync(exe, ["//nologo", "//E:JScript", script], {
       stdio: "ignore", timeout: RECYCLE_TIMEOUT_MS + 30000, windowsHide: true,
     });
-    if (r.error) return fail("E_RECYCLE_SPAWN_FAILED", { reason: r.error.message });
+    if (r.error) {
+      const salvaged = salvageMoved(before, dirs);
+      if (salvaged) return salvaged;
+      return fail("E_RECYCLE_SPAWN_FAILED", { reason: r.error.message });
+    }
     let text = "";
-    try { text = readFileSync(resultFile, "utf8"); } catch { return fail("E_RECYCLE_NO_RESULT"); }
+    try { text = readFileSync(resultFile, "utf8"); } catch {
+      const salvaged = salvageMoved(before, dirs);
+      if (salvaged) return salvaged;
+      return fail("E_RECYCLE_NO_RESULT");
+    }
     if (text.startsWith("NUKE")) {
       return fail("E_RECYCLE_DISABLED");
     }
-    const m = text.match(/RS\|(\d+)\|(\d+)\|?([^\r\n]*)/);
-    if (!m) return fail("E_RECYCLE_UNRECOGNIZED");
+    const m = text.match(/RS\|(\d+)\|?([^\r\n]*)/);
+    if (!m) {
+      // 结果文件存在但内容不完整（写入中途进程被终止）：同样先查索引再判失败。
+      const salvaged = salvageMoved(before, dirs);
+      if (salvaged) return salvaged;
+      return fail("E_RECYCLE_UNRECOGNIZED");
+    }
     const left = Number(m[1]);
-    const matched = Number(m[2]);
-    const lastErr = (m[3] || "").trim();
-    // 部分成功是可能发生的：搬移是逐项的，失败的项数要如实报出来，不能一律说「未删除任何记录」。
+    const lastErr = (m[2] || "").trim();
+    // 部分成功是可能发生的：搬移逐项进行，失败项数须如实报出。
     if (left > 0) {
-      const params = { left, total: dirs.length, moved: dirs.length - left };
+      // 脚本按「原路径是否仍存在」统计 left，句柄释放存在延迟时会误判为仍存在，故再用索引查一次。
+      const { matched } = verifyRecycled(before, dirs);
+      if (matched === dirs.length && !dirs.some((d) => existsSync(d))) {
+        return { ok: true, moved: dirs.length, salvaged: true };
+      }
+      const moved = Math.min(Math.max(dirs.length - left, matched), dirs.length - 1);
+      const params = { left: dirs.length - moved, total: dirs.length, moved };
       return fail(lastErr === "" ? "E_RECYCLE_LEFT" : "E_RECYCLE_LEFT_REASON", lastErr === "" ? params : { ...params, reason: lastErr });
     }
+    const { matched } = verifyRecycled(before, dirs);
     if (matched < dirs.length) {
       return fail("E_RECYCLE_MISMATCH", { matched, total: dirs.length });
     }
@@ -368,7 +457,7 @@ async function stopAgent(ctx, sessionId) {
     stopped = true;
     try { agent.cancel?.({ kind: "disposed" }); } catch {}
     try {
-      // Agent 只有 cancel/whenIdle，没有可自己调的 scope；等它静默即可，超时就走人。
+      // Agent 仅有 cancel/whenIdle，没有可自行调用的 scope；等待其静默即可，超时则结束等待。
       if (typeof agent.whenIdle === "function") await Promise.race([agent.whenIdle(), sleep(AGENT_QUIESCE_MS)]);
       else await sleep(200);
     } catch {}
@@ -400,7 +489,7 @@ async function detachLive(ctx, sessionId) {
       const store = sessions.store;
       const entry = store && typeof store.get === "function" ? store.get(v) : undefined;
       if (entry === undefined) continue;
-      // 首选官方 enter() 交出的 detach 闭包：它是唯一会连带摘内部附件的口子。
+      // 首选官方 enter() 交出的 detach 闭包：它是唯一会连带摘除内部附件的途径。
       if (typeof entry.detach === "function") { entry.detach(); detached = true; }
       else if (typeof sessions.detachEntered === "function") { sessions.detachEntered(entry); detached = true; }
       else if (typeof store.delete === "function") { store.delete(v); detached = true; }
@@ -449,7 +538,7 @@ async function removeFromArchiveSet(ctx, sessionId) {
   const registry = ctx.get("workspaceRegistry");
   if (!registry) return false;
   const variants = idVariants(sessionId);
-  // 公开接口优先：不在归档集时它静默返回，正合我用。
+  // 公开接口优先：不在归档集时静默返回。
   if (typeof registry.unarchiveSession === "function") {
     let removed = false;
     try {
@@ -479,21 +568,14 @@ async function removeFromArchiveSet(ctx, sessionId) {
   return removed;
 }
 
-// 三段式：先摘内存（运行中的会话占着文件句柄，不摘就搬不动）→ 再把整棵树一次性移入回收站
-// → 最后清记账。磁盘这一步失败就整体中止，后面的记录一律不动，留给用户重试。
+// 三段式：先摘内存（运行中的会话占用文件句柄，不摘除则无法移动）→ 再将整棵树一次性移入回收站
+// → 最后清理记账。磁盘这一步失败即整体中止，后续记录一律不动，供用户重试。
 async function deleteSessionCore(ctx, sessionId) {
   const tree = collectSessionTree(ctx, sessionId);
-  const treeFailed = tree.ok ? null : tree;
-  const fallback = tree.ok && tree.dirs.length > 0 ? null : findSessionDirs(sessionId);
-  if (fallback && !fallback.ok) {
-    return fail("E_ABORTED_NO_CHANGE", { reason: fallback });
-  }
-  const dirs = tree.ok && tree.dirs.length > 0 ? tree.dirs : fallback.dirs;
-  if (treeFailed) ctx.logger?.warn?.(`[dsh-session-remover] ${sessionId}：连带展开失败 ${treeFailed.code}`);
+  if (!tree.ok) return tree;
+  const { dirs, ids } = tree;
   if (dirs.length === 0) return fail("E_NOT_FOUND", {}, { status: 404 });
 
-  const ids = dirs.map((d) => "session-" + dirName(d).replace(/^session-/, ""));
-
   let stopped = false, flushed = false, detached = false;
   for (const id of ids) {
     stopped = (await stopAgent(ctx, id)) || stopped;
@@ -539,7 +621,7 @@ function auditLeftover(ctx, sessionId, dirs) {
   if (dirs.some((d) => existsSync(d))) leftover.push({ code: "L_SESSION_DIR" });
   const sd = ctx.get("storageDomain");
   if (sd && typeof sd.get === "function") {
-    // 只审 rc.2 里真实存在的存储域：message_feedback 已改为会话日志权威，不再是存储域。
+    // 仅审计 rc.2 中真实存在的存储域：message_feedback 已改为以会话日志为权威，不再是存储域。
     for (const [domainName, label] of [["session_projcache", "L_PROJ_CACHE"]]) {
       try {
         const domain = sd.get(domainName);
@@ -581,7 +663,7 @@ function apply(ctx) {
       try {
         for await (const chunk of req) {
           raw += chunk;
-          // 超限与「读失败」是两回事：前者是客户端请求过大，回 413 才能让人看懂。
+          // 超限与「读失败」性质不同：前者为客户端请求过大，返回 413 便于理解。
           if (raw.length > BODY_LIMIT) return json(res, 413, fail("E_BODY_TOO_LARGE"));
         }
       } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-remover",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "DSH 插件：在侧栏会话行的「…」菜单中增加「删除对话」与「批量删除…」，将对话及其子代理会话移入 Windows 回收站，可从回收站还原。",
   "keywords": [
     "dsh",