dsh-plugin-session-tidy 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,35 @@
-# Temporary Holding Version
+# dsh-plugin-session-tidy
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+清理 DSH **会话文件**——官方只提供「归档」，磁盘上的 session 文件仍在，长年积累。
+
+## 功能
+
+- **会话行右键菜单**：删除单个会话
+- **侧边栏底部批量面板**：多选 → 移到 `sessions-trash` → 可再清空
+- 删除是**移到回收区**（可恢复）；清空才真删
+
+## 安全设计
+
+- 破坏性操作有**二次确认**（按住 Ctrl 可跳过，适合批量场景）
+- 只动会话文件，不碰配置/凭据
+
+## 安装
+
+Junction 方式（同其它插件）+ profile 的 `cordis.patch.yml`：
+
+```yaml
+- insert:
+    - id: session-tidy
+      name: 'dsh-plugin-session-tidy'
+```
+
+> 本插件原名 `session-cleaner`；因 npm 上已有同名包（他人），开源版统一改名为 `dsh-plugin-session-tidy`（含内部插件 id / 路由 / 快捷键）。
+
+## 适配
+
+- DSH **0.2.2-rc.1+** · 零运行时依赖
+- client + host 双入口
+
+## License
+
+MIT

package/lib/client.js

@@ -0,0 +1,494 @@
+// dsh-plugin-session-tidy -- client 侧
+//
+// 入口：侧边栏底部动作区（sidebar.footer.action）
+// 能力：列出会话（按工作区分组）→ 勾选 → 二次确认 → 移到回收目录 → 可再清空
+//
+// 样式照抄官方：只用 --dsw-* 变量，全程不用 !important，类名带 sc_ 前缀。
+// 不 require 任何 Harness Client 包（官方明令）。
+
+window.__ModuleLoader__.load({
+    id: 'dsh-plugin-session-tidy',
+    factory: (require) => {
+        var module = { exports: {} };
+        var exports = module.exports;
+        Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+        let react = require('react');
+        let reactDom = require('react-dom');
+
+        // 官方 primitive：MenuItemButton 自带宿主菜单项样式（图标位、缩进、hover、快捷键槽）。
+        // 据 dsh-client-ui-workspace README：Module Loader 包可经 loader 的 require 解析它，
+        // 但【不要打包副本、不要列为运行时依赖】。取不到就降级自绘，绝不让菜单崩。
+        // 快捷键（全局）与面板之间的桥：由侧边栏入口在挂载时登记
+        let openPanelBridge = null;
+
+        let MenuItemButton = null;
+        try {
+            const prim = require('@deepseek-ai/dsh-client-ui-primitives');
+            if (prim && typeof prim.MenuItemButton === 'function') {
+                MenuItemButton = prim.MenuItemButton;
+                console.log('[session-tidy] ✅ 官方 primitive 就绪：菜单项用 MenuItemButton（官方样式）');
+            } else {
+                console.log('[session-tidy] primitives 能加载但没有 MenuItemButton，降级自绘');
+            }
+        } catch (e) {
+            console.log('[session-tidy] MenuItemButton 取不到，降级自绘: ' + ((e && e.message) || e));
+        }
+
+        const NS = 'sc';
+        const SHORTCUT_ID = 'session-tidy.open';
+        const CSS_TAG_ID = 'dsh-plugin-session-tidy/client.css';
+
+        const CSS = [
+            '.' + NS + '_btn{',
+            'box-sizing:border-box;color:var(--dsw-alias-label-tertiary);font:inherit;',
+            'background:0 0;border:none;border-radius:8px;cursor:pointer;',
+            'align-items:center;gap:6px;padding:4px 8px;display:inline-flex;width:100%;text-align:left}',
+            '.' + NS + '_btn:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary)}',
+            '.' + NS + '_mask{position:fixed;inset:0;background:rgba(0,0,0,.45);z-index:9000}',
+            '.' + NS + '_panel{',
+            'position:fixed;left:50%;top:50%;transform:translate(-50%,-50%);z-index:9001;',
+            'width:min(760px,92vw);max-height:82vh;display:flex;flex-direction:column;',
+            'background:var(--dsw-alias-bg-base,#1b1b1f);color:var(--dsw-alias-label-primary,#e8e8ea);',
+            'border:1px solid var(--dsw-alias-border-secondary,rgba(255,255,255,.12));border-radius:12px;',
+            'box-shadow:0 12px 40px rgba(0,0,0,.5);font-size:13px;line-height:20px;overflow:hidden}',
+            '.' + NS + '_head{padding:14px 16px 10px;border-bottom:1px solid var(--dsw-alias-border-secondary,rgba(255,255,255,.1))}',
+            '.' + NS + '_title{font-size:15px;font-weight:600;display:flex;justify-content:space-between;align-items:center}',
+            '.' + NS + '_sub{color:var(--dsw-alias-label-tertiary);font-size:12px;margin-top:4px}',
+            '.' + NS + '_body{overflow:auto;padding:8px 16px;flex:1;min-height:80px}',
+            '.' + NS + '_ws{margin:10px 0 4px;color:var(--dsw-alias-label-secondary);font-weight:600}',
+            '.' + NS + '_wsPath{color:var(--dsw-alias-label-tertiary);font-weight:400;font-size:12px;margin-left:6px}',
+            '.' + NS + '_row{display:flex;align-items:center;gap:8px;padding:3px 0}',
+            '.' + NS + '_row label{display:flex;align-items:center;gap:8px;flex:1;min-width:0;cursor:pointer}',
+            '.' + NS + '_row input{cursor:pointer}',
+            '.' + NS + '_id{font-family:ui-monospace,Consolas,monospace;font-size:12px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
+            '.' + NS + '_size{font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-secondary);white-space:nowrap}',
+            '.' + NS + '_tag{font-size:11px;padding:0 6px;border-radius:6px;border:1px solid var(--dsw-alias-border-secondary,rgba(255,255,255,.15));color:var(--dsw-alias-label-tertiary);white-space:nowrap}',
+            '.' + NS + '_lock{color:var(--dsw-alias-state-warning-primary,#d97706);font-size:11px;white-space:nowrap}',
+            '.' + NS + '_foot{padding:10px 16px;border-top:1px solid var(--dsw-alias-border-secondary,rgba(255,255,255,.1));display:flex;gap:8px;align-items:center;justify-content:space-between;flex-wrap:wrap}',
+            '.' + NS + '_act{box-sizing:border-box;border-radius:8px;padding:6px 12px;cursor:pointer;font:inherit;border:1px solid transparent}',
+            '.' + NS + '_ghost{background:0 0;border-color:var(--dsw-alias-border-secondary,rgba(255,255,255,.18));color:var(--dsw-alias-label-secondary)}',
+            '.' + NS + '_ghost:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+            '.' + NS + '_danger{background:var(--dsw-alias-state-error-primary,#dc2626);color:#fff}',
+            '.' + NS + '_danger:disabled{opacity:.45;cursor:not-allowed}',
+            '.' + NS + '_confirm{background:var(--dsw-alias-state-warning-primary,#d97706);color:#fff}',
+            '.' + NS + '_msg{color:var(--dsw-alias-label-tertiary);font-size:12px}',
+            '.' + NS + '_err{color:var(--dsw-alias-state-error-primary,#dc2626);font-size:12px}',
+            // 会话行菜单里的条目：照官方菜单项的样子（整行可点、hover 高亮、不用 !important）
+            '.' + NS + '_mi{box-sizing:border-box;display:flex;align-items:center;gap:8px;width:100%;background:0 0;border:none;color:var(--dsw-alias-label-primary,#e8e8ea);font:inherit;text-align:left;padding:6px 10px;border-radius:6px;cursor:pointer}',
+            '.' + NS + '_mi:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+            '.' + NS + '_miIcon{flex:0 0 auto;opacity:.75}',
+            // 仅在拿不到官方 MenuItemButton 时的兜底（danger 行的等价外观）
+            '.' + NS + '_miDanger{color:var(--dsw-alias-state-error-primary,#dc2626)}',
+        ].join('\n');
+
+        function injectCss() {
+            if (document.getElementById(CSS_TAG_ID)) return;
+            const tag = document.createElement('style');
+            tag.id = CSS_TAG_ID;
+            tag.setAttribute('data-plugin-css', CSS_TAG_ID);
+            tag.textContent = CSS;
+            document.head.appendChild(tag);
+        }
+
+        function fmtBytes(n) {
+            if (!n) return '0 B';
+            if (n < 1024) return n + ' B';
+            if (n < 1024 * 1024) return (n / 1024).toFixed(1) + ' KB';
+            if (n < 1024 * 1024 * 1024) return (n / 1024 / 1024).toFixed(1) + ' MB';
+            return (n / 1024 / 1024 / 1024).toFixed(2) + ' GB';
+        }
+        function fmtTime(ms) {
+            try { return new Date(ms).toLocaleString('zh-CN', { hour12: false }); } catch { return ''; }
+        }
+        const LOCK_TEXT = { active: '运行中', pinned: '已置顶', recent: '刚用过' };
+
+        async function api(path, body) {
+            const opt = body === undefined
+                ? { method: 'GET' }
+                : { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) };
+            const r = await fetch(path, opt);
+            let j = null;
+            try { j = await r.json(); } catch { /* 非 JSON */ }
+            if (!r.ok) throw new Error((j && (j.error || j.message)) || ('HTTP ' + r.status));
+            return j;
+        }
+
+        function Panel(props) {
+            const onClose = props.onClose;
+            const initialPick = props.initialPick || '';
+            const initialConfirming = !!props.initialConfirming;
+            const [loading, setLoading] = react.useState(true);
+            const [err, setErr] = react.useState('');
+            const [data, setData] = react.useState(null);
+            const [picked, setPicked] = react.useState({});   // id -> true
+            const [confirming, setConfirming] = react.useState(false);
+            const [busy, setBusy] = react.useState(false);
+            const [note, setNote] = react.useState('');
+
+            const load = react.useCallback(() => {
+                setLoading(true); setErr('');
+                api('/session-tidy/list')
+                    .then((d) => {
+                        setData(d);
+                        setPicked(initialPick ? { [initialPick]: true } : {});
+                        setConfirming(initialConfirming);
+                    })
+                    .catch((e) => setErr(String(e.message || e)))
+                    .finally(() => setLoading(false));
+            }, []);
+            react.useEffect(() => { load(); }, [load]);
+
+            const sessions = (data && data.sessions) || [];
+            const pickedList = sessions.filter((s) => picked[s.id]);
+            const pickedBytes = pickedList.reduce((n, s) => n + s.bytes, 0);
+
+            const toggle = (id) => setPicked((p) => { const q = Object.assign({}, p); if (q[id]) delete q[id]; else q[id] = true; return q; });
+
+            const groups = react.useMemo(() => {
+                const m = new Map();
+                for (const s of sessions) {
+                    if (!m.has(s.workspace)) m.set(s.workspace, { workspace: s.workspace, path: s.workspacePath, items: [] });
+                    m.get(s.workspace).items.push(s);
+                }
+                return Array.from(m.values());
+            }, [sessions]);
+
+            const pickGroup = (g, on) => setPicked((p) => {
+                const q = Object.assign({}, p);
+                for (const s of g.items) { if (on && !s.lockedBy) q[s.id] = true; else if (!on) delete q[s.id]; }
+                return q;
+            });
+            const pickAll = () => setPicked(() => {
+                const q = {};
+                for (const s of sessions) if (!s.lockedBy) q[s.id] = true;
+                return q;
+            });
+
+            const doDelete = async () => {
+                setBusy(true); setErr('');
+                try {
+                    const r = await api('/session-tidy/delete', {
+                        ids: pickedList.map((s) => ({ id: s.id, workspace: s.workspace })),
+                    });
+                    const moved = (r.moved || []).length;
+                    const refused = (r.failed || []).length;
+                    setNote('已移动 ' + moved + ' 个会话到回收目录' + (refused ? '，' + refused + ' 个被拒绝' : ''));
+                    setConfirming(false);
+                    load();
+                } catch (e) { setErr(String(e.message || e)); }
+                finally { setBusy(false); }
+            };
+
+            const doEmpty = async () => {
+                setBusy(true); setErr('');
+                try {
+                    const r = await api('/session-tidy/empty-trash', {});
+                    setNote('已彻底删除 ' + r.count + ' 个会话 / ' + fmtBytes(r.bytes));
+                    load();
+                } catch (e) { setErr(String(e.message || e)); }
+                finally { setBusy(false); }
+            };
+
+            const rows = [];
+            for (const g of groups) {
+                rows.push(react.createElement('div', { className: NS + '_ws', key: 'ws-' + g.workspace },
+                    g.path || g.workspace,
+                    react.createElement('span', { className: NS + '_wsPath' }, '(' + g.items.length + ')'),
+                    react.createElement('button', {
+                        className: NS + '_act ' + NS + '_ghost',
+                        style: { marginLeft: 8, padding: '1px 6px', fontSize: 11 },
+                        onClick: () => pickGroup(g, true),
+                    }, '选可清理的'),
+                    react.createElement('button', {
+                        className: NS + '_act ' + NS + '_ghost',
+                        style: { marginLeft: 4, padding: '1px 6px', fontSize: 11 },
+                        onClick: () => pickGroup(g, false),
+                    }, '清空勾选')
+                ));
+                for (const s of g.items) {
+                    const locked = !!s.lockedBy;
+                    rows.push(react.createElement('div', { className: NS + '_row', key: s.id },
+                        react.createElement('label', null,
+                            react.createElement('input', {
+                                type: 'checkbox', disabled: locked, checked: !!picked[s.id],
+                                onChange: () => toggle(s.id),
+                            }),
+                            react.createElement('span', { className: NS + '_id' }, s.id),
+                            s.title ? react.createElement('span', { className: NS + '_tag' }, s.title) : null,
+                            s.archived ? react.createElement('span', { className: NS + '_tag' }, '已归档') : null
+                        ),
+                        locked ? react.createElement('span', { className: NS + '_lock' }, LOCK_TEXT[s.lockedBy] || '禁选') : null,
+                        react.createElement('span', { className: NS + '_size' }, fmtBytes(s.bytes)),
+                        react.createElement('span', { className: NS + '_tag' }, fmtTime(s.mtime))
+                    ));
+                }
+            }
+
+            const trash = (data && data.trash) || { count: 0, bytes: 0 };
+
+            return reactDom.createPortal(
+                react.createElement(react.Fragment, null,
+                    react.createElement('div', { className: NS + '_mask', onClick: onClose }),
+                    react.createElement('div', { className: NS + '_panel', role: 'dialog', 'aria-label': '清理会话文件' },
+                        react.createElement('div', { className: NS + '_head' },
+                            react.createElement('div', { className: NS + '_title' },
+                                react.createElement('span', null, '清理会话文件'),
+                                react.createElement('button', { className: NS + '_act ' + NS + '_ghost', onClick: onClose }, '关闭')
+                            ),
+                            react.createElement('div', { className: NS + '_sub' },
+                                loading ? '读取中…'
+                                    : data
+                                        ? '共 ' + sessions.length + ' 个会话 / ' + fmtBytes(data.totalBytes)
+                                          + ' · 可清理 ' + fmtBytes(data.deletableBytes)
+                                          + ' · 置顶 ' + (data.counts ? data.counts.pinned : 0)
+                                          + ' · 运行中 ' + (data.counts ? data.counts.active : 0)
+                                        : ''
+                            )
+                        ),
+                        react.createElement('div', { className: NS + '_body' },
+                            err ? react.createElement('div', { className: NS + '_err' }, '出错：' + err) : null,
+                            note ? react.createElement('div', { className: NS + '_msg' }, note) : null,
+                            !loading && !sessions.length ? react.createElement('div', { className: NS + '_msg' }, '没有可显示的会话。') : null,
+                            rows
+                        ),
+                        react.createElement('div', { className: NS + '_foot' },
+                            react.createElement('div', null,
+                                react.createElement('div', { className: NS + '_msg' }, '已选 ' + pickedList.length + ' 个 / ' + fmtBytes(pickedBytes)),
+                                react.createElement('div', { className: NS + '_msg' },
+                                    '回收目录：' + trash.count + ' 个 / ' + fmtBytes(trash.bytes)
+                                    + (trash.count ? '（可彻底删除）' : ''))
+                            ),
+                            react.createElement('div', { style: { display: 'flex', gap: 8, alignItems: 'center' } },
+                                react.createElement('button', { className: NS + '_act ' + NS + '_ghost', onClick: pickAll, disabled: busy }, '全选可清理'),
+                                trash.count
+                                    ? react.createElement('button', { className: NS + '_act ' + NS + '_ghost', onClick: doEmpty, disabled: busy }, '清空回收目录')
+                                    : null,
+                                confirming
+                                    ? react.createElement(react.Fragment, null,
+                                        react.createElement('button', { className: NS + '_act ' + NS + '_confirm', onClick: doDelete, disabled: busy },
+                                            busy ? '处理中…' : '确认清理 ' + pickedList.length + ' 个'),
+                                        react.createElement('button', { className: NS + '_act ' + NS + '_ghost', onClick: () => setConfirming(false), disabled: busy }, '取消')
+                                      )
+                                    : react.createElement('button', {
+                                        className: NS + '_act ' + NS + '_danger',
+                                        disabled: busy || !pickedList.length,
+                                        onClick: () => setConfirming(true),
+                                      }, '清理选中')
+                            )
+                        )
+                    )
+                ),
+                document.body
+            );
+        }
+
+        function EntryButton() {
+            const [open, setOpen] = react.useState(false);
+            // 面板状态住在【常驻】的侧边栏入口里；菜单项与全局快捷键都经这座桥来开它。
+            // ⚠️ 菜单项自己渲染面板是错的：菜单一关组件就卸载、state 丢失 ⇒ 点了没反应。
+            const [pick, setPick] = react.useState('');
+            react.useEffect(() => {
+                openPanelBridge = (id) => { setPick(id || ''); setOpen(true); };
+                return () => { if (openPanelBridge) openPanelBridge = null; };
+            }, []);
+            return react.createElement(react.Fragment, null,
+                react.createElement('button', {
+                    className: NS + '_btn',
+                    type: 'button',
+                    title: '清理会话文件（移到回收目录，可恢复）',
+                    onClick: () => { setPick(''); setOpen(true); },
+                }, '清理会话'),
+                open ? react.createElement(Panel, {
+                    onClose: () => { setOpen(false); setPick(''); },
+                    initialPick: pick,
+                    initialConfirming: !!pick,
+                }) : null
+            );
+        }
+
+        /** 垃圾桶图标（自己画，不依赖官方 primitive）。 */
+        function TrashIcon() {
+            return react.createElement('svg', {
+                className: NS + '_miIcon', width: 14, height: 14, viewBox: '0 0 16 16',
+                fill: 'none', stroke: 'currentColor', strokeWidth: 1.4,
+                strokeLinecap: 'round', strokeLinejoin: 'round',
+            }, react.createElement('path', { d: 'M3 4.5h10M6.5 4.5V3h3v1.5M4.5 4.5l.6 8h5.8l.6-8M6.8 7v3.2M9.2 7v3.2' }));
+        }
+
+        /**
+         * 会话行菜单里的条目（插槽 sidebar.workspaces.session.menu.item）。
+         * props 由插槽给：{ sessionId, displayTitle, useMenuOpenState }。
+         * ⚠️ useMenuOpenState 可能因官方版本差异而缺失 —— 用恒定的 fallback 保证【无条件调用】，
+         *    否则违反 hooks 规则会直接崩掉整个菜单。
+         */
+        // ★ 官方 MenuItemButton 的 onSelect 是 `() => void`，【不带事件对象】
+        //   ⇒ 拿不到 e.ctrlKey。所以自己跟踪修饰键状态（按住 Ctrl 点击 = 跳过二次确认）。
+        //
+        //   ⚠️ 状态必须挂在 window 上，【不能】用模块级变量：
+        //   插件可能被加载多份（HMR / 强刷，Console 里见过三份 client apply()），
+        //   而「注册监听的实例」与「渲染菜单项的实例」可能不是同一个 ——
+        //   模块级变量各是各的 ⇒ 按 Ctrl 那边置了位，这边读到的还是 false（实测就是这个症状）。
+        //   失焦时复位，否则 Alt+Tab 切走再回来状态会永远卡在按下。
+        function ctrlIsDown() { return window.__scCtrlDown === true; }
+        function trackModifiers() {
+            // ★ 最可靠的一路：按下鼠标那一刻的 e.ctrlKey
+            //   （2026-10-14 修 bug：用户"按住 Ctrl 点击仍要二次确认"）
+            const mark = (e) => { window.__scCtrlDown = !!(e && e.ctrlKey); };
+            const down = (e) => { if (e.key === 'Control') window.__scCtrlDown = true; };
+            const up = (e) => { if (e.key === 'Control') window.__scCtrlDown = false; };
+            const winBlur = () => { window.__scCtrlDown = false; };
+            document.addEventListener('mousedown', mark, true);
+            document.addEventListener('pointerdown', mark, true);
+            window.addEventListener('keydown', down, true);
+            window.addEventListener('keyup', up, true);
+            //  ⚠️ window 上的 blur 监听【绝不能加 capture】：
+            //     blur 不冒泡，但在【捕获阶段】会从 window 向下传到目标元素 ——
+            //     加 capture 等于在监听"任何元素失焦"；而点击菜单项会让输入框失焦，
+            //     于是刚置上的 Ctrl 状态被立刻清成 false ⇒ 永远走二次确认（实测症状）。
+            //     不加 capture ⇒ 只接 window 自身的失焦，这才是我们要的语义。
+            window.addEventListener('blur', winBlur);
+            return () => {
+                document.removeEventListener('mousedown', mark, true);
+                document.removeEventListener('pointerdown', mark, true);
+                window.removeEventListener('keydown', down, true);
+                window.removeEventListener('keyup', up, true);
+                window.removeEventListener('blur', winBlur);
+            };
+        }
+
+        function MenuDeleteItem(props) {
+            const sessionId = props.sessionId;
+            // 一次性诊断：确认插槽到底给了哪些 props（尤其 useShortcuts 在不在）
+            if (!MenuDeleteItem.logged) {
+                MenuDeleteItem.logged = true;
+                console.log('[session-tidy] 菜单项 props: ' + Object.keys(props).join(', '));
+            }
+            const useMenuOpen = react.useMemo(
+                () => (typeof props.useMenuOpenState === 'function' ? props.useMenuOpenState : () => [false, () => {}]),
+                [props.useMenuOpenState]
+            );
+            const [, setMenuOpen] = useMenuOpen();
+            // 官方做法：shortcut 由插槽 props 的 useShortcuts 取【用户实际绑定】的键位。
+            // useMemo 固定引用 + 无条件调用 —— 条件调用 hook 会崩掉整个菜单。
+            const useSc = react.useMemo(
+                () => (typeof props.useShortcuts === 'function' ? props.useShortcuts : () => undefined),
+                [props.useShortcuts]
+            );
+            const shortcut = useSc((rows) => (rows || []).find((r) => r.id === SHORTCUT_ID));
+            // 一键移入回收目录 —— 不弹面板、不再要确认。
+            // 分层原则：移入回收目录【可恢复】⇒ 一键；彻底删除（清空回收目录）才要确认。
+            const [phase, setPhase] = react.useState('idle');   // idle | busy | done | failed
+            const [errMsg, setErrMsg] = react.useState('');
+            const [already, setAlready] = react.useState(false);
+            const onClick = async () => {
+                if (phase === 'busy' || phase === 'done') return;   // 忽略重复点击
+                // 二次确认：鼠标直接点要确认（易误点）；
+                // ★ 按住 Ctrl 再点 = 跳过确认，直接移入回收目录（2026-10-14 用户要求）。
+                //   删除本身是可恢复的（移到 sessions-trash 而非 unlink），所以这个捷径是安全的。
+                if (!ctrlIsDown() && (phase === 'idle' || phase === 'failed')) {
+                    setErrMsg(''); setPhase('confirm'); return;
+                }
+                setPhase('busy');
+                try {
+                    const r = await api('/session-tidy/delete-one', { id: sessionId });
+                    if (r && r.ok) {
+                        if (r.already) setAlready(true);   // 文件本就不在（多半已删过）
+                        // ★ 2026-10-14 追加：文件已移走 ⇒ 再走【官方归档】，让 host 状态立即更新。
+                        //   动机（用户实测："怎么还在啊"）：删了文件但 host 内存状态不变 ⇒ 侧边栏照样
+                        //   显示该会话，要重启 DSH 才干净。官方通道 uiWorkspace.archiveSession 会把
+                        //   它移出活跃列表 ⇒ 列表【立刻】消失（host 侧随后还会把 archivedSessionIds 摘掉）。
+                        //   顺序讲究：**先删文件、成功后才归档** —— 删除失败时不归档，会话仍留在列表里。
+                        try {
+                            if (typeof window.__scArchive === 'function') await window.__scArchive(sessionId);
+                        } catch (e) {
+                            console.warn('[session-tidy] 官方归档未成功（文件已删，列表要重启才更新）: ' + ((e && e.message) || e));
+                        }
+                        setPhase('done');
+                        setTimeout(() => { try { setMenuOpen(false); } catch (e) { /* 忽略 */ } }, 900);
+                        // 不再自动刷新页面：那会打断用户正在进行的对话。
+                        // 列表要等下次刷新才更新（会话列表来自 host 状态，删文件不会改它）。
+                    } else {
+                        setErrMsg((r && r.error) || '未移动');
+                        setPhase('failed');
+                    }
+                } catch (e) {
+                    setErrMsg((e && e.message) || String(e));
+                    setPhase('failed');
+                }
+            };
+            let label = '删除会话';
+            if (phase === 'confirm') label = '确认删除？（' + (props.displayTitle || '此会话') + '）';
+            else if (phase === 'busy') label = '删除中…';
+            else if (phase === 'done') label = already ? '该会话已清理过 ✓' : '已移入回收目录 ✓';
+            else if (phase === 'failed') label = '失败：' + errMsg;
+            const tip = '移到回收目录（可恢复；置顶与运行中的会话会被拒绝）—— 按住 Ctrl 点击可跳过二次确认';
+            return MenuItemButton
+                ? react.createElement(MenuItemButton, {
+                    danger: phase !== 'done',      // 官方危险行：error 色文字/图标 + danger hover 填充
+                    icon: react.createElement(TrashIcon),
+                    shortcut: shortcut,
+                    onSelect: onClick,
+                }, label)
+                : react.createElement('button', {
+                    type: 'button',
+                    role: 'menuitem',
+                    className: NS + '_mi ' + NS + '_miDanger',
+                    title: tip,
+                    onClick: onClick,
+                }, react.createElement(TrashIcon), label);
+        }
+
+        function apply(ctx) {
+            console.log('[session-tidy] client apply()');
+            // 修饰键跟踪（Ctrl+点击跳过确认用）
+            if (ctx && typeof ctx.effect === 'function') ctx.effect(trackModifiers);
+            else trackModifiers();
+            injectCss();
+            // ★ 把官方归档动作挂到 window —— 插槽组件的 props 里没有 ctx，拿不到服务。
+            //   uiWorkspace.archiveSession(id) 更新 host 状态 ⇒ 侧边栏立即移除该会话。
+            //   能力检测：服务不在就置 null，调用方自动退化为"只删文件"。
+            try {
+                const ws = (ctx && typeof ctx.get === 'function') ? ctx.get('uiWorkspace') : null;
+                window.__scArchive = (ws && typeof ws.archiveSession === 'function')
+                    ? function (id) { return ws.archiveSession(id); }
+                    : null;
+                console.log('[session-tidy] 官方归档通道: ' + (window.__scArchive ? '✅ uiWorkspace.archiveSession 可用' : '⚠️ 不可用（删完列表要重启才更新）'));
+            } catch (e) {
+                window.__scArchive = null;
+                console.log('[session-tidy] 官方归档通道探测失败: ' + ((e && e.message) || e));
+            }
+
+            // 快捷键注册已移除（2026-10-13）。
+            // 原因：它删的是"主视图当前会话"——那正是用户正在对话的那个，方向完全错了；
+            // 且 'shortcuts' 服务在客户端未必可用，声明 inject 会让整个插件去等它。
+            // ⇒ 宁可不做，也不能删掉用户正在用的会话。
+            // ① 会话行的 "..." 菜单（官方 slot；插件项排在 archive(400) 之后）
+            try {
+                ctx.slots.inject('sidebar.workspaces.session.menu.item', () => ctx.slots.register(
+                    { name: 'sidebar.workspaces.session.menu.item', id: 'session-tidy.delete', order: 500 },
+                    MenuDeleteItem
+                ));
+                console.log('[session-tidy] ✅ 菜单项已注册到 sidebar.workspaces.session.menu.item');
+            } catch (e) {
+                console.error('[session-tidy] 菜单项注册失败: ' + ((e && e.message) || e));
+            }
+            // ② 侧边栏底部的批量入口
+            try {
+                ctx.slots.inject('sidebar.footer.action', () => ctx.slots.register(
+                    { name: 'sidebar.footer.action', id: 'dsh-plugin-session-tidy', order: 90 },
+                    EntryButton
+                ));
+                console.log('[session-tidy] ✅ 入口已注册到 sidebar.footer.action');
+            } catch (e) {
+                console.error('[session-tidy] 入口注册失败: ' + ((e && e.message) || e));
+            }
+        }
+
+        exports.apply = apply;
+        // 只声明 slots。曾经加过 'shortcuts'（为了注册快捷键），那会让插件去等一个
+        // 未必存在的客户端服务 —— 风险大于收益，已回滚（2026-10-13）。
+        exports.inject = ['slots'];
+        return module.exports;
+    },
+});

package/lib/index.js

@@ -0,0 +1,428 @@
+// dsh-plugin-session-tidy -- host 侧
+//
+// 为什么需要它：官方【只归档不删除】（dsh-client-ui-workspace README：
+// 「会话可以归档但绝不会被删除」；dsh-session-persistence-jsonl：「seam 无删除接口」），
+// 而 archiveSession 只是往注册表塞 id —— 文件仍在原地，不省空间。
+//
+// 删除动作【可恢复】：移到 ~/.dsh/sessions-trash/<时间戳>/，再由用户显式清空。
+//
+// 三条保护（用户 2026-10-13 定）：
+//   ① 置顶会话        ← ~/.dsh/storages/workspace.json 的 global.pinnedSessionIds（只读）
+//   ② 正在运行的会话  ← ctx.agents.list() 的 session.id
+//   ③ mtime 兜底      ← RECENT_MS 内动过的一律禁选
+// 前两条【前端禁选 + 后端拒绝】双重校验 —— 前端只是提示，后端才是闸门。
+//
+// 来源检查：只接受 loopback（远程 / tls-proxy 反代一律 403）。
+
+import { readdir, stat, mkdir, rename, rm, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const name = 'session-tidy';
+
+/** webServer 承载路由；agents 用来识别"正在运行的会话"（拿不到就退化为只靠 mtime）。 */
+export const inject = ['webServer', 'agents'];
+
+const DSH = join(homedir(), '.dsh');
+const SESSIONS = join(DSH, 'sessions');
+const TRASH = join(DSH, 'sessions-trash');
+const WORKSPACE_JSON = join(DSH, 'storages', 'workspace.json');
+
+/** 最近这么久内动过的会话禁选（保护正在进行的对话）。 */
+const RECENT_MS = 10 * 60 * 1000;
+
+const SESSION_FILE = 'session.v4.jsonl.zstd';
+
+/** 只认本机回环来源：远程（含反代）一律拒绝。 */
+function isLoopback(req) {
+    const a = req.socket && req.socket.remoteAddress;
+    const ok = a === '127.0.0.1' || a === '::1' || a === '::ffff:127.0.0.1';
+    if (!ok) return false;
+    const host = String(req.headers.host || '');
+    const h = host.replace(/:\d+$/, '').replace(/^\[|\]$/g, '');
+    return h === '127.0.0.1' || h === 'localhost' || h === '::1';
+}
+
+function sendJson(res, code, body) {
+    res.statusCode = code;
+    res.setHeader('content-type', 'application/json; charset=utf-8');
+    res.setHeader('cache-control', 'no-store');
+    res.end(JSON.stringify(body));
+}
+
+async function readBody(req, limit = 64 * 1024) {
+    return new Promise((resolve, reject) => {
+        let d = '';
+        req.on('data', (chunk) => {
+            d += chunk;
+            if (d.length > limit) { reject(new Error('body too large')); req.destroy(); }
+        });
+        req.on('end', () => resolve(d));
+        req.on('error', reject);
+    });
+}
+
+async function dirBytes(dir) {
+    let total = 0;
+    async function walk(d) {
+        let entries;
+        try { entries = await readdir(d, { withFileTypes: true }); } catch { return; }
+        for (const e of entries) {
+            const p = join(d, e.name);
+            if (e.isDirectory()) await walk(p);
+            else { try { total += (await stat(p)).size; } catch { /* 忽略 */ } }
+        }
+    }
+    await walk(dir);
+    return total;
+}
+
+/** 工作区转义名 ⇒ 可读路径（--C-Users-x-Desktop-~7BA1~5BB6-- ⇒ C:\Users\x\Desktop\管家）。 */
+export function decodeWorkspace(name) {
+    const core = name.replace(/^--/, '').replace(/--$/, '');
+    return core
+        .replace(/~([0-9A-Fa-f]{4})/g, (_, h) => String.fromCharCode(parseInt(h, 16)))
+        .replace(/^([A-Za-z])-/, '$1:\\')   // 盘符：C-Users ⇒ C:\Users
+        .replace(/-/g, '\\');
+}
+
+/**
+ * 读 DSH 的 workspace 注册表（**只读，绝不写**）。
+ * 返回 { pinned:Set, archived:Set, titles:Map<sessionId,title> }，失败时返回空集合。
+ */
+export async function readRegistry() {
+    const pinned = new Set();
+    const archived = new Set();
+    const titles = new Map();
+    try {
+        const j = JSON.parse(await readFile(WORKSPACE_JSON, 'utf8'));
+        for (const id of j?.global?.pinnedSessionIds ?? []) pinned.add(String(id));
+        for (const id of j?.global?.archivedSessionIds ?? []) archived.add(String(id));
+        for (const w of Object.values(j?.tables?.workspaces ?? {})) {
+            for (const sid of w?.sessionIds ?? []) if (!titles.has(String(sid))) titles.set(String(sid), String(w?.title ?? ''));
+        }
+    } catch { /* 注册表不可读 ⇒ 空保护集合，靠 mtime 兜底 */ }
+    return { pinned, archived, titles };
+}
+
+/**
+ * 正在【运行】的会话 id —— 判据是 agent.status === 'running'。
+ *
+ * ★ 2026-10-14 修 bug（用户："没在运行的会话也被提示正在运行、拒绝删除"）：
+ *   agents.list() 返回的是【所有 live agent】（官方注释原文：All live agents, in registration
+ *   order）—— 会话切走或结束后 agent 仍会驻留，只看"存在"必然把整屏历史会话误判成"正在运行"。
+ *   官方的 AgentStatus 是【二元】的：'idle' | 'running'
+ *   （原句：export type AgentStatus = 'idle' | 'running'，见 extensions/tool-cordis 的 api-catalog）
+ *   ⇒ 只把 running 当运行；idle 的只是驻留，可以删。
+ *   拿不到 status 时【放行】：宁可让用户删掉已结束的会话，也不要把列表全锁死；
+ *   真正在写的文件还有 mtime 与 rename 失败两道兜底。
+ */
+export function activeSessionIds(ctx) {
+    const out = new Set();
+    try {
+        for (const agent of ctx?.get?.('agents')?.list?.() ?? []) {
+            const id = agent?.session?.id ?? agent?.sessionId;
+            if (!id) continue;
+            if (agent && agent.status === 'running') out.add(String(id));
+        }
+    } catch { /* 拿不到就不保护这一维 */ }
+    return out;
+}
+
+/**
+ * 扫出所有会话（含不可删的，带标记 —— 让用户看到"为什么删不了"）。
+ * @returns { sessions, totalBytes, deletableBytes }
+ */
+export async function scanSessions(opts = {}) {
+    const now = opts.now ?? Date.now();
+    const pinned = opts.pinned ?? new Set();
+    const archived = opts.archived ?? new Set();
+    const active = opts.active ?? new Set();
+    const titles = opts.titles ?? new Map();
+
+    const out = [];
+    let workspaces = [];
+    try { workspaces = await readdir(SESSIONS, { withFileTypes: true }); } catch { return { sessions: [], totalBytes: 0, deletableBytes: 0 }; }
+
+    for (const w of workspaces) {
+        if (!w.isDirectory()) continue;
+        const wdir = join(SESSIONS, w.name);
+        let sessions = [];
+        try { sessions = await readdir(wdir, { withFileTypes: true }); } catch { continue; }
+        for (const s of sessions) {
+            if (!s.isDirectory()) continue;
+            const id = s.name;
+            const sdir = join(wdir, id);
+            let st;
+            try { st = await stat(join(sdir, SESSION_FILE)); } catch { continue; }
+            const bytes = await dirBytes(sdir);
+            const recent = now - st.mtimeMs < RECENT_MS;
+
+            // 磁盘目录名可能带 session- 前缀；注册表里的 id 也带。两种都比一次。
+            const bare = id.replace(/^session-/, '');
+            const isPinned = pinned.has(id) || pinned.has(bare) || pinned.has('session-' + bare);
+            const isArchived = archived.has(id) || archived.has(bare) || archived.has('session-' + bare);
+            const isActive = active.has(id) || active.has(bare) || active.has('session-' + bare);
+
+            let lockedBy = null;
+            if (isActive) lockedBy = 'active';
+            else if (isPinned) lockedBy = 'pinned';
+            else if (recent) lockedBy = 'recent';
+
+            out.push({
+                id,
+                workspace: w.name,
+                workspacePath: decodeWorkspace(w.name),
+                title: titles.get(id) || titles.get(bare) || '',
+                bytes,
+                mtime: st.mtimeMs,
+                archived: isArchived,
+                lockedBy,
+            });
+        }
+    }
+    // 已归档的排前面（用户主动归档过 ⇒ 最可能想清），同组按大小倒序
+    out.sort((a, b) => (Number(b.archived) - Number(a.archived)) || (b.bytes - a.bytes));
+    const totalBytes = out.reduce((n, x) => n + x.bytes, 0);
+    const deletableBytes = out.filter((x) => !x.lockedBy).reduce((n, x) => n + x.bytes, 0);
+    return { sessions: out, totalBytes, deletableBytes };
+}
+
+/** 回收目录现状。 */
+export async function trashInfo() {
+    let stamps = [];
+    try { stamps = await readdir(TRASH, { withFileTypes: true }); } catch { return { count: 0, bytes: 0 }; }
+    let count = 0, bytes = 0;
+    for (const d of stamps) {
+        if (!d.isDirectory()) continue;
+        const p = join(TRASH, d.name);
+        let wsList = [];
+        try { wsList = await readdir(p, { withFileTypes: true }); } catch { continue; }
+        for (const w of wsList) {
+            if (!w.isDirectory()) continue;
+            let inner = [];
+            try { inner = await readdir(join(p, w.name), { withFileTypes: true }); } catch { continue; }
+            for (const s of inner) {
+                if (!s.isDirectory()) continue;
+                count++;
+                bytes += await dirBytes(join(p, w.name, s.name));
+            }
+        }
+    }
+    return { count, bytes };
+}
+
+/**
+ * 把指定会话移到回收目录。
+ * ★ 后端再次校验三条保护 —— 前端禁选只是提示。
+ */
+export async function moveToTrash(ids, guards = {}) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const pinned = guards.pinned ?? new Set();
+    const active = guards.active ?? new Set();
+    const moved = [];
+    const failed = [];
+
+    for (const it of ids) {
+        const id = String(it?.id ?? '');
+        const workspace = String(it?.workspace ?? '');
+        // 防路径穿越
+        if (!id || !workspace || /[\\/]|\.\./.test(id) || /[\\/]|\.\./.test(workspace)) {
+            failed.push({ id, error: '非法名字' });
+            continue;
+        }
+        const bare = id.replace(/^session-/, '');
+        const inSet = (s) => s.has(id) || s.has(bare) || s.has('session-' + bare);
+        if (inSet(active)) { failed.push({ id, error: '正在运行，拒绝删除' }); continue; }
+        if (inSet(pinned)) { failed.push({ id, error: '置顶会话，拒绝删除' }); continue; }
+
+        const src = join(SESSIONS, workspace, id);
+        try {
+            const st = await stat(src);
+            if (Date.now() - st.mtimeMs < RECENT_MS) { failed.push({ id, error: '最近仍活跃，拒绝删除' }); continue; }
+            const dstDir = join(TRASH, stamp, workspace);
+            await mkdir(dstDir, { recursive: true });
+            await rename(src, join(dstDir, id));
+            moved.push(id);
+        } catch (e) {
+            failed.push({ id, error: (e && e.message) || String(e) });
+        }
+    }
+    // ★ 文件移走了，还要把这个会话从 DSH 的 workspace 注册表里摘掉 ——
+    //   否则侧边栏列表照样显示它，再点还会报「找不到」（实测就是这个症状）。
+    let unregistered = null;
+    if (moved.length) unregistered = await unregisterSessions(moved);
+    return { moved, failed, stamp, unregistered };
+}
+
+/**
+ * 从 DSH 的 workspace 注册表里摘掉这些会话 id。
+ *
+ * ★ 为什么必须做（2026-10-14 实测）：已删会话仍留在 workspaces[].sessionIds 里（6 个里 5 个还在），
+ *   而侧边栏列表读的就是这份状态 ⇒ 不摘掉的话「删了文件列表照样显示、再点还报找不到」。
+ *
+ * ★ 关于官方 archiveSession：归档是【用户的主动状态】（想留着只是不想看），所以【不用它代替删除】。
+ *   但 2026-10-14 起 client 侧会在【文件删除成功之后】顺手调一次归档 —— 唯一目的是让 host 侧状态
+ *   立即更新（否则侧边栏要重启才干净，用户实测："怎么还在啊"）；紧接着本函数会把该 id 从
+ *   archivedSessionIds 里也摘掉 ⇒ 不留下"伪归档"。
+ *   顺序讲究：先删文件、成功后才归档 —— 删除失败时不归档，会话仍留在列表里，语义更直白。
+ *
+ * ★ 安全措施（针对「DSH 也会写这个文件」）：
+ *   ① 写前【重读】磁盘最新内容，不拿旧副本覆盖
+ *   ② 只改那三个数组，其余字段原样带回
+ *   ③ 先备份 .bak-session-tidy-<时间戳>
+ *   ④ 原子写：先写临时文件再 rename（避免写一半被读到）
+ *   ⑤ 整段 try/catch —— 这步失败【不影响删除本身】（文件已经移走了）
+ *
+ * ★ 生效时机：DSH 内存里那份状态不会因此改变 ⇒ 【重启 DSH 后】列表才干净。
+ */
+export async function unregisterSessions(ids) {
+    if (!ids || !ids.length) return { ok: false, reason: 'empty' };
+    const set = new Set(ids.map(String));
+    try {
+        const before = await readFile(WORKSPACE_JSON, 'utf8');
+        const j = JSON.parse(before);
+        let removed = 0;
+
+        for (const w of Object.values(j?.tables?.workspaces ?? {})) {
+            if (!Array.isArray(w?.sessionIds)) continue;
+            const next = w.sessionIds.filter((x) => !set.has(String(x)));
+            removed += w.sessionIds.length - next.length;
+            w.sessionIds = next;
+        }
+        for (const key of ['archivedSessionIds', 'pinnedSessionIds']) {
+            const arr = j?.global?.[key];
+            if (!Array.isArray(arr)) continue;
+            const next = arr.filter((x) => !set.has(String(x)));
+            removed += arr.length - next.length;
+            j.global[key] = next;
+        }
+        if (!removed) return { ok: true, removed: 0 };
+
+        const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        await writeFile(WORKSPACE_JSON + '.bak-session-tidy-' + stamp, before, 'utf8').catch(() => { /* 备份失败不阻断 */ });
+        const tmp = WORKSPACE_JSON + '.tmp-' + Date.now();
+        await writeFile(tmp, JSON.stringify(j, null, 2), 'utf8');
+        await rename(tmp, WORKSPACE_JSON);
+        console.log('[session-tidy] 已从 workspace 注册表摘除 ' + removed + ' 处引用（重启 DSH 后列表生效）');
+        return { ok: true, removed: removed };
+    } catch (e) {
+        console.log('[session-tidy] 摘除注册表失败（不影响已删除的文件）: ' + ((e && e.message) || e));
+        return { ok: false, error: (e && e.message) || String(e) };
+    }
+}
+
+/** 彻底清空回收目录。 */
+export async function emptyTrash() {
+    const info = await trashInfo();
+    await rm(TRASH, { recursive: true, force: true });
+    return info;
+}
+
+export function apply(ctx) {
+    console.log('[session-tidy] apply() 开始');
+
+    const guard = (req, res) => {
+        if (isLoopback(req)) return true;
+        sendJson(res, 403, { error: 'forbidden', message: '仅允许本机访问' });
+        return false;
+    };
+
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: '/session-tidy/list',
+        handler: async (req, res) => {
+            if (!guard(req, res)) return;
+            if (req.method !== 'GET') { sendJson(res, 405, { error: 'method' }); return; }
+            try {
+                const reg = await readRegistry();
+                const active = activeSessionIds(ctx);
+                const scan = await scanSessions({ ...reg, active });
+                const trash = await trashInfo();
+                sendJson(res, 200, {
+                    ok: true,
+                    ...scan,
+                    trash,
+                    recentMs: RECENT_MS,
+                    counts: { pinned: reg.pinned.size, archived: reg.archived.size, active: active.size },
+                });
+            } catch (e) {
+                sendJson(res, 500, { ok: false, error: (e && e.message) || String(e) });
+            }
+        },
+    }), 'session-tidy: list');
+
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: '/session-tidy/delete',
+        handler: async (req, res) => {
+            if (!guard(req, res)) return;
+            if (req.method !== 'POST') { sendJson(res, 405, { error: 'method' }); return; }
+            try {
+                const body = JSON.parse((await readBody(req)) || '{}');
+                const ids = Array.isArray(body.ids) ? body.ids : [];
+                if (!ids.length) { sendJson(res, 400, { ok: false, error: '没有选中任何会话' }); return; }
+                if (ids.length > 500) { sendJson(res, 400, { ok: false, error: '一次最多 500 个' }); return; }
+                const reg = await readRegistry();
+                const active = activeSessionIds(ctx);
+                const r = await moveToTrash(ids, { pinned: reg.pinned, active });
+                console.log('[session-tidy] 移入回收目录 ' + r.moved.length + ' 个，拒绝/失败 ' + r.failed.length);
+                sendJson(res, 200, { ok: true, ...r });
+            } catch (e) {
+                sendJson(res, 500, { ok: false, error: (e && e.message) || String(e) });
+            }
+        },
+    }), 'session-tidy: delete');
+
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: '/session-tidy/empty-trash',
+        handler: async (req, res) => {
+            if (!guard(req, res)) return;
+            if (req.method !== 'POST') { sendJson(res, 405, { error: 'method' }); return; }
+            try {
+                const info = await emptyTrash();
+                console.log('[session-tidy] 清空回收目录 ' + info.count + ' 个 / ' + info.bytes + ' B');
+                sendJson(res, 200, { ok: true, ...info });
+            } catch (e) {
+                sendJson(res, 500, { ok: false, error: (e && e.message) || String(e) });
+            }
+        },
+    }), 'session-tidy: empty-trash');
+
+    // ★ 会话行菜单用：只给 sessionId（菜单插槽的 props 里没有 workspace），host 自己定位。
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: '/session-tidy/delete-one',
+        handler: async (req, res) => {
+            if (!guard(req, res)) return;
+            if (req.method !== 'POST') { sendJson(res, 405, { error: 'method' }); return; }
+            try {
+                const body = JSON.parse((await readBody(req)) || '{}');
+                const id = String(body.id || '');
+                if (!id) { sendJson(res, 400, { ok: false, error: '缺少 id' }); return; }
+                const reg = await readRegistry();
+                const active = activeSessionIds(ctx);
+                const scan = await scanSessions({ ...reg, active });
+                const hit = scan.sessions.find((s) => s.id === id);
+                if (!hit) {
+                    // 文件已不在 ⇒ 多半是【已经删过一次】（用户又点了一下，属正常操作）。
+                    // 不再报 404「找不到该会话」—— 那会让人以为出错了。
+                    sendJson(res, 200, { ok: true, already: true, id: id, moved: [], failed: [] });
+                    return;
+                }
+                const r = await moveToTrash([{ id: hit.id, workspace: hit.workspace }], { pinned: reg.pinned, active });
+                if (!r.moved.length) {
+                    sendJson(res, 200, { ok: false, error: (r.failed[0] && r.failed[0].error) || '未移动', ...r });
+                    return;
+                }
+                console.log('[session-tidy] 菜单删除: ' + id + ' (' + hit.bytes + ' B)');
+                sendJson(res, 200, { ok: true, id, bytes: hit.bytes, ...r });
+            } catch (e) {
+                sendJson(res, 500, { ok: false, error: (e && e.message) || String(e) });
+            }
+        },
+    }), 'session-tidy: delete-one');
+
+    console.log('[session-tidy] ✅ 四条路由已注册');
+}

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "dsh-plugin-session-tidy",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "清理 DSH 会话文件（官方只归档不删除）：会话行菜单 + 侧边栏批量面板",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Fanlr1/dsh-plugins.git",
+    "directory": "packages/session-tidy"
+  },
+  "homepage": "https://github.com/Fanlr1/dsh-plugins/tree/main/packages/session-tidy#readme",
+  "bugs": {
+    "url": "https://github.com/Fanlr1/dsh-plugins/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "session",
+    "cleanup"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dsh": {
+    "client": {
+      "inject": [],
+      "platform": "web"
+    }
+  }
+}