dsh-session-curator 0.2.0 → 0.3.0

package/lib/host/delete.js

@@ -0,0 +1,77 @@
+/**
+ * 危险操作：**物理删除**（不可恢复）。
+ *
+ * 为什么不再是"软删除到回收站"：回收站与归档在做同一件事（把会话从侧边栏藏起来、之后还能
+ * 找回来），而归档是 DSH 自带的机制、不动磁盘、随时可逆。所以删除就做成**真正的删除**：
+ * 删掉 `<DSH_HOME>/sessions/<slug>/<sessionId>/` 与它的投影缓存，不可撤销。想留退路的
+ * 用户在确认弹窗里会被明确提示改用归档。
+ *
+ * 顺序不能随便改（与旧 `purge` 同一条教训）：**先把记账清干净，再删目录**。
+ *   - `archivedSessionIds` / `pinnedSessionIds` 是持久化的集合，删除后还留着 id 就是一条
+ *     "DSH 一直以为它归档着、界面上又找不到"的永久幽灵；
+ *   - 工作区记账（`sessionIds`）同样要摘掉，否则侧边栏的"未分组"里会留一条点不开的幽灵行；
+ *   - 目录最后删。万一 `rm` 失败（占用 / 权限），这一项在 `results[]` 里报失败，会话还在
+ *     磁盘上，只是已经被取消归档 —— 用户仍然看得到它，可以重试，不会凭空丢数据。
+ *
+ * 正在跑的会话与**当前正在使用的会话**一律拒绝删除：前者由官方的
+ * `workspace/session-activity` 判定（与官方归档同一条判据），后者是
+ * `process.env.DSH_SESSION_ID`。
+ */
+import { promises as fsp } from "node:fs";
+import { messageOf } from "./fs-utils.js";
+import { projCacheFile } from "./paths.js";
+/**
+ * 逐项物理删除：会话目录 + 投影缓存，并把归档 / 置顶 / 工作区三处记账清干净。
+ *
+ * 单项失败只留在 `results[]` 里，不影响其余项（`each()` 的语义）。
+ */
+export async function deleteSessions(host, ids) {
+    const dirs = await host.scanSessionDirs();
+    return host.each(ids, async (sessionId) => {
+        const steps = [];
+        if (sessionId === process.env.DSH_SESSION_ID) {
+            throw new Error("这是当前正在使用的会话，不能删除");
+        }
+        const activity = await host.sessionActivity(sessionId);
+        if (activity.length > 0)
+            throw new Error("会话正在运行，请先停止它");
+        const info = dirs.get(sessionId);
+        if (!info)
+            throw new Error("找不到会话日志目录（可能已被删除）");
+        // 三处记账先清：见文件头"顺序不能随便改"。
+        if (host.registry.archivedSessionIds.includes(sessionId)) {
+            await host.registry.unarchiveSession(sessionId);
+            steps.push("unarchive");
+        }
+        if (host.registry.pinnedSessionIds.includes(sessionId)) {
+            await host.registry.unpinSession(sessionId);
+            steps.push("unpin");
+        }
+        const workspace = host.findWorkspaceOf(sessionId);
+        if (workspace) {
+            try {
+                if (typeof workspace.detachSession === "function") {
+                    await workspace.detachSession(sessionId);
+                    steps.push("detach");
+                }
+            }
+            catch (error) {
+                // 摘不掉记账不该阻止删除：目录没了之后 DSH 自己也会把它清掉。
+                steps.push(`detach-failed:${messageOf(error)}`);
+            }
+        }
+        // 会话目录整个删掉（这是唯一不可逆的一步）。
+        await fsp.rm(info.dir, { recursive: true, force: true });
+        steps.push("delete");
+        // 投影缓存是 DSH 自己的文件（`storages/session_projcache/sessions/<id>.json`）：
+        // 会话都没了，留着一份标题 / cwd 的缓存只会在下次重建列表时对不上。
+        try {
+            await fsp.rm(projCacheFile(sessionId), { force: true });
+            steps.push("projcache");
+        }
+        catch {
+            // 缓存删不掉不影响会话本身
+        }
+        return steps;
+    });
+}

package/lib/host/fs-utils.js

