dsh-session-remover 1.0.0 → 1.0.1

package/README.en.md

@@ -43,7 +43,7 @@ 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.
 - **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.
@@ -51,6 +51,7 @@ dsh plugin --profile desktop add dsh-session-remover
 ## 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.
 - **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.

package/README.md

@@ -43,7 +43,7 @@ dsh plugin --profile desktop add dsh-session-remover
 
 ## 说明
 
-- **删除为移入回收站，并非抹除**：同盘移动，不复制数据，`.dsh` 内不留副本。删除前先按会话所在磁盘核对回收站是否被关闭（Windows 该开关按磁盘逐个设置）；已勾选「不将文件移到回收站中，直接删除」时，插件**拒绝删除**，不会退化为永久删除。移入后另按「原位置 + 名字」在回收站中逐项核对，确认确实进入回收站。
+- **删除为移入回收站，并非抹除**：同盘移动，不复制数据，`.dsh` 内不留副本。删除前先按会话所在磁盘核对两件事：该磁盘是否关闭了回收站（Windows 该开关按磁盘逐个设置）、该磁盘是否有可用的回收站；任一不满足即**拒绝删除**，不会退化为永久删除。移入后另按「原位置 + 名字」逐项核对，确认确实进入回收站；核对直接读取本机回收站索引（只列文件名，不逐项读取），耗时基本不受回收站已存项数影响。
 - **一并删除子代理会话**：子代理会话不显示于侧栏与搜索，未一并清理将持续累积。由 fork 产生的分叉会话属独立对话，**不被连带删除**。
 - **清理三处记录**：投影缓存、工作区记账、归档集合。投影缓存为派生数据，还原后由 DSH 自动重建；后两处予以清理以避免在本地留存痕迹，代价是还原后的对话归入侧栏的「未分组」。
 - **支持删除当前打开的对话**：删除前先停止其运行中的任务并落盘，无需重启 DSH。
@@ -51,6 +51,7 @@ dsh plugin --profile desktop add dsh-session-remover
 ## 已知限制
 
 - **仅支持 Windows**。移入回收站依赖系统脚本宿主 `cscript.exe`（Windows 自带）；在其他系统上插件拒绝删除并报错，不会退化为永久删除。
+- **所在磁盘没有回收站时拒绝删除**。会话目录若位于网络盘、U 盘或未启用回收站的磁盘（如 FAT/exFAT），移入回收站会退化为永久删除，插件一律拒绝。处理办法：先把会话目录搬到本地磁盘，或在该磁盘上删除任意一个文件以启用回收站，再重试。
 - **回收站清空后不可还原**。插件仅负责将文件移入回收站，是否清空由用户决定；回收站存在容量上限，超出配额时 Windows 将丢弃最早的项。
 - **还原后可能不在原工作区**。插件清除了工作区记账，还原的对话将出现在「未分组」中。如需恢复至原工作区，须在 DSH 停止运行时手工编辑 `~/.dsh/storages/workspace.json`。
 - **附件不予回收**。DSH 附件按内容寻址、跨会话共享，且无引用计数，插件无法安全判断其可否回收。

package/lib/client.js

@@ -94,6 +94,7 @@ 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}",
@@ -170,6 +171,7 @@ 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}",
@@ -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,7 +74,7 @@ function isInside(root, target) {
   const t = resolve(target).toLowerCase();
   return t.startsWith(r + "\\") || t.startsWith(r + "/");
 }
-// 读磁盘的函数一律：读失败返回 ok:false。把「读不出来」当成「磁盘上没有」，会误判活会话。
+// 读磁盘的函数一律在读失败时返回 ok:false。将「读不出来」当作「磁盘上没有」会误判活动会话。
 function findSessionDirs(sessionId) {
   const root = sessionsRoot();
   const variants = idVariants(sessionId);
@@ -98,7 +98,7 @@ function findSessionDirs(sessionId) {
 }
 
 const ZSTD_MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
-// 复用一块头缓冲：readSessionHeader 是同步函数，不会重入；几百个会话逐个 new 会白扔上百 MB。
+// 复用同一块头缓冲：readSessionHeader 为同步函数，不会重入；数百个会话逐个分配将浪费上百 MB。
 const HEAD_BUF = Buffer.allocUnsafe(HEAD_BYTES);
 
 function sessionLogFiles(dir) {
@@ -199,7 +199,7 @@ function collectSessionTree(ctx, sessionId) {
   const childrenOf = new Map();
   for (const entry of byKey.values()) {
     if (protectedKeys.has(entry.id)) continue;
-    // 只收 origin === "subagent"：fork 出来的分叉会话 header 里也有 parentSession，但它是独立对话，绝不能连带删。
+    // 仅收 origin === "subagent"：由 fork 产生的分叉会话 header 中同样有 parentSession，但其属独立对话，不得连带删除。
     if (entry.header?.origin !== "subagent") continue;
     const parent = entry.header?.parentSession;
     if (typeof parent !== "string" || parent.length === 0) continue;
@@ -232,8 +232,8 @@ function collectSessionTree(ctx, sessionId) {
   return { ok: true, dirs };
 }
 
-// 移入回收站要靠系统脚本宿主 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 +241,9 @@ function cscriptPath() {
   }
   return "";
 }
-// 回收站被关掉（NukeOnDelete=1）时 MoveHere 会直接永久删除，与「可还原」的承诺相反 → 先拒绝。
-// 注意：该开关是「按卷」存的（回收站属性按驱动器逐个勾选），根键下通常没有这个值，
-// 故必须先由盘符查到卷 GUID，再读该卷的值；只读根键会让这道闸门形同虚设。
-// 移完后按「原位置 + 名字」回回收站里点名核对，确认真的进去了，而不是被静默永久删掉。
+// 回收站被关闭（NukeOnDelete=1）时 MoveHere 将直接永久删除，与「可还原」的承诺相反，故先行拒绝。
+// 该开关按卷存储（回收站属性按驱动器逐个勾选），根键下通常没有此值，
+// 故须先由盘符查出卷 GUID，再读该卷的值；仅读根键将使此闸门失效。
 function recycleScript(paths, resultFile) {
   return [
     "var paths = " + JSON.stringify(paths) + ";",
@@ -253,7 +252,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 +271,7 @@ function recycleScript(paths, resultFile) {
     "  } catch (err) {}",
     "  return \"\";",
     "}",
-    // 卷级值读不到时退回根键值（旧版 Windows 把开关放在根键）。
+    // 卷级值读不到时退回根键值（旧版 Windows 将该开关置于根键）。
     "function isNukeOn(p) {",
     "  var volKey = volumeKeyOf(p);",
     "  if (volKey !== \"\") {",
@@ -285,10 +284,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 +300,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 +455,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 +487,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 +536,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,8 +566,8 @@ async function removeFromArchiveSet(ctx, sessionId) {
   return removed;
 }
 
-// 三段式：先摘内存（运行中的会话占着文件句柄，不摘就搬不动）→ 再把整棵树一次性移入回收站
-// → 最后清记账。磁盘这一步失败就整体中止，后面的记录一律不动，留给用户重试。
+// 三段式：先摘内存（运行中的会话占用文件句柄，不摘除则无法移动）→ 再将整棵树一次性移入回收站
+// → 最后清理记账。磁盘这一步失败即整体中止，后续记录一律不动，供用户重试。
 async function deleteSessionCore(ctx, sessionId) {
   const tree = collectSessionTree(ctx, sessionId);
   const treeFailed = tree.ok ? null : tree;
@@ -539,7 +626,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 +668,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.1",
   "description": "DSH 插件：在侧栏会话行的「…」菜单中增加「删除对话」与「批量删除…」，将对话及其子代理会话移入 Windows 回收站，可从回收站还原。",
   "keywords": [
     "dsh",