dsh-plugin-tool-management 0.19.0 → 0.20.0

package/lib/hub.js

@@ -24,13 +24,14 @@
 //   ├─ mcp-disabled-tools.json | mcp-known-tools.json | mcp-notes.json | mcp-settings.json | mcp-export.json
 //   ├─ tool-management.log                               插件日志（滚动 .1）
 //   ├─ backups/cordis.patch.yml.bak-<时间戳>             改宿主 patch 前的备份
-//   ├─ trash/{skills,subagents,prompts,scenes}-trash/<id>/  回收站（除记忆外的四类）
-//   └─ memories-trash/<id>/                              记忆回收站（**hub 根下独立目录**）
+//   ├─ trash/{skills,subagents,prompts,scenes,memories}-trash/<id>/  回收站（六类）
 //
-// 记忆回收站**不在 `trash/` 下**（本机实测 `trash/` 只有 4 个 `-trash` 目录）：它走
-// `memories/service.ts` 自己的路径（`join(stateDir, 'memories-trash', id)`，stateDir = hub 根），
-// 不经本模块的 `moveToTrash`。此前这行把它画进 `trash/{…}` 里，按它写备份/迁移脚本会既漏搬
-// 又误判（那是一类真实存在、条目数最多的用户数据）。
+// 六类回收站的落点已统一在 `trash/` 下（2026-10-10 起；记忆此前在 hub 根的 `memories-trash/`，
+// 由启动迁移并入 —— 见 `HUB_RENAMES`）。
+// 但**记忆那一类仍不经本模块的 `moveToTrash`**：它走 `memories/service.ts` 自己的路径
+// （`join(stateDir, 'trash/memories-trash', id)`，stateDir = hub 根），manifest 形状也由记忆域
+// 自己定。本模块只保证**目录位置**与其余几类一致；把它的读写抄到这里来只会得到第二份会漂移的
+// 真相（本条注释的前身就是这么写错的：它把记忆画进 `trash/{…}` 里，而当时那里根本没有它）。
 //
 // 留在 `$DSH_HOME` 根下的两个文件**不是**插件的：`AGENTS.md`（宿主每轮读取的全局基线，
 // 插件只是按场景/预设写它）与 `cordis.patch.yml`（宿主加载插件的配置入口）。