@@ -1,6 +1,6 @@
 /** 文件系统小工具 + 错误消息归一化。 */
 import { promises as fsp } from "node:fs";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 /** 任何抛出物 → 一句人话（宿主 logger 与端点错误信封都用它）。 */
 export function messageOf(error) {
     if (error instanceof Error)
@@ -31,20 +31,6 @@ export async function mapLimit(items, limit, worker) {
     await Promise.all(Array.from({ length: width }, run));
     return results;
 }
-/** 跨卷 rename 会抛 EXDEV，退回 copy + rm。 */
-export async function moveDir(from, to) {
-    await fsp.mkdir(dirname(to), { recursive: true });
-    try {
-        await fsp.rename(from, to);
-        return;
-    }
-    catch (error) {
-        if (error?.code !== "EXDEV")
-            throw error;
-    }
-    await fsp.cp(from, to, { recursive: true, force: true });
-    await fsp.rm(from, { recursive: true, force: true });
-}
 const DIR_STATS_CACHE = new Map();
 /** 缓存上限：超过就整个清掉。磁盘目录数远小于它，这里只是防止长期运行无限增长。 */
 const DIR_STATS_CACHE_LIMIT = 2000;

package/lib/host/open.js

@@ -3,9 +3,9 @@
  *
  * 安全边界（这一段是这个文件存在的全部理由）：
  *   - 路径**不接受客户端传**：只吃 `sessionId`，由宿主自己按 `<DSH_HOME>/sessions/<slug>/<id>`
- *     或回收站目录拼出来。客户端就算传了别的路径也没用 —— 入参里根本没有路径字段。
- *   - 拼出来之后再 `resolve()` 一次并断言它落在**允许的两个根**（`<DSH_HOME>/sessions`、
- *     回收站根）之下。这一道是为了挡住 `../` 之类的 id（线协议的 `idsOf()` 只保证是
+ *     拼出来。客户端就算传了别的路径也没用 —— 入参里根本没有路径字段。
+ *   - 拼出来之后再 `resolve()` 一次并断言它落在**允许的根**（`<DSH_HOME>/sessions`）
+ *     之下。这一道是为了挡住 `../` 之类的 id（线协议的 `idsOf()` 只保证是
  *     非空字符串，不保证它不是一个相对路径）。
  *   - 只有 `target: "reveal"` 才会真的去叫系统文件管理器，而且只用**固定的可执行名**
  *     （`explorer.exe` / `open` / `xdg-open`），参数是那个已经校验过的目录。不拼 shell 字符串，
@@ -20,17 +20,17 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { resolve, sep } from "node:path";
 import { messageOf } from "./fs-utils.js";
-import { sessionsRoot, trashRoot } from "./paths.js";
+import { sessionsRoot } from "./paths.js";
 /** `path` / `reveal`：`reveal` 之外的任何值都当成 `path`（只读，最保守的那条）。 */
 export function openTargetOf(value) {
     return value === "reveal" ? "reveal" : "path";
 }
 /**
- * 两个允许的根：会话目录与回收站。`resolve()` 之后比较，且要求"相等或以 `<root>+分隔符`
+ * 允许的根：整个会话目录。`resolve()` 之后比较，且要求"相等或以 `<root>+分隔符`
  * 开头" —— 单比 `startsWith(root)` 会把 `<DSH_HOME>/sessions-evil` 放进来。
  */
 function allowedRoots() {
-    return [resolve(sessionsRoot()), resolve(trashRoot())];
+    return [resolve(sessionsRoot())];
 }
 function inside(root, target) {
     return target === root || target.startsWith(root.endsWith(sep) ? root : root + sep);
@@ -69,22 +69,16 @@ function reveal(path) {
 /**
  * `open` 端点：算路径 → 校验 → （可选）叫文件管理器。
  *
- * `sessionId` 必须能在磁盘或回收站里找到；找不到就抛错，由信封兜住（与 `describe` 一致）。
+ * `sessionId` 必须能在磁盘上找到；找不到就抛错，由信封兜住（与 `describe` 一致）。
  */
 export async function openSession(host, ids, target) {
     const sessionId = ids[0];
     if (typeof sessionId !== "string" || sessionId === "")
         throw new Error("缺少会话 id");
-    // 磁盘优先，其次回收站：同一个 id 不可能同时在两处（删除时目录被搬走了）。
     const dirs = await host.scanSessionDirs();
-    let path = dirs.get(sessionId)?.dir ?? null;
-    if (path === null) {
-        const inTrash = resolve(trashRoot(), sessionId);
-        if (existsSync(inTrash))
-            path = inTrash;
-    }
+    const path = dirs.get(sessionId)?.dir ?? null;
     if (path === null)
-        throw new Error("找不到这个会话的日志目录（磁盘和回收站里都没有）");
+        throw new Error("找不到这个会话的日志目录（磁盘上不存在）");
     const resolved = resolve(path);
     const roots = allowedRoots();
     if (!roots.some((root) => inside(root, resolved))) {

package/lib/host/paths.js

@@ -25,20 +25,12 @@ export function dshHomePath(...segments) {
     return join(resolveDshHome(), ...segments);
 }
 /**
- * 回收站根目录：`<DSH_HOME>/storages/session-manager/trash`。
- *
- * 这里的 `session-manager` 是**故意不改的旧名**：插件从 `dsh-session-manager` 改名成
- * `dsh-session-curator` 时，回收站里可能还躺着用户已经删掉的会话（本机就有一个）——
- * 改路径会把它们变成孤儿。数据目录用历史名、其余 id 用新名，是权衡后的结果。
+ * 历史遗留：本插件 0.2.0 之前把"软删除"的会话搬到
+ * `<DSH_HOME>/storages/session-manager/trash`（目录名 `session-manager` 是更早的包名）。
+ * 回收站功能已在 0.3.0 移除，删除改成物理删除，所以插件**不再读写**那个目录：
+ * 里面可能还有用户当年软删除的会话，插件不主动迁移也不删除它们；需要时人工把
+ * `trash/<sessionId>/` 搬回 `sessions/<slug>/<sessionId>/` 即可。
  */
-export const TRASH_SUBPATH = ["storages", "session-manager", "trash"];
-/** 回收站条目的元数据：原 slug / cwd / 标题 / 删除时间 / 删除前是否已归档。 */
-export const META_FILE = "__trash.json";
-/** 从投影缓存搬进来的那份文件（恢复时要搬回原位）。 */
-export const PROJ_FILE = "__projcache.json";
-export function trashRoot() {
-    return dshHomePath(...TRASH_SUBPATH);
-}
 export function sessionsRoot() {
     return dshHomePath("sessions");
 }

package/lib/host/routes.js

@@ -1,5 +1,5 @@
 /**
- * 传输 / 分发：十一个端点 → 十一条精确 Fetch 路由。
+ * 传输 / 分发：十个端点 → 十条精确 Fetch 路由。
  *
  * ── 为什么**不用** `ctx.connection.rpc.handle()`（踩过的坑，改回去之前先读）──
  *
@@ -36,12 +36,8 @@ export const ENDPOINTS = {
     unarchive: (manager, payload) => manager.unarchive(payload.ids ?? []),
     pin: (manager, payload) => manager.pin(payload.ids ?? []),
     unpin: (manager, payload) => manager.unpin(payload.ids ?? []),
-    trash: (manager, payload) => manager.trash(payload.ids ?? []),
-    restore: (manager, payload) => manager.restore(payload.ids ?? []),
-    purge: (manager, payload) => manager.purge(payload.ids ?? []),
-    // 保留策略的两条都只吃 `days`（不是 id 列表）：预览只读，清理是永久删除。
-    "trash-stats": (manager, payload) => manager.trashStats(daysOf(payload)),
-    "purge-older-than": (manager, payload) => manager.purgeOlderThan(daysOf(payload)),
+    // 物理删除：不可恢复，确认弹窗由客户端把关（见 components/dialog-host.ts）。
+    delete: (manager, payload) => manager.delete(payload.ids ?? []),
     // 磁盘占用视图（只读）与"复制路径 / 在资源管理器中显示"。
     usage: (manager) => manager.usage(),
     // `target` 只认字面量 `"reveal"`；其余一律当 `"path"`（只读，最保守的那条）。
@@ -52,19 +48,6 @@ export const ENDPOINTS = {
 export function idsOf(payload) {
     return Array.isArray(payload.ids) ? payload.ids.filter((value) => typeof value === "string" && value !== "") : [];
 }
-/**
- * 保留天数：越界 / 非数字一律退回 **30 天**（界面的默认值）。
- *
- * 这里只做"是不是个正常数字"的粗校验，真正的夹取在 `retention.ts` 的
- * `retentionCutoff()`（预览与真删共用那一份）。为什么退回 30 而不是 0：`0` 会让截止时间
- * 变成"此刻"，等于把整个回收站当成过期 —— 缺字段的请求绝不能有这种后果。
- */
-export function daysOf(payload) {
-    const value = payload.days;
-    if (typeof value !== "number" || !Number.isFinite(value))
-        return 30;
-    return Math.min(Math.max(Math.floor(value), 1), 3650);
-}
 /**
  * 一个端点处理器。返回 Connection 的固定信封：处理器自身的业务失败走
  * `{ok:false, error}`，端点内部的逐项失败则留在 `value.results` 里。

package/lib/host/session-manager.js

@@ -1,17 +1,16 @@
 /**
  * 会话管理器：**只读投影**（快照 / 标题 / 体积）+ 归档 / 置顶这类轻量变更。
  *
- * 危险操作（软删除 / 恢复 / 永久删除）在 `trash.ts` 里，那边带完整的事故注释；
+ * 危险操作（物理删除）在 `delete.ts` 里，那边带完整的事故注释；
  * 这里只负责把磁盘与 registry 的事实汇总成快照，以及逐项执行的框架 `each()`。
  */
 import { promises as fsp } from "node:fs";
 import { join } from "node:path";
 import { dirStats, mapLimit, messageOf, readProjectionFile } from "./fs-utils.js";
-import { META_FILE, dshHomePath, projCacheFile, sessionsRoot, trashRoot } from "./paths.js";
+import { dshHomePath, projCacheFile, sessionsRoot } from "./paths.js";
 import { LOCAL_VERSION } from "./manifest.js";
 import { checkForUpdate } from "./update.js";
-import { purgeOlderThan, purgeSessions, restoreSessions, trashSessions } from "./trash.js";
-import { isExpired, retentionCutoff } from "./retention.js";
+import { deleteSessions } from "./delete.js";
 import { openSession } from "./open.js";
 /**
  * 文件系统侧的并发上限。快照一次要给上百个目录做 `readdir` + `stat`，串行 await 会让
@@ -109,67 +108,23 @@ export class SessionManager {
             active
         };
     }
-    async listTrash() {
-        const root = trashRoot();
-        let entries;
-        try {
-            entries = await fsp.readdir(root, { withFileTypes: true });
-        }
-        catch {
-            return [];
-        }
-        // 每条都要读 `__trash.json` + 遍历目录：串行时条目一多就明显卡（回收站常驻几十条）。
-        // 这里**故意**用最宽松的读法（坏 JSON / 缺字段 / 连版本都比插件新，都只是"字段缺失"）：
-        // 一次列表不该因为某一条元数据坏了就整个炸掉。要按 schema 校验、并且会拒绝未知版本的是
-        // `trash.ts` 的 `readTrashMeta()`（恢复那条路，见那边的注释）。
-        const rows = await mapLimit(entries.filter((entry) => entry.isDirectory()), FS_CONCURRENCY, async (entry) => {
-            const dir = join(root, entry.name);
-            let meta = null;
-            try {
-                meta = JSON.parse(await fsp.readFile(join(dir, META_FILE), "utf8"));
-            }
-            catch {
-                meta = null;
-            }
-            const stats = await this.dirStats(dir);
-            return {
-                sessionId: entry.name,
-                title: typeof meta?.title === "string" && meta.title !== "" ? meta.title : entry.name,
-                cwd: typeof meta?.cwd === "string" ? meta.cwd : null,
-                slug: typeof meta?.slug === "string" ? meta.slug : null,
-                // 与 describeSession 对齐：客户端按"原来的工作区文件夹"分组要用到这两个字段。
-                workspaceId: typeof meta?.workspaceId === "string" ? meta.workspaceId : null,
-                workspaceTitle: typeof meta?.workspaceTitle === "string" ? meta.workspaceTitle : null,
-                deletedAt: typeof meta?.deletedAt === "number" ? meta.deletedAt : 0,
-                bytes: stats.bytes,
-                files: stats.files,
-                restorable: typeof meta?.slug === "string" && meta.slug !== ""
-            };
-        });
-        rows.sort((left, right) => right.deletedAt - left.deletedAt);
-        return rows;
-    }
-    /** 当前归档 / 置顶 / 回收站的完整快照，附带目录位置。 */
+    /** 当前归档 / 置顶的完整快照，附带目录位置。 */
     async buildSnapshot() {
         const registry = this.registry;
-        // 三个只读来源互不依赖：目录索引（哪些 id 在磁盘上）、回收站清单、registry 记账。
-        const [dirs, trashed] = await Promise.all([this.scanSessionDirs(), this.listTrash()]);
-        // 回收站条目**只**归回收站页签。删除时我们故意让 id 留在归档集合里（那是 DSH
-        // 唯一"从所有分组面消失"的机制，见 trash.ts），所以这里必须把交集滤掉：
-        // 否则同一个会话会同时出现在"已归档"和"回收站"，而"已归档"那条还是没有目录的幽灵行。
-        const inTrash = new Set(trashed.map((row) => row.sessionId));
+        // 目录索引（哪些 id 真的在磁盘上）是唯一的只读来源；registry 记账可能包含已经删掉的 id。
+        const dirs = await this.scanSessionDirs();
         const archivedIds = [];
         for (const sessionId of registry.archivedSessionIds) {
-            // 顺带把"目录已经不在了"的 id 也滤掉：`archivedSessionIds` 是**只增不减**的记账
+            // 把"目录已经不在了"的 id 滤掉：`archivedSessionIds` 是**只增不减**的记账
             //（DSH 自己的注释：目录没了的条目照样留在集合里），而 DSH 的侧边栏只从会话清单里
             // 取行 —— 这种 id 在它那边本来就不显示。列出来只会得到一条 0 B、点不动的幽灵行。
-            if (inTrash.has(sessionId) || !dirs.has(sessionId))
+            if (!dirs.has(sessionId))
                 continue;
             archivedIds.push(sessionId);
         }
         const pinnedIds = [];
         for (const sessionId of registry.pinnedSessionIds) {
-            if (inTrash.has(sessionId) || !dirs.has(sessionId))
+            if (!dirs.has(sessionId))
                 continue;
             pinnedIds.push(sessionId);
         }
@@ -184,23 +139,16 @@ export class SessionManager {
         let archivedBytes = 0;
         for (const row of archived)
             archivedBytes += row.bytes;
-        let trashBytes = 0;
-        for (const row of trashed)
-            trashBytes += row.bytes;
         return {
             dshHome: dshHomePath(),
             version: LOCAL_VERSION,
-            trashDir: trashRoot(),
             sessionsDir: sessionsRoot(),
             archived,
             pinned,
-            trashed,
             totals: {
                 archived: archived.length,
                 archivedBytes,
-                pinned: pinned.length,
-                trashed: trashed.length,
-                trashBytes
+                pinned: pinned.length
             },
             activeSessionIds: [...activeIds]
         };
@@ -220,14 +168,14 @@ export class SessionManager {
         return this.buildSnapshot();
     }
     /**
-     * **单个**会话的完整事实（第十个端点，侧边栏 hover 卡片用）。
+     * **单个**会话的完整事实（侧边栏 hover 卡片用）。
      *
      * 入参复用 `ids`（线协议的 `idsOf()` 只接受字符串数组）：取第一条，其余忽略 ——
      * hover 卡片一次只问一个会话，把它做成批量端点没有意义。
      *
      * 客户端的 hover 会在 800ms 之后触发、且**每次划过都会问**，所以这里刻意只做
-     * `listTrash()` + `scanSessionDirs()` + 单条 `dirStats()`，不做全量快照；
-     * 端到端的节流由客户端那份带 TTL 的缓存负责（`src/client/detail.ts`）。
+     * `scanSessionDirs()` + 单条 `dirStats()`，不做全量快照；端到端的节流由客户端那份
+     * 带 TTL 的缓存负责（`src/client/detail.ts`）。
      */
     async describe(ids) {
         const sessionId = ids[0];
@@ -236,46 +184,14 @@ export class SessionManager {
         const registry = this.registry;
         const archived = registry.archivedSessionIds.includes(sessionId);
         const pinned = registry.pinnedSessionIds.includes(sessionId);
-        // 活动判定与回收站清单互不依赖：一起等。回收站里的条目不可能正在跑（目录都搬走了），
-        // 所以只有磁盘上那条路要用它的结果。
-        const [trashed, activeList] = await Promise.all([
-            this.listTrash().then((rows) => rows.find((row) => row.sessionId === sessionId)),
-            this.sessionActivity(sessionId)
-        ]);
-        const active = activeList.length > 0;
-        if (trashed) {
-            return {
-                sessionId,
-                title: trashed.title,
-                cwd: trashed.cwd,
-                workspaceId: trashed.workspaceId,
-                workspaceTitle: trashed.workspaceTitle,
-                slug: trashed.slug,
-                // `__trash.json` 只记删除时间，恢复时才用得上创建时间，所以这里不硬凑。
-                createdAt: null,
-                bytes: trashed.bytes,
-                files: trashed.files,
-                onDisk: false,
-                archived,
-                pinned,
-                // 回收站条目：目录已经搬走，谈不上"正在跑"。
-                active: false,
-                trashed: true,
-                deletedAt: trashed.deletedAt,
-                restorable: trashed.restorable
-            };
-        }
         const dirs = await this.scanSessionDirs();
         if (!dirs.has(sessionId))
             throw new Error("找不到这个会话（日志目录不在磁盘上）");
-        const row = await this.describeSession(sessionId, dirs, active);
+        const row = await this.describeSession(sessionId, dirs, (await this.sessionActivity(sessionId)).length > 0);
         return {
             ...row,
             archived,
-            pinned,
-            trashed: false,
-            deletedAt: null,
-            restorable: false
+            pinned
         };
     }
     /** 逐个执行，单项失败只记录在 results 里，不影响其余项。 */
@@ -318,41 +234,9 @@ export class SessionManager {
             return [];
         }
     }
-    // ── 危险操作：实现在 trash.ts（那边有完整的事故注释） ─────────────────
-    trash(ids) {
-        return trashSessions(this, ids);
-    }
-    restore(ids) {
-        return restoreSessions(this, ids);
-    }
-    purge(ids) {
-        return purgeSessions(this, ids);
-    }
-    /**
-     * 回收站保留策略的**预览**（只读）：多少条、多少字节会被"清理 N 天前"带走。
-     *
-     * 只统计**真正能清掉**的条目 —— 老版本留下的、没有 `__trash.json`（`deletedAt` 为 0 或
-     * 缺 slug）的条目不算在内：它们连删除时间都不知道，`purge-older-than` 也一定会跳过，
-     * 预览要是把它们算进去，用户点确认后就会发现"说好的 5 条只删了 3 条"。
-     */
-    async trashStats(days) {
-        const rows = await this.listTrash();
-        const cutoff = retentionCutoff(days);
-        let count = 0;
-        let bytes = 0;
-        let totalBytes = 0;
-        for (const row of rows) {
-            totalBytes += row.bytes;
-            if (isExpired(row, cutoff)) {
-                count += 1;
-                bytes += row.bytes;
-            }
-        }
-        return { days, cutoff, count, bytes, totalCount: rows.length, totalBytes };
-    }
-    /** 「清理 N 天前」：与预览同一套判据，逐项失败不影响其余项。 */
-    purgeOlderThan(days) {
-        return purgeOlderThan(this, days);
+    // ── 危险操作：物理删除，实现在 delete.ts（那边有完整的事故注释） ─────
+    delete(ids) {
+        return deleteSessions(this, ids);
     }
     /** 复制路径 / 在资源管理器中显示（实现在 `open.ts`，那边有完整的路径校验注释）。 */
     open(ids, target) {
@@ -364,16 +248,15 @@ export class SessionManager {
      * 与 `buildSnapshot()` 的关系：两者都读同一批目录，`dirStats()` 的 mtime 缓存让重复的
      * 目录遍历只有第一次真的走磁盘；快照刚刚跑过的那批（归档 / 置顶）在这里直接命中缓存。
      *
-     * 为什么要有这条端点而不是让客户端从快照里算：快照只有三个集合，**普通会话**（正在用的
+     * 为什么要有这条端点而不是让客户端从快照里算：快照只有两个集合，**普通会话**（正在用的
      * 那些）根本不在里面 —— 而"哪些会话最占地方"恰恰要问全部。
      *
-     * 聚合按会话**当前所在的文件夹**（回收站条目用 `__trash.json` 里的原 cwd）：
-     * 与列表分组同一套键，用户看到的"工作区"是同一个东西。
+     * 聚合按会话**当前所在的文件夹**（投影缓存里的 cwd）：与列表分组同一套键，用户看到的
+     * "工作区"是同一个东西。
      */
     async usage() {
         const registry = this.registry;
-        const [dirs, trashed] = await Promise.all([this.scanSessionDirs(), this.listTrash()]);
-        // 磁盘上的会话 + 回收站里的会话 = 全部会话（两边 id 不会重合，删除时目录已经搬走了）。
+        const dirs = await this.scanSessionDirs();
         const onDiskIds = [...dirs.keys()];
         const activeIds = await this.activeAmong(onDiskIds);
         const rows = [];
@@ -390,30 +273,11 @@ export class SessionManager {
                 bytes: described.bytes,
                 files: described.files,
                 createdAt: described.createdAt,
-                deletedAt: null,
                 archived: registry.archivedSessionIds.includes(sessionId),
                 pinned: registry.pinnedSessionIds.includes(sessionId),
-                trashed: false,
                 active: described.active
             });
         });
-        for (const row of trashed) {
-            push({
-                sessionId: row.sessionId,
-                title: row.title,
-                cwd: row.cwd,
-                workspaceTitle: row.workspaceTitle,
-                bytes: row.bytes,
-                files: row.files,
-                createdAt: null,
-                deletedAt: row.deletedAt > 0 ? row.deletedAt : null,
-                archived: registry.archivedSessionIds.includes(row.sessionId),
-                pinned: false,
-                trashed: true,
-                // 目录都搬进回收站了，谈不上"正在跑"。
-                active: false
-            });
-        }
         let totalBytes = 0;
         const groups = new Map();
         for (const row of rows) {
@@ -437,7 +301,6 @@ export class SessionManager {
         return {
             totalSessions: rows.length,
             totalBytes,
-            onDiskSessions: onDiskIds.length,
             groups: [...groups.values()].sort((left, right) => right.bytes - left.bytes),
             largest,
             oldest

package/lib/index.js

@@ -2,15 +2,12 @@
  * dsh-session-curator — host 半区入口。
  *
  * 提供三块能力：
- *   1. 会话软删除：先把会话**藏起来**（进 registry-global 的归档集合 —— DSH 里唯一能让它
- *      从侧边栏所有分组面消失的机制，否则它会以"未分组"的幽灵行留在那里），再把它从
- *      工作区记账里摘掉（`Workspace.detachSession`），最后把
- *      `<DSH_HOME>/sessions/<slug>/<sessionId>/` 整个搬到
- *      `<DSH_HOME>/storages/session-manager/trash/<sessionId>/`。可完整恢复。
- *      ⚠️ 目录名 `session-manager` 是**故意保留的旧名**（见 host/paths.ts）。
- *   2. 回收站管理：列出 / 恢复 / 永久删除。
- *   3. 归档会话管理：列出全部归档会话（标题、目录、体积），支持批量取消归档、置顶，
- *      以及直接删除。归档/取消归档/置顶全部走官方 `ctx.workspaceRegistry`。
+ *   1. 会话删除：**物理删除**（不可恢复）—— 先清掉归档 / 置顶 / 工作区三处记账，再删掉
+ *      `<DSH_HOME>/sessions/<slug>/<sessionId>/` 与它的投影缓存。想留退路的用户走归档：
+ *      归档同样能让会话从侧边栏消失，而且随时能找回来。
+ *   2. 归档会话管理：列出全部归档会话（标题、目录、体积），支持批量取消归档、置顶、删除。
+ *   3. 置顶会话管理：同一套列表与动作；归档 / 取消归档 / 置顶全部走官方 `ctx.workspaceRegistry`。
+ *      另有三个辅助端点：磁盘占用视图（只读）、复制路径 / 在资源管理器中显示、更新检查。
  *
  * 对客户端暴露一组挂在共享 `/api` 通道下的精确 Fetch 路由（
  * `ctx.connection.fetch.register`）：信任检查与会话鉴权由 Connection 的 `/api`
@@ -33,6 +30,5 @@ export function apply(ctx) {
 // 纯函数 / 纯工具，给 `scripts/smoke.mjs` 直接单测（插件运行时用不到）。
 export { compareVersions } from "./host/update.js";
 export { dirStats, forgetDirStats } from "./host/fs-utils.js";
-export { isExpired, retentionCutoff } from "./host/retention.js";
 // `open` 的路径校验单独导出：自检要直接断言那道判据，不必真的去调系统 shell。
 export { insideRoot } from "./host/open.js";

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Session manager",
-    "description": "Soft-delete sessions to a trash and manage archived or pinned ones, grouped by their original workspace folder."
+    "description": "Permanently delete sessions and manage archived or pinned ones, grouped by their original workspace folder."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "会话管理",
-    "description": "删除会话（软删除到回收站）并管理已归档 / 已置顶的会话，按原来的工作区文件夹分组。"
+    "description": "永久删除会话，并管理已归档 / 已置顶的会话，按原来的工作区文件夹分组。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-session-curator",
-  "version": "0.2.0",
-  "description": "DeepSeek Harness plugin: soft-delete sessions to a recoverable trash and manage archived/pinned ones, grouped by their original workspace folder. | DSH 插件：会话软删除到可恢复的回收站，并按原来的工作区文件夹管理已归档 / 已置顶会话。",
+  "version": "0.3.0",
+  "description": "DeepSeek Harness plugin: permanently delete sessions and manage archived/pinned ones, grouped by their original workspace folder. | DSH 插件：永久删除会话，并按原来的工作区文件夹管理已归档 / 已置顶会话。",
   "type": "module",
   "main": "lib/index.js",
   "icon": "./icon.svg",
@@ -43,8 +43,7 @@
     "session-management",
     "curator",
     "archive",
-    "trash",
-    "soft-delete",
+    "delete",
     "workspace",
     "i18n"
   ],
@@ -119,7 +118,8 @@
     "build": "node scripts/build.mjs",
     "typecheck": "tsc -p tsconfig.host.json && tsc -p tsconfig.client.json",
     "test": "pnpm run build && node scripts/artifact.mjs && node scripts/client.mjs && node scripts/smoke.mjs && node scripts/activation.mjs",
-    "check": "pnpm run typecheck && pnpm run format:check && node --check lib/index.js && node --check lib/client.js && node --check scripts/artifact.mjs && node --check scripts/check-profile.mjs && node --check scripts/client.mjs",
+    "check": "pnpm run typecheck && pnpm run format:check && node --check lib/index.js && node --check lib/client.js && node --check scripts/artifact.mjs && node --check scripts/check-profile.mjs && node --check scripts/client.mjs && node --check scripts/lib-sync.mjs",
+    "check:lib": "node scripts/lib-sync.mjs",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "release": "node scripts/release.mjs",

package/lib/host/retention.js

@@ -1,24 +0,0 @@
-/**
- * 保留天数 → 截止时间戳：**严格早于**它的条目才算过期。
- *
- * 上限 3650 天（10 年）只是防呆：`days` 来自线协议，客户端算错、或有人手工构造请求时，
- * 别让它退化成"把整个回收站清空"；`NaN` / 负数一律夹到 1 天（而不是 0：0 会让截止时间
- * 变成"此刻"，语义上等于清空）。
- */
-export function retentionCutoff(days) {
-    const safe = Number.isFinite(days) ? Math.min(Math.max(Math.floor(days), 1), 3650) : 1;
-    return Date.now() - safe * 24 * 60 * 60 * 1000;
-}
-/**
- * 一条回收站条目该不该被"清理 N 天前"带走。
- *
- * 三个条件缺一不可：
- *   - `restorable`：老版本留下的、没有 `__trash.json` 的条目连原 slug 都不知道，
- *     `deletedAt` 也就无从谈起（`listTrash()` 会给它 0）。它们只能由用户在界面上
- *     逐条「永久删除」，绝不能被一个按时间的批量操作顺手带走；
- *   - `deletedAt > 0`：同上，缺删除时间的条目不参与时间判断；
- *   - `deletedAt < cutoff`：**严格**早于截止时间，边界那一条留着。
- */
-export function isExpired(row, cutoff) {
-    return row.restorable && row.deletedAt > 0 && row.deletedAt < cutoff;
-}