@@ -68,6 +69,11 @@ const HUB_RENAMES = [
     ['agents-md', 'prompts'],
     ['rules-index.json', 'memories-index.json'],
     ['rules-trash', 'memories-trash'],
+    // 记忆回收站并入 `trash/`，与其余五类同处一处（2026-10-10）。
+    // **必须排在上一行之后**：极老的 `rules-trash/` 要先改名成 `memories-trash/`，这一行才能
+    // 把它一并搬进 `trash/`。顺序颠倒的话，老用户那份会留在 hub 根下不动 —— 而它恰恰是条目数
+    // 最多的一类数据。
+    ['memories-trash', 'trash/memories-trash'],
     ['agents', 'subagents'],
     ['agents-index.json', 'subagents-index.json'],
     ['state.json', 'skills-state.json'],
@@ -266,6 +272,90 @@ export function trashEntryPath(kind, id) {
         return null;
     return join(trashKindDir(kind), id);
 }
+/** 清单类文件名：它们是插件自己的元数据，不是"删掉的那份东西"，不进详情。 */
+const TRASH_META_NAMES = new Set(['manifest.json', 'metadata.json']);
+/** 详情上限：单个文件、总字节、文件数、递归深度。超了就如实标 `truncated`，绝不悄悄截。 */
+const PREVIEW_MAX_FILE = 64 * 1024;
+const PREVIEW_MAX_TOTAL = 256 * 1024;
+const PREVIEW_MAX_FILES = 40;
+const PREVIEW_MAX_DEPTH = 4;
+/** 前 8 KiB 里出现 NUL 就按二进制处理 —— 二进制内容转成字符串只会是一屏乱码。 */
+function looksBinary(buf) {
+    const n = Math.min(buf.length, 8192);
+    for (let i = 0; i < n; i += 1)
+        if (buf[i] === 0)
+            return true;
+    return false;
+}
+/**
+ * 把一条回收站条目目录里的负载**只读**地读出来，供界面「详情」显示。
+ *
+ * 为什么放在这里而不是各域各写一遍：三个域的回收站落在三套不同的目录布局里
+ * （hub 的四类 `<kind>-trash`、记忆的 `memories-trash`、技能的 `skills-trash`），
+ * 但"把一个目录里的文件读成能看的文本"这件事完全一样。上限、二进制判据、哪些名字算清单
+ * 只写一遍 —— 否则迟早出现"某一域的详情能读到别的东西"。
+ *
+ * 只读、不落盘、不跟随符号链接（条目里出现链接一律跳过，别把根外的文件读出来给界面看）。
+ * 目录不存在 / 读不动 → 返回空数组，调用方据此报"内容已不可读"，不抛。
+ */
+export async function readTrashPayloadFiles(dir, options = {}) {
+    const out = [];
+    let total = 0;
+    const maxDepth = Number.isFinite(Number(options.maxDepth)) ? Number(options.maxDepth) : PREVIEW_MAX_DEPTH;
+    const walk = async (current, rel, depth) => {
+        if (out.length >= PREVIEW_MAX_FILES || depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        // 目录在前、文件在后；同层按名字排序 —— 让详情里的顺序稳定（不随文件系统枚举顺序变）。
+        const sorted = [...entries].sort((a, b) => {
+            if (a.isDirectory() !== b.isDirectory())
+                return a.isDirectory() ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        for (const entry of sorted) {
+            if (out.length >= PREVIEW_MAX_FILES)
+                return;
+            const abs = join(current, entry.name);
+            const nextRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                await walk(abs, nextRel, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || TRASH_META_NAMES.has(entry.name))
+                continue;
+            let buf;
+            try {
+                buf = await readFile(abs);
+            }
+            catch {
+                continue;
+            }
+            const file = { path: nextRel, size: buf.length };
+            if (looksBinary(buf)) {
+                file.binary = true;
+            }
+            else {
+                const room = Math.max(0, Math.min(PREVIEW_MAX_FILE, PREVIEW_MAX_TOTAL - total));
+                const slice = buf.subarray(0, room);
+                file.text = slice.toString('utf8');
+                if (slice.length < buf.length)
+                    file.truncated = true;
+                total += slice.length;
+            }
+            out.push(file);
+        }
+    };
+    await walk(dir, '', 0);
+    return out;
+}
 async function readManifest(kind, id) {
     const dir = trashEntryPath(kind, id);
     if (dir === null)

package/lib/index.js

@@ -16,7 +16,7 @@ import { createRequire } from 'node:module';
 import { randomUUID } from 'node:crypto';
 import { createHistoryDomain } from './sessions/history.js';
 import { createSkillsService, pluginLog } from './skills/service.js';
-import { renameWithRetry } from './skills/core.js';
+import { renameWithRetry, trashRootPath } from './skills/core.js';
 import { createPromptsService } from './prompts/service.js';
 import { createQuickPromptsService } from './prompts/quick-service.js';
 import { isInsideRootResolved } from './paths.js';
@@ -56,6 +56,9 @@ import { buildCompatOps } from './ops/compat.js';
 import { buildPromptOps } from './ops/prompts.js';
 import { buildQuickPromptOps } from './ops/quick-prompts.js';
 import { buildSessionOps } from './ops/sessions.js';
+import { buildTrashRetentionOps } from './ops/trash-retention.js';
+// 回收站保留期（0.19.1）：侧车 `hub/trash-retention.json` + 六类回收站的到期清扫。
+import { createTrashRetentionDomain } from './trash-retention.js';
 // HTTP 请求准入与 handlers 后处理（2026-09-19 从本文件 apply 闭包抽出，依赖显式传参）。
 import { createAccessToken, createFrozenGate, createOpWhitelist, createSceneLock, guardModelOp, guardModelOps, installHandlerGuards } from './request-gate.js';
 // `isReadCall` 随 HTTP 路由一起搬走了（写门禁与审计流水都读同一份登记表判据）。
@@ -203,6 +206,10 @@ export default {
             memoriesRoot: String(config?.memoriesRoot || ''),
             stateDir: String(config?.memoriesStateDir || ''),
             scenesDir: String(config?.memoriesScenesDir || ''),
+            // 技能回收站根目录：只给回收站「详情」（`trash-preview`）读技能条目用。路径的唯一定义
+            // 在 skills/skill-roots.ts（`trashRootPath()`），这里原样转手，不在记忆域重算一遍 ——
+            // 重算就是第二个真相源，改一处忘一处时详情会指向一个空目录。
+            skillsTrashDir: trashRootPath(),
             // 场景记忆段预算（字节），默认 131072（= DEFAULT_MAX_BYTES，128 KiB）；仅用于测试与特殊部署调优。
             ...(Number.isFinite(Number(config?.rulesMaxBytes))
                 ? { maxBytes: Number(config.rulesMaxBytes) }
@@ -874,6 +881,33 @@ export default {
         // 保留期设置与到期清扫、批量操作目标校验、归档列表分组视图。构造实例、首次清扫、
         // 挂周期定时器都在工厂内完成 —— 它们原本就写在 apply() 的同一位置。
         const history = createHistoryDomain({ ctx, config, pluginRoot: PLUGIN_ROOT, message });
+        // 回收站保留期域（0.19.1）：与上面的 history 同形 —— 构造、首次清扫、周期定时器都在
+        // 工厂内完成。默认保留期是 `0`（永久保留），所以对没打开过这个开关的宿主来说，
+        // 启动那次清扫读完侧车就返回了，一次磁盘遍历都不做。
+        //
+        // 记忆回收站那两条**走 memories 域的 op**，不在这里重抄路径与 manifest 形状：它在
+        // `hub/trash/memories-trash/`（2026-10-10 起与其余五类同处一处，之前是 hub 根下的独立
+        // 目录），形状由 memories 域自己定 —— 重抄一遍只会得到第二份会漂移的真相。
+        const trashRetention = createTrashRetentionDomain({
+            ctx,
+            config,
+            memories: {
+                list: async () => {
+                    const res = await memoriesService.ops['rules-trash-list']({});
+                    const entries = res && Array.isArray(res.entries) ? res.entries : [];
+                    return entries
+                        .map((e) => ({
+                        id: String((e && e.trashId) || ''),
+                        name: String((e && e.name) || ''),
+                        deletedAt: String((e && e.deletedAt) || ''),
+                    }))
+                        // 没有 id 的条目删不掉，也不能记流水 —— 在这里挡掉，免得把一条坏数据一路带到
+                        // 「永久删除」那一步才失败。
+                        .filter((e) => e.id !== '');
+                },
+                purge: (id) => memoriesService.ops['rules-trash-remove']({ trashId: id }),
+            },
+        });
         // ── 场景提示词 → 全局基线（AGENTS.md）同步 ────────────────────────────────
         //
         // 用户裁定（2026-09-15）：「切换场景，对应的提示词直接把 AGENTS.md 直接修改」。
@@ -933,6 +967,8 @@ export default {
                 return `场景「${ref.label || ''}」${ref.active ? '（已启用）' : ''}绑定了它`;
             if (ref && ref.kind === 'restore')
                 return '它就是退出场景后要恢复的全局提示词';
+            if (ref && ref.applied === true)
+                return '它正被「应用」在 ~/.dsh/AGENTS.md 里';
             return '~/.dsh/AGENTS.md 当前内容就是它';
         };
         // ---------- path discovery ----------
@@ -1546,6 +1582,14 @@ export default {
                 extractTurnsFromEvents: extractExportTurns,
                 serializeTurns: serializeTranscript,
             }),
+            // 回收站保留期（ops/trash-retention.ts）：trash-retention-get（只读）/
+            // trash-retention-set（写 + 冻结；成功后立即扫一次，见该文件文件头）。
+            // 清扫本身**不在这里**——它是引擎的后台动作，由 trashRetention 域自己挂启动与周期。
+            ...buildTrashRetentionOps({
+                read: trashRetention.read,
+                write: trashRetention.write,
+                sweep: trashRetention.sweep,
+            }),
             // rules 域里要走「场景 ↔ 全局基线同步」包装的四个写 op（ops/scene-sync.ts 提供）。
             // 必须排在 ...memoriesService.ops 之后 —— 这里是显式覆盖同名 op，不是新增。
             ...buildSceneSyncOps({
@@ -2168,7 +2212,15 @@ export default {
             const denied = await frozenGate('agentsmd-apply', { id });
             return denied ? { ok: false, error: denied } : applyPresetGuarded(id);
         };
-        buildPromptTools({ ...toolDeps, promptOps: auditOps(promptOps), applyPresetGuarded: applyPresetForModel, promptsDir });
+        // 取消应用同理：`agentsmd-unapply` 在冻结清单里，模型侧不经 op 表直调就要在这里显式过
+        // 冻结闸（与 apply 同一形状）—— 少了这一层，锁着场景时模型仍能撤掉当前基线。
+        const unapplyPresetForModel = async () => {
+            const denied = await frozenGate('agentsmd-unapply', {});
+            return denied
+                ? { ok: false, error: denied }
+                : promptOps['agentsmd-unapply']();
+        };
+        buildPromptTools({ ...toolDeps, promptOps: auditOps(promptOps), applyPresetGuarded: applyPresetForModel, unapplyPreset: unapplyPresetForModel, promptsDir });
         buildMemoryTools({ ...toolDeps, rulesOps: auditOps(memoriesService.ops) });
         // 场景族（tools/scene.ts）：列场景与档案（`_list`）+ 建场景 / 写档案 / 绑提示词（`_save`）
         // + 进入与退出（`_switch`）。

package/lib/mcp/manager.js

@@ -18,11 +18,11 @@
 // 其余 14 项（ensurePaths / withWriteLock / readPatch / pluginInventory / memoriesService 等）
 // 由 deps 显式传入。
 import { clearRuntimeNote, noteRuntime } from '../compat/runtime-notes.js';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
 import { MCP_CLIENT_MODULE, MCP_TOOL_PREFIX, ambiguousServerNames, looksLikeMcpPrefixDrift, serverNameCandidates, splitMcpToolName } from '../host-names.js';
 import { hubPath } from '../hub.js';
 import { planOverrideCompaction } from './override-blocks.js';
-// 配置体检的探测（PATH 查询 / 端点连通性 / 检查清单 + mcpm-inspect op），2026-10-01 剥出。
-import { createInspectProbe } from './inspect-probe.js';
 import { createMcpStateCatalog } from './state-section.js';
 import { createToolVisibility } from './tool-visibility.js';
 import { appendBlock, buildDisableBlock, buildInsertBlock, insertEntryIds, parseRows, removeEntryAll, removeMarked, spliceRanges, splitLines, } from './patch-yaml.js';
@@ -1519,15 +1519,19 @@ export function createMcpManager(deps) {
             return { ok: true, removed: total, ids: removed, files };
         });
     }
-    // ---------- 配置体检的探测（0.15.0 B1；0.16.5 起含端点探测）----------------------
-    // 正文 2026-10-01 整段搬到 ./inspect-probe.js（一字未改，只把闭包作用域的几个名字改走
-    // deps）。那段「对补丁只读、`where`/`which` 只查命令名绝不执行配置里的命令、复用列表结果
-    // 但不回写任何缓存」的口径连同理由一起搬过去了，见那边的文件头。
-    const { mcpmInspect } = createInspectProbe({
-        ensurePaths, readPatch, message, normalizeRow, mcpmList,
-    });
     // ---------- 配置的导出 / 导入 ----------
-    async function mcpmExport() {
+    /**
+     * `args.outDir`（可选）：给了就写到该目录下的 `mcp-export.json`，不给则照旧写 hub 侧车。
+     *
+     * 判据与 `bundle-export` / `snapshot-export` 完全一致（必须绝对路径）：相对路径会落到
+     * 进程 CWD，那是猜。用户 2026-10-12：「mcp 的导出缺少选择导出目录」—— 此前这一档只能
+     * 落到 `~/.dsh/tool-management/mcp-export.json`，界面上没有任何可改的出口。
+     *
+     * `args.dryRun`（可选）：只算 JSON、**不落盘**。界面打开弹窗时先用它取预览，真正落盘
+     * 由用户点「导出到目录」触发 —— 与其余四个导出弹窗同一套交互（不开弹窗就写文件是副作用）。
+     * `snapshot-export` 走的是不带 dryRun 的老路径，行为不变。
+     */
+    async function mcpmExport(args) {
         const p = await ensurePaths();
         const list = await mcpmList();
         const rows = (list.rows || []).filter((r) => r.level !== 'loader').map((r) => ({
@@ -1544,16 +1548,24 @@ export function createMcpManager(deps) {
         }));
         const payload = { exportedAt: new Date().toISOString(), rows };
         const json = JSON.stringify(payload, null, 2);
+        if (args && args.dryRun)
+            return { ok: true, json, savedTo: null };
+        const outDir = String((args && args.outDir) || '').trim();
+        if (outDir && !/^([A-Za-z]:[\\/]|\\\\|\/)/.test(outDir))
+            return { ok: false, error: '导出目录需为绝对路径' };
         let savedTo = null;
         try {
-            const abs = mcpSidecar(MCP_EXPORT_FILE);
-            // 用 `writeJsonFile`（直写 hub 侧车）而**不是** `writePatch`（2026-09-30 审查 P1-3）：
+            const abs = outDir ? join(outDir, MCP_EXPORT_FILE) : mcpSidecar(MCP_EXPORT_FILE);
+            // 用 `writeJsonFile`（直写 JSON）而**不是** `writePatch`（2026-09-30 审查 P1-3）：
             // `writePatch` 是宿主**补丁文件**的写口，写前会跑 `checkPatchWrite` 的官方方言校验
             // （顶层必须是 YAML 数组），而这里写的是 hub 里一份 JSON **对象** —— 校验必然失败、
             // 异常被下面的 catch 吞掉，于是 `savedTo` 恒为 null，界面显示"没能落盘（hub 目录写入
             // 失败）"，**诊断是错的**（真实原因是方言校验器拒收 JSON 对象）。而且 `writePatch`
             // 自己的调用面纪律（`index.ts`：「不写宿主配置的动作也不该调用它」）本就排除了它 ——
             // 本处是唯一一个传 hub 路径的调用点。顺带省掉一次 `danger-full-access` 策略升级。
+            // `writeJsonFile` 不建父目录（hub 路径总是已存在），所以自定义目录要自己 mkdir。
+            if (outDir)
+                await mkdir(outDir, { recursive: true });
             await writeJsonFile(abs, payload);
             savedTo = abs;
         }
@@ -1792,7 +1804,6 @@ export function createMcpManager(deps) {
             'mcpm-compact': mcpmCompact,
             'mcpm-export': mcpmExport,
             'mcpm-import': mcpmImport,
-            'mcpm-inspect': mcpmInspect,
         },
         readDisabledTools,
         readKnownMcpTools,

package/lib/mcp/secret-guard.js

@@ -15,7 +15,7 @@
 // 「那几段」= **userinfo / 查询串 / 片段**三处（2026-09-30 审查 F5）：`new URL()` 把 userinfo
 // 与 fragment 存在 `username/password` 与 `hash` 里，`toString()` 原样带出。只换 `search`
 // 的话，`https://user:pass@host/mcp`（Basic-Auth 形态）与 `https://host/mcp#access_token=…`
-// 会整条原样返回 —— 而这两条路正是免令牌出口（`mcpm-list` / `mcpm-inspect` / 模型工具 /
+// 会整条原样返回 —— 而这两条路正是免令牌出口（`mcpm-list` / 模型工具 /
 // 快照导出）。路径与主机**不动**：它们是该服务的身份，算进来会把真 URL 误判成打码值。
 //
 // 判据为什么可以这么硬：打码值只可能表示"用户没改这一项"，绝不可能表示"用户想把它设成这个"。
@@ -170,7 +170,7 @@ function maskUrlPartsByString(url) {
  * fragment 存在 `username/password` 与 `hash` 里，`toString()` 会原样带出 ——
  * 只替换 `search` 的话，`https://user:pass@host/mcp` 与 `https://host/mcp#access_token=…`
  * 会**整条原样返回**（后者连 `?` 都没有），而这两条路正是免令牌出口
- * （`mcpm-list` / `mcpm-inspect` / 模型工具 / 快照导出）。Basic-Auth 形态的凭据就此明文可见。
+ * （`mcpm-list` / 模型工具 / 快照导出）。Basic-Auth 形态的凭据就此明文可见。
  */
 export function maskUrlQuery(url) {
     if (!url)

package/lib/memories/constants.js

@@ -188,5 +188,12 @@ export const fail = (code, error, params) => (params ? { ok: false, error, code,
  * 旧名 `rules-index.json` / `rules-trash/` 由 hub 的启动迁移搬过来（见 hub.ts）。
  */
 export const MEMORIES_INDEX_FILE = 'memories-index.json';
-/** 记忆回收站目录名（hub 根下）。ops 分域后 trash 域要用，故与索引文件名一起放在这一层。 */
-export const MEMORIES_TRASH_DIR = 'memories-trash';
+/**
+ * 记忆回收站目录（**hub 内相对路径**，故带 `trash/` 段）。
+ *
+ * 2026-10-10 起与其余五类同处一处：`hub/trash/memories-trash/`。此前它是 hub 根下的
+ * `memories-trash/`，独立于 `trash/` —— 界面上六类早就统一成一个「回收站」了，落点却分两处，
+ * 按 `trash/` 写备份 / 迁移脚本会漏掉这一类（条目数最多的那类）。
+ * 老位置由 hub 的启动迁移搬过来（见 `hub.ts` 的 `HUB_RENAMES`），只搬不删。
+ */
+export const MEMORIES_TRASH_DIR = 'trash/memories-trash';

package/lib/memories/service.js

@@ -65,7 +65,7 @@ import { deriveFromDoc, projectRule, relocateLegacyLayout, buildSnapshot, probeS
  * 场景/记忆根目录名（$DSH_HOME 下），集中在 `tool-management/` 一个目录内：
  *   - `memories/<场景>/…`    记忆正文真源
  *   - `..`（即 tool-management 根）侧车：memories-index.json（内含 `scenes` 切片 = 场景记录
- *     的**真源**）/ skills-state.json / trash/ / memories-trash/
+ *     的**真源**）/ skills-state.json / trash/（六类回收站，含 `trash/memories-trash/`）
  *
  * `scenes/`（`SCENES_DIR`）是 v0.3 遗留的**空壳**：只创建、只回显路径，没有任何读写。
  * 别把场景记录的位置写成它。
@@ -728,6 +728,7 @@ export function createMemoriesService(ctx, deps) {
     // 抽出去的 ops/*.ts 只通过它访问闭包，任何漏挂都会在 tsc 阶段报「Cannot find name」。
     const rc = {
         stateDir, memoriesRoot, scenesRoot, maxBytes,
+        ...(deps.skillsTrashDir ? { skillsTrashDir: deps.skillsTrashDir } : {}),
         snapshot, invalidateSnapshot, sceneMemory, scenePrompt,
         parseId, locateRule, refuseOutsideRoot, buildProjected, sceneRows,
         copyIntoMemoriesTrash, listAttachments, serializeRuleFile, serializeUpdatedFile,
@@ -759,6 +760,10 @@ export function createMemoriesService(ctx, deps) {
         'rules-remove': (args) => runWrite(() => trashOps.rulesRemove(args || {})),
         'rules-restore': (args) => runWrite(() => trashOps.rulesRestore(args || {})),
         'rules-trash-list': () => trashOps.rulesTrashList(),
+        // 回收站「详情」：跨域只读预览（记忆 / 技能 / 提示词 / 人设 / 场景五类的条目都能查）。
+        // 只 lstat + 递归读文件，不写任何东西 ⇒ 不进写队列、也不 refresh 快照。
+        // 登记在 op-registry 的 `readonly` 一档：**锁定期间照样能看**（锁的是写，不是看）。
+        'trash-preview': (args) => trashOps.trashPreview(args || {}),
         'rules-trash-remove': (args) => runWrite(() => trashOps.rulesTrashRemove(args || {})),
         'rules-attach': (args) => runWrite(() => memoryOps.rulesAttach(args || {})),
         'rules-detach': (args) => runWrite(() => memoryOps.rulesDetach(args || {})),

package/lib/op-registry.js

@@ -57,12 +57,6 @@ export const OP_REGISTRY = Object.freeze({
     // 会停在启用态 —— 是写不是读。（0.6.0 / 0.7.0 各有漏列前科，见文件头。）
     'mcpm-tools-refresh': { write: true },
     'mcpm-tools': { readonly: true },
-    // 配置体检：只读补丁文件 + 一次 PATH 查询（`where`/`which`，不执行配置里的命令）。
-    // 回的是检查项 id + 少量**打码后**的字段值（URL 查询串走 `maskUrlQuery`，与 `mcpm-list`
-    // 同口径；`command` 明文，理由同 `mcpm-list`：命令名不是凭据，`args` 两边都不回）。
-    // 与 `mcpm-list` 同档，不带令牌 —— 0.16.6 之前这里回的是 URL 原文，等于让免令牌的请求
-    // 拿到 `?api_key=…`，绕过了 `mcpm-reveal` 那道防线（审查 P0-5，0.17.0 修）。
-    'mcpm-inspect': { readonly: true },
     // ── 技能域（22，含内联的 skill-open）───────────────────────────────────────
     'skill-state': { annotatesLock: true },
     'skill-detail': { readonly: true },
@@ -88,6 +82,9 @@ export const OP_REGISTRY = Object.freeze({
     'skill-trash-delete': { serviceWrite: true, frozen: true },
     'skill-custom-add': { serviceWrite: true, frozen: true },
     'skill-custom-remove': { serviceWrite: true, frozen: true },
+    // 永久删除一条**按约定发现**的来源记录（agents / codex / claude）：只写本地状态里的
+    // `forgottenSources`，磁盘源文件一个字节都不动。与 `skill-custom-remove` 同权。
+    'skill-source-forget': { serviceWrite: true, frozen: true },
     // 打开系统编辑器改文件：不改宿主状态，但它是"界面按钮"性质的写入口，按写门禁。
     'skill-open': { write: true },
     // ── 记忆与场景域（27：memories 24 + archive-engine 3）──────────────────────
@@ -96,6 +93,9 @@ export const OP_REGISTRY = Object.freeze({
     'rules-budget': { readonly: true },
     'rules-diagnose': { readonly: true },
     'rules-trash-list': { readonly: true },
+    // 回收站「详情」：跨域只读（五类回收站共用一条，域由 args.domain 区分）。只读 → 不冻，
+    // 锁定的场景里照样能看一眼"删掉的是什么"（看不是改，与「编辑页可打开」同一条口径）。
+    'trash-preview': { readonly: true },
     'rules-create': { serviceWrite: true, frozen: true },
     'rules-update': { serviceWrite: true, frozen: true },
     'rules-remove': { serviceWrite: true, frozen: true },
@@ -140,7 +140,7 @@ export const OP_REGISTRY = Object.freeze({
     'subagent-toggle': { serviceWrite: true, frozen: true, syncsArchive: true },
     'subagent-trash-restore': { serviceWrite: true, frozen: true },
     'subagent-trash-delete': { serviceWrite: true, frozen: true },
-    // ── 提示词域（11）──────────────────────────────────────────────────────────
+    // ── 提示词域（12）──────────────────────────────────────────────────────────
     'agentsmd-list': { annotatesLock: true },
     'agentsmd-read': { readonly: true },
     'agentsmd-get-current': { readonly: true },
@@ -149,6 +149,8 @@ export const OP_REGISTRY = Object.freeze({
     'agentsmd-update': { write: true, frozen: true },
     // apply 写全局 AGENTS.md = 换掉生效基线。
     'agentsmd-apply': { write: true, frozen: true },
+    // unapply 同样写全局 AGENTS.md（把它恢复成链起点，即开始应用之前的那份内容）→ 与 apply 同档。
+    'agentsmd-unapply': { write: true, frozen: true },
     'agentsmd-remove': { write: true, frozen: true },
     'agentsmd-import': { write: true, frozen: true },
     'agentsmd-trash-restore': { write: true, frozen: true },
@@ -188,6 +190,19 @@ export const OP_REGISTRY = Object.freeze({
     'bundle-export': { write: true },
     // 新增一条宿主工作区登记 —— 改的是宿主侧的登记，不是插件自己的侧车。
     'history-workspace-register': { write: true },
+    // ── 回收站保留期（2）──────────────────────────────────────────────────────
+    // 与 History 页的保留期（上面那两条）是同一个功能出现在两个页面：同一份侧车形状
+    // （`{retentionDays, updatedAt}`）、同一条到期判据、同一个「改设置即重置倒计时」语义。
+    // 读侧是纯读（客户端 boot 时必问一次拿当前值），与 `history-retention-get` 同档。
+    'trash-retention-get': { readonly: true },
+    // 写侧**比 `history-retention-set` 多一层冻结**，这是一处刻意的不同：
+    //   · 历史页那条只影响「已归档会话」—— 归档是用户主动收进去的，删了就是删了；
+    //   · 这一条成功后立即扫一次，**能永久删掉六类回收站条目里的任意一条**，而六条手工
+    //     删除 op（`skill-trash-delete` / `agentsmd-trash-delete` / `subagent-trash-delete` /
+    //     `quickprompt-trash-delete` / `rules-trash-remove`）全都是冻结的。
+    //   一个能删掉所有回收站条目的 op 却比单条删除更宽松，等于给冻结开了后门。
+    //   （`scene-trash-delete` 是唯一没标冻结的那条，属既有不一致，不在本次范围。）
+    'trash-retention-set': { write: true, frozen: true },
     // ── 兼容 / 注入 / 备份 / 流水 / 迁移快照（11）────────────────────────────────
     'compat-status': { readonly: true },
     // 「最近改动」流水的读侧：只读 hub 里的 `audit.jsonl`（内容只有对象名，见 audit-log.ts 第 ① 条）。

package/lib/ops/prompts.js

@@ -71,10 +71,44 @@ export function buildPromptOps(deps) {
         },
         // 应用 = 写全局基线文件；场景接管期间只放行「场景绑定的那一份」（见 applyPresetGuarded）。
         'agentsmd-apply': (args) => deps.applyPresetGuarded(String((args && args.id) || '')),
+        // 取消应用 = **回到链起点**（这一串应用/取消往复开始之前的状态）：起点有内容就把
+        // `__last-applied__/AGENTS.md` 写回去，起点文件不存在就把文件删掉（`removed: true`）。
+        // 连续应用过 A、B 时是**一步回到起点**，不是只退一步 —— 与场景基线同一条口径
+        // （见 `service.ts` 的 `backupGlobal`）。
+        // 它是「生效中」那颗开关的**关**方向 —— 此前只有「应用」没有反向动作，于是「只有一份预设
+        // 且它生效中」时开关关不掉、删除又被引用拦着（2026-10-10 实测反馈）。
+        //
+        // 用户 2026-10-10 第二次反馈「取消应用，AGENTS.md 还是存在」暴露了另一半：`backupGlobal()`
+        // 原先在文件不存在时**什么都不写**，"起点不存在"因此不可恢复，取消应用恒判 noBackup，
+        // 而这里给出的出路「删除这份预设」不成立（remove 不碰 AGENTS.md）。现在那个事实由
+        // `__last-applied__/absent.json` 记着，删文件这一支才走得通。
+        // 第三次反馈（同一天）「新建 a、b 两份提示词，启动 a，再启动 b，不启动 a 也不启动 b，
+        // AGENTS.md 没有消失」则是这个标记**被后续写入抹掉**：`backupGlobal` 原先每笔都覆盖链
+        // 起点槽位，第 ③ 步「应用 b」就把"起点不存在"刷成了 a 的内容。改成链起点只写一次。
+        //
+        // 场景驱动时**拒绝**：那时基线归场景管（生效中的是场景绑定的那一份），在这里撤销只会被
+        // 下一次场景同步写回去，而且「取消应用」对场景绑定也不成立 —— 要解除得去场景页改绑定。
+        'agentsmd-unapply': async () => {
+            const driver = await deps.scenePromptSync.driver();
+            if (driver) {
+                return {
+                    ok: false,
+                    code: 'error.agentsMd.unapplyWhileScene',
+                    error: `场景「${driver.label}」正在驱动全局基线，不能在这里取消应用：先退出场景，或到场景页改掉它的提示词绑定。`,
+                    params: { scene: driver.label },
+                };
+            }
+            const res = await deps.promptsService.unapply();
+            if (res && res.ok === false) {
+                // 「没有链起点」是一种**确定的**状态（不是故障）：AGENTS.md 的当前内容不是由
+                // 「应用」写进去的（首次打开时播种的 default 就是这样）。单给一个 code，界面才能
+                // 把出路说清楚（应用别的预设 / 直接编辑 AGENTS.md），而不是丢一句写盘失败。
+                return res.noBackup ? { ok: false, code: 'error.agentsMd.noUnapplyBackup', error: res.error } : res;
+            }
+            return res;
+        },
         'agentsmd-get-current': () => deps.promptsService.getCurrent(),
-        // 删除：**被引用的那份一律拒绝**（用户裁定，2026-09-16 扩到引用清单）。三类引用：
-        // 场景绑定（含恒常的 `_shared` / `global`）、`~/.dsh/AGENTS.md` 的当前内容、
-        // 进场景前保存的基线（退出场景后要恢复的那一份）。拒绝时逐条说明「谁在用」，
+        // 删除：**场景绑定**与**当前应用的那份**拦得住（判据见下方注释）。拒绝时逐条说明「谁在用」，
         // 用户知道该先改哪里。引用清单由 scene-prompt-sync 与显示/注入同源算出。
         //
         // 探测**失败**时改为拒绝（2026-09-30 审查 F13）。原来的取舍是「放行并记 warn：删预设不动
@@ -96,13 +130,36 @@ export function buildPromptOps(deps) {
                     params: { id },
                 };
             }
-            const why = refs.get(id) || [];
-            if (why.length) {
-                const refsText = why.map(deps.promptRefReason).join('；');
+            // 删除保护认两类**真依赖**（判据是「删掉它会不会让别处静默坏掉」或「会不会留下一个
+            // 用户无法理解的中间态」）：
+            //   ① 场景绑定 → 会静默坏掉：场景驱动靠 `presetId` 去读预设正文，读不到 `driver()`
+            //      就返回 null，场景静默失效（AGENTS.md 停在场景态，用户看到的是"什么都没做"）。
+            //   ② **当前应用的**那份（`file` + `applied`，见下）→ 会留下中间态：删掉之后
+            //      `~/.dsh/AGENTS.md` 内容一字不变、**照旧生效**，但界面上再没有任何预设对应它。
+            //      用户看到的是「我把它删了，怎么全局提示词还在？」（2026-10-10 用户反馈：
+            //      「当前应用的提示词如果直接删除，AGENTS.md 还存在，当前应用的提示词应该不能删除」）。
+            //      拦住并引导先「取消应用」，这一步会把文件恢复成链起点（开始应用之前的状态），
+            //      之后就能删了。
+            //
+            // **不拦**的两类（各自都有明确的理由，别顺手加回来）：
+            //   - `file` 但没有 `applied`（首次打开提示词页时自动播种出来的 default）：它内容与
+            //     AGENTS.md 相同、界面标「文件里是它」，却从未发生过写入。删掉它完全合理（那只是
+            //     一份副本），而**拦它就是死路** —— 那份没有链起点可回，取消应用关不掉。
+            //   - `restore`（退出场景要恢复的那一份）：恢复走的是 `scene-baseline.json` 里存下的
+            //     **正文**（scene-prompt-sync 的 `restore(saved.content)`），不读预设目录。
+            // 2026-09-16 的裁定是三类一律拦，那条规则在「只有一份预设且它生效中」时构成**死锁**：
+            // 开关关不掉（基线没有"全部不应用"这一态）、引用又解不开。现在开关能关了（取消应用），
+            // 拦 ② 才有出路 —— 取消应用会把 `__applied__.json` 清成 null，`applied` 随之变 false。
+            const blocking = (refs.get(id) || []).filter((r) => r.kind === 'scene' || (r.kind === 'file' && r.applied === true));
+            if (blocking.length) {
+                const refsText = blocking.map(deps.promptRefReason).join('；');
+                const hasScene = blocking.some((r) => r.kind === 'scene');
+                const hasFile = blocking.some((r) => r.kind === 'file');
+                const escape = [hasScene ? '到场景页换绑提示词、或退出场景' : '', hasFile ? '先点左边那颗开关「取消应用」' : ''].filter(Boolean).join('；');
                 return {
                     ok: false,
                     code: 'error.agentsMd.referenced',
-                    error: `「${id}」仍被引用，不能删除：${refsText}。先改掉引用（换绑提示词 / 退出场景 / 应用别的预设）再删除。`,
+                    error: `「${id}」不能删除：${refsText}。先解除引用再删 —— ${escape}。`,
                     params: { id, refs: refsText },
                 };
             }

package/lib/ops/sessions.js

@@ -18,6 +18,31 @@ import { isValidPresetId } from '../prompts/preset-id.js';
 import { defaultPersonasDir, validPersonaName } from '../subagents/service.js';
 import { isInsideRoot } from '../paths.js';
 import { planMemoryExport } from '../memories/service.js';
+/**
+ * Linux 的桌面目录：按 XDG 用户目录规范从 `user-dirs.dirs` 里读 `XDG_DESKTOP_DIR`。
+ *
+ * 为什么需要它：中文 / 日文等本地化环境里，桌面目录的**真名**不是 `Desktop`，而是
+ * `桌面` / `デスクトップ` —— 这时 `join(homedir(), 'Desktop')` 探不到，我们会白白退回主目录。
+ * 配置文件里的值形如 `"$HOME/桌面"`（含 `$HOME` 变量与引号），这里做最小解析：
+ * 去引号、把 `$HOME` / 前导 `~` 换成真实主目录。
+ *
+ * 读不到 / 没有这一行 / 值不是绝对路径 → 返回 undefined，调用方继续试下一个候选。
+ * 纯只读，任何异常都吞掉（这只是"默认值填哪儿"的增强，不该影响导出本身）。
+ */
+async function xdgDesktopDir() {
+    try {
+        const base = String(process.env.XDG_CONFIG_HOME || '').trim() || join(homedir(), '.config');
+        const text = await readFile(join(base, 'user-dirs.dirs'), 'utf8');
+        const m = /^\s*XDG_DESKTOP_DIR\s*=\s*"([^"]*)"/m.exec(text);
+        if (!m)
+            return undefined;
+        const raw = m[1].replace(/^\$HOME(?=[\\/]|$)/, homedir()).replace(/^~(?=[\\/]|$)/, homedir());
+        return raw && (raw.startsWith('/') || /^[A-Za-z]:[\\/]/.test(raw)) ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function buildSessionOps(deps) {
     return {
         // History（归档会话管理）ops。只读：history-list / history-retention-get；
@@ -114,16 +139,35 @@ export function buildSessionOps(deps) {
                 return { ok: false, error: deps.message(e) };
             }
         },
-        // 导出默认目录：桌面（存在时）否则用户主目录。只读，不门控。
+        // 导入 / 导出的默认目录：桌面（存在时）否则用户主目录。只读，不门控。
+        //
+        // 名字里带 `history` 是历史原因，但它早就是**全插件共用的**默认 IO 目录：整机迁移导出
+        // / 快照位置 / 会话导出 / MCP JSON 导出 / 技能自定义来源目录都取这一份。之所以必须问宿主、
+        // 不能让客户端写死：桌面在哪取决于**跑宿主的那台机器 + 那个用户**——
+        //   Windows  C:\Users\<用户名>\Desktop
+        //   macOS    /Users/<用户名>/Desktop
+        //   Linux    /home/<用户名>/Desktop，且桌面目录**未必存在**（也可能是本地化名字，
+        //            例如中文环境下的 ~/桌面 —— 那种走 XDG 配置，见下）
+        // 全部用 `os.homedir()` 起算，换用户 / 换系统自动跟着走。
         'history-export-defaults': async () => {
             let dir = homedir();
-            try {
-                const desktop = join(homedir(), 'Desktop');
-                const st = await stat(desktop);
-                if (st.isDirectory())
-                    dir = desktop;
+            // Linux 的桌面目录名可能被本地化：先按 XDG 用户目录规范问一次，再退回惯用的 Desktop。
+            // 两条都探不到就用主目录 —— 主目录一定存在，且导出的只是子目录，不影响可用性。
+            const candidates = [join(homedir(), 'Desktop')];
+            if (process.platform === 'linux') {
+                candidates.unshift(await xdgDesktopDir());
+            }
+            for (const candidate of candidates) {
+                if (!candidate)
+                    continue;
+                try {
+                    if ((await stat(candidate)).isDirectory()) {
+                        dir = candidate;
+                        break;
+                    }
+                }
+                catch { /* 这个候选不可用 → 试下一个 */ }
             }
-            catch { /* 桌面路径不可用 → 回退主目录 */ }
             return { ok: true, defaultDir: dir };
         },
         // 列出目录的子目录，供客户端「选择文件夹」弹窗逐级浏览。dir 为空时返回根
@@ -321,6 +365,17 @@ export function buildSessionOps(deps) {
                 return { ok: false, error: '当前环境不支持重新登记工作区（registry 未实现 registerWorkspace）' };
             }
             const title = args && args.title ? String(args.title) : undefined;
+            // 目录已被删除时提前拦下（用户 2026-10-12：工作区文件夹删掉后不该还能「重新登记」）。
+            // 宿主 registerWorkspace 内部的 realpath 本来就会拒绝，但报错文本是底层的；这里给
+            // 一句能直接读懂的提示。界面在 dirMissing 时已不再渲染该按钮，这条是防御性兜底。
+            try {
+                const st = await stat(path);
+                if (!st.isDirectory())
+                    return { ok: false, error: '目录已不存在，无法重新登记：' + path };
+            }
+            catch {
+                return { ok: false, error: '目录已不存在，无法重新登记：' + path };
+            }
             try {
                 const workspace = await registry.registerWorkspace(path, title);
                 return { ok: true, workspace };