dsh-plugin-tool-management 0.19.1 → 0.20.0

package/lib/skills/core.js

@@ -124,7 +124,15 @@ export async function addCustomRoot(inputPath, label, log) {
     if (current.writable === false)
         return invalidManagerStateWrite();
     const existing = customRootsFromState(current.state);
+    // 「永久删除」过的来源不再参与重叠判定：用户在回收站里把它彻底删掉之后，要能把同一个
+    // 目录**作为自定义来源重新加回来**（`confirm.source.forget.desc` 那句「需要时只能重新
+    // 添加这个目录」说的就是这条路）。不放过它的话，那句提示就是一句空话 —— 路径仍被
+    // `userRoots()` 认领，添加只会吃一个「目录与已有技能来源重叠」。
+    const forgotten = new Set(Array.isArray(current.state.forgottenSources)
+        ? current.state.forgottenSources
+        : []);
     for (const known of userRoots()
+        .filter((root) => !forgotten.has(root.key))
         .map((root) => root.path)
         .concat(existing.map((root) => root.path))) {
         if (await pathsOverlap(canonical, known))
@@ -189,6 +197,59 @@ export async function removeCustomRoot(key, log) {
         log("custom-remove", `移除自定义技能目录 ${target.path} (${clean})`);
     return { key: clean, path: target.path };
 }
+/**
+ * 永久删除一条**按约定发现**的来源记录（回收站 → 目录 里那颗「永久删除」）。
+ *
+ * 与 `removeCustomRoot` 的分工：那条管的是"用户手加的自定义目录"，删掉 `customRoots` 里
+ * 的记录就完事；这条管的是 `agents` / `codex` / `claude` 这类**由 `userRoots()` 按约定推导**
+ * 出来的来源 —— 它们不在状态文件的 customRoots 里，路径每次启动都会重新算出来，所以只把 key
+ * 从 `removedSources` 里摘掉的话，下一轮它又原样回来了。
+ *
+ * 于是另记一份 `forgottenSources`：进了这份名单的来源既不读取（`activeUserRoots` 摘掉它）、
+ * 也不列出（`state()` 的 roots 过滤掉它）—— 等于从插件里彻底消失。用户想反悔有两条路：
+ * 清掉状态文件里这个 key，或者把它**作为自定义来源重新添加**（`addCustomRoot` 的重叠判定
+ * 已经跳过已忘记的来源，所以那条路真的走得通）。
+ *
+ * **磁盘上的源文件一个字节都不动** —— 这条函数自始至终只写状态文件。
+ */
+export async function forgetSource(key, log) {
+    const clean = String(key == null ? "" : key).trim();
+    const root = userRoots().find((item) => item.key === clean);
+    if (!root)
+        return {
+            ok: false,
+            error: `未知的来源: ${clean}`,
+            code: "error.root.unknown",
+            params: { root: clean },
+        };
+    // 默认来源（dsh / hub / 官方）必须读取：它们不在移除候选里，也不该能被永久删除。
+    if (isDefaultSkillSource(clean))
+        return {
+            ok: false,
+            error: `默认来源不能永久删除: ${clean}`,
+            code: "error.root.default",
+            params: { root: clean },
+        };
+    const current = await readManagerState();
+    if (current.writable === false)
+        return invalidManagerStateWrite();
+    const forgotten = new Set(Array.isArray(current.state.forgottenSources)
+        ? current.state.forgottenSources
+        : []);
+    forgotten.add(clean);
+    current.state.forgottenSources = [...forgotten].sort();
+    // 「已移除」那条记录一起摘掉：留着它只会在状态文件里多一条指向"已经不存在"的脏键，
+    // 而且归一化那一步本来也会把它去掉 —— 没理由写进去（与 removeCustomRoot 同一口径）。
+    if (Array.isArray(current.state.removedSources))
+        current.state.removedSources = current.state.removedSources.filter((item) => item !== clean);
+    delete current.state.sources[clean];
+    delete current.state.disabledSkills[clean];
+    delete current.state.enabledSkills[clean];
+    await writeManagerState(current.state);
+    if (log)
+        log("source-forget", `永久删除来源记录 ${clean}: ${root.path}`);
+    return { root: clean, path: root.path };
+}
 /**
  * 从活动 Session cwd 推导项目技能根。只接受宿主上可解析的绝对目录，
  * 同一项目的多个 Session 会折叠到同一组稳定 key，避免跨 workspace 合并同名技能。
@@ -434,17 +495,22 @@ async function visibleEntryForRoot(root, name) {
  */
 /** 状态文件已存在但不可用时一律关闭外部来源，避免损坏配置重新暴露技能。 */
 /**
- * 参与扫描的来源 = 全部来源 − 用户已移除的。
+ * 参与扫描的来源 = 全部来源 − 用户已移除的 − 用户已永久删除的。
  *
  * 「移除来源」与「停用来源」是两件事：
  *   - 停用（`sources[key] = false`）：仍然读取并列出技能，只是不可调用；
  *   - 移除（出现在 `removedSources`）：**连目录都不读**，技能不出现在列表里，
  *     也不参与 provider 候选。源文件不动，清掉这个标记即恢复。
+ *
+ * 「永久删除」（`forgottenSources`）是移除的**终点**：这条来源从插件里彻底消失 ——
+ * 不再读取（与移除同）、并且连"已移除"那行记录也不再出现（见 `state()` 的 roots 过滤）。
+ * 两者都**不碰磁盘**。
  */
 export function activeUserRoots(stateValue) {
     const state = stateValue;
     const removed = new Set(state && Array.isArray(state.removedSources) ? state.removedSources : []);
-    return userRoots().filter((root) => !removed.has(root.key));
+    const forgotten = new Set(state && Array.isArray(state.forgottenSources) ? state.forgottenSources : []);
+    return userRoots().filter((root) => !removed.has(root.key) && !forgotten.has(root.key));
 }
 /** 裁剪自定义来源列表：非法条目丢弃，key/path 绑定校验，label 规整。 */
 /**

package/lib/skills/manager-state.js

@@ -269,6 +269,8 @@ export function defaultManagerState() {
         // 也不参与 provider 候选）。与「停用来源」不同——停用仍列出技能、只是不可调用。
         // 源文件一个字节都不动；清空这个数组即可恢复。
         removedSources: [],
+        // 用户从回收站「永久删除」的来源：连"已移除"这条记录都不再出现（见 core-types 的说明）。
+        forgottenSources: [],
     };
 }
 export function validStateSkillName(name) {
@@ -324,6 +326,12 @@ export function validManagerStateDocument(value) {
             value.removedSources.some((key) => typeof key !== "string" || key.length === 0 || key.length > 128))
             return false;
     }
+    // 永久删除的来源：同上（可选字段、同样的 key 形状）。
+    if (value.forgottenSources !== undefined) {
+        if (!Array.isArray(value.forgottenSources) ||
+            value.forgottenSources.some((key) => typeof key !== "string" || key.length === 0 || key.length > 128))
+            return false;
+    }
     // 同名首选表：可选字段；只校验容器与值类型，键值逐条在 normalize 里裁剪（见 validPreferredSkillName）。
     if (value.preferredSkills !== undefined) {
         if (!value.preferredSkills ||
@@ -426,6 +434,23 @@ export function normalizeManagerState(value) {
                 !isDefaultSkillSource(key))),
         ].sort();
     }
+    // 永久删除的来源：同一套口径（已知 key、非默认来源），另外**从 removedSources 里摘掉**
+    // —— 一条来源要么"已移除"、要么"已永久删除"，同时挂在两份名单上只会让两处显示打架。
+    {
+        const raw = Array.isArray(value.forgottenSources) ? value.forgottenSources : [];
+        const known = new Set([
+            ...userRoots().map((root) => root.key),
+            ...customKeys,
+        ]);
+        const forgotten = [
+            ...new Set(raw.filter((key) => typeof key === "string" &&
+                known.has(key) &&
+                !isDefaultSkillSource(key))),
+        ].sort();
+        normalized.forgottenSources = forgotten;
+        if (forgotten.length)
+            normalized.removedSources = normalized.removedSources.filter((key) => !forgotten.includes(key));
+    }
     return normalized;
 }
 export function normalizeCustomRoots(value) {
@@ -618,11 +643,17 @@ export async function state(options = {}) {
     const removedKeys = new Set(Array.isArray(policyResult.state.removedSources)
         ? policyResult.state.removedSources
         : []);
+    // 「永久删除」过的来源（回收站 → 目录 里那条记录的终点）：连行都不留 —— 界面不该再有
+    // 它的位置，「恢复读取」也无从谈起（用户 2026-10-12 要求 codex / Claude 也能永久删除）。
+    // 注意它同时也在 `activeUserRoots` 里被摘掉，所以下面这层过滤只影响**列表展示**。
+    const forgottenKeys = new Set(Array.isArray(policyResult.state.forgottenSources)
+        ? policyResult.state.forgottenSources
+        : []);
     // 已移除的来源仍然出现在 roots 里（界面要能显示「已移除」并允许恢复），但**不扫描**：
     // 技能不入列表、不参与重名决胜 —— 这正是用户要的「不读取这个文件夹」。
     // 注意这里必须用**全部**来源 + 自定义来源，不能只用 activeUserRoots()，
     // 否则被移除的来源会连行都不剩，界面就无从提供「恢复读取」。
-    const user = [...userRoots(), ...customRootsFromState(policyResult.state)];
+    const user = [...userRoots(), ...customRootsFromState(policyResult.state)].filter((root) => !forgottenKeys.has(root.key));
     const scannable = user.filter((root) => !removedKeys.has(root.key));
     const userScans = await scanDeduplicatedRoots(scannable);
     const projectWarnings = [];

package/lib/skills/service.js

@@ -5,7 +5,7 @@
 // 沿用上游机制：全局层接管 + 每个活动 agent scope 内二次注册。
 import { appendFile, rename, rm, stat } from 'node:fs/promises';
 import { isInsideRootResolved } from '../paths.js';
-import { state, setSkillEnabled, setPreferredSkill, markSkillsDisabled, setSourceEnabled, setSourceRemoved, deleteSkill, restoreTrash, importSkill, importUploadedSkill, browseDirectories, createSkill, updateSkill, skillDetail, userRoots, projectRoots, readManagerState, customRootsFromState, addCustomRoot, removeCustomRoot, logPath, } from './core.js';
+import { state, setSkillEnabled, setPreferredSkill, markSkillsDisabled, setSourceEnabled, setSourceRemoved, deleteSkill, restoreTrash, importSkill, importUploadedSkill, browseDirectories, createSkill, updateSkill, skillDetail, userRoots, projectRoots, readManagerState, customRootsFromState, addCustomRoot, removeCustomRoot, forgetSource, logPath, } from './core.js';
 import { watchDirectories } from './dir-watch.js';
 import { registerAgentSkillProviders, externalSkillProvider } from './provider-registration.js';
 import { permanentlyDeleteTrashSafely } from './system-trash.js';
@@ -233,6 +233,8 @@ export function createSkillsService(ctx) {
         // 批量启停与单条启停同权：配了访问令牌的宿主必须同样要求带令牌。
         'skill-set-all',
         'skill-trash-restore', 'skill-trash-delete', 'skill-custom-add', 'skill-custom-remove',
+        // 「永久删除来源记录」（回收站 → 目录）：与上面两条同权，是写操作。
+        'skill-source-forget',
     ]);
     /**
      * 新建 / 导入 / 恢复技能后统一「默认停用」。**失败不能吞。**
@@ -385,6 +387,10 @@ export function createSkillsService(ctx) {
         // 自定义技能目录：添加（绝对路径，只读接入）/ 移除（连同策略键）。
         'skill-custom-add': wrap((args) => write(() => addCustomRoot(args && args.path, args && args.label, log)), afterWrite),
         'skill-custom-remove': wrap((args) => write(() => removeCustomRoot(args && args.key, log)), afterWrite),
+        // 永久删除一条**按约定发现**的来源记录（agents / codex / claude）。与 `skill-custom-remove`
+        // 的分工见 core.ts 的 `forgetSource`：那条管用户手加的自定义目录，这条管推导出来的来源
+        // —— 后者不在状态文件的 customRoots 里，必须另记一份"已永久删除"名单才删得掉。
+        'skill-source-forget': wrap((args) => write(() => forgetSource(args && args.root, log)), afterWrite),
     };
     /**
      * 该绝对路径是否落在「本插件认识的技能来源」内。

package/lib/tools/mcp.js

@@ -13,6 +13,12 @@
 // 所以 switch 里只有 on|off 过 `lockedSceneGuard()`，restart 不过；与面板侧
 // `guardLockedOps(frozenOps('all'))` 的口径逐字一致（两处口径不同才是真的"说假话"）。
 //
+// restart 现在是**唯一**的重启入口：面板侧那颗重启键用户此前已删除（2026-10-12 复核，
+// 客户端已无任何 restart 调用方）。这不是要把它也删掉 —— 工具是模型按需调用的面，与面板
+// 按钮是两回事；面板删掉只说明"不想让人手点"，而"服务器卡住、让模型重连一下"这条恢复路径
+// 仍然成立，且它正是上面那条"锁定期间唯一不冻结的写"的立足点。删掉它等于把场景锁定时的
+// 唯一恢复手段一并拿掉。
+//
 // **改一台已配置服务器时绝不读明文凭据**：`mcpm-edit` 的守卫（`resolveMaskedKv` /
 // `resolveMaskedUrl`）就是为"接受打码值并还原"写的 —— 界面编辑框预填的本来就是打码值。
 // 所以这里拿 `mcpmListView()` 的**打码视图**把模型没给的字段填回去，让 op 去还原。

package/lib/tools/prompt.js

@@ -58,15 +58,27 @@ export function buildPromptTools(deps) {
     }));
     register(defineTool({
         name: 'prompt_manager_apply',
-        description: 'Apply one AGENTS.md preset by id; effective next turn. If a scene drives the baseline this does NOT refuse — it rebinds that scene to the preset and re-syncs it, so tell the user which scene was rebound. A locked scene blocks the call. Only on the user\'s instruction.',
+        description: 'Apply one AGENTS.md preset by id; effective next turn. If a scene drives the baseline this does NOT refuse — it rebinds that scene to the preset and re-syncs it, so tell the user which scene was rebound. A locked scene blocks the call. Pass apply=false to cancel instead — AGENTS.md goes back to what it was before the run of applies (the file is removed if there was none to begin with); a scene driving the baseline refuses that, rebind the scene instead. Only on the user\'s instruction.',
         parameters: {
-            id: { type: 'string', required: true, description: 'Preset id (lowercase letters, digits, hyphens).' },
+            id: { type: 'string', required: true, description: 'Preset id (lowercase letters, digits, hyphens). Ignored when apply=false.' },
+            apply: { type: 'boolean', description: 'Omit or true = apply the preset in `id`; false = cancel — undo the run of applies.' },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
         async execute(args) {
             const blocked = await deps.lockedSceneGuard();
             if (blocked)
                 throw new Error(blocked);
+            if (args.apply === false) {
+                // 取消方向：`agentsmd-unapply` 自带两条护栏（场景驱动时拒绝、没有链起点时给确定
+                // 错误码），原样透传。回执要说清恢复成哪种 —— 起点没有文件时是**删文件**，
+                // 不说的话用户以为 AGENTS.md 还在（0.19.1 界面弹窗报的就是这两种）。
+                const r = await deps.unapplyPreset();
+                if (!r.ok)
+                    throw new Error(r.error || '取消应用失败');
+                return r.removed === true
+                    ? 'OK: application cancelled — ~/.dsh/AGENTS.md did not exist before the run started, so the file was removed (effective next turn).'
+                    : 'OK: application cancelled — ~/.dsh/AGENTS.md is back to what it was before the run started (effective next turn).';
+            }
             const r = await deps.applyPresetGuarded(args.id);
             if (!r.ok)
                 throw new Error(r.error);

package/lib/tools/scene.js

@@ -26,8 +26,9 @@
 // 不因为多了一条工具就破例（工具描述本来就是写"什么时候该用它"的地方）。
 import { text, toolNameList } from './deps.js';
 import { FACTORY_TOOL_TABLE_PRESET } from './table.js';
-/** 档案里由模型设置的三个段（`memories` 段在 P5 已废弃，不再是档案的一部分）。 */
-const ARCHIVE_SECTIONS = ['mcp', 'skills', 'subagents'];
+/** 档案里由模型设置的段（`memories` 段在 P5 已废弃，不再是档案的一部分）。
+ *  `mcpNotes`（0.20.0）与其余三段同族：整段替换、段缺席 = 不碰这一域。 */
+const ARCHIVE_SECTIONS = ['mcp', 'mcpNotes', 'skills', 'subagents'];
 /** 段里的名单：数组段是名字列表，`mcp` 段是 serverName → `'*'` | 工具名数组。段缺席 = 空。 */
 function segmentNames(value) {
     if (Array.isArray(value))
@@ -36,6 +37,21 @@ function segmentNames(value) {
         return Object.keys(value);
     return [];
 }
+/**
+ * `quickPrompts` 入参 → 档案值：去空、去重、保序（与 op 侧 `quickPromptsArg` 同一口径）。
+ *
+ * ⚠️ 空数组是**合法值**（= 进入后全部停用），不能在这里被当成"没给"滤掉 —— 它与
+ * "这一域不碰"（段缺席）是两句相反的话（见 `SceneArchive.quickPrompts` 的注释）。
+ */
+function quickPromptIds(value) {
+    const out = [];
+    for (const item of Array.isArray(value) ? value : []) {
+        const id = String(item == null ? '' : item).trim();
+        if (id && out.indexOf(id) < 0)
+            out.push(id);
+    }
+    return out;
+}
 /**
  * 档案里绑的工具表方案 → 给人读的那一句。`factory-default` 是个哨兵值而不是本机存过的方案，
  * 原样打出来模型会去找一份叫这个名字的方案（`_save` 那边也没有这一栏，它改不了）。
@@ -69,6 +85,11 @@ function archiveText(archive) {
     const tt = toolTableLabel(archive.toolTablePreset);
     if (tt)
         parts.push('工具表方案「' + tt + '」');
+    // 快捷提示词绑定（0.20.0）：进了这个场景会动到 `/` 菜单里哪些条目，不报就只能靠猜。
+    // 空表是"进入后全部停用"，与"没绑"（这一域不碰）是两句相反的话，不能压成一个 "0 条"。
+    const qp = archive.quickPrompts;
+    if (Array.isArray(qp))
+        parts.push(qp.length ? '快捷提示词 ' + qp.length + ' 条' : '快捷提示词：进入后全部停用');
     return parts.join(' ｜ ');
 }
 /**
@@ -124,7 +145,7 @@ export function buildSceneTools(deps) {
         // 默认的隐藏名单里）：静态文本没法按 toolVisible 改写，点名一条模型没有的工具只会让它
         // 白跑一趟。要说"去哪看"就用中性说法（the scene listing / the「本机当前的场景」reminder
         // —— 后者是常驻源，只要场景域开着就在）。点名只留在**运行时回执**里、按可见性分叉。
-        description: 'List every scene with its archive (what entering it switches on: MCP servers, skills, personas, and the bound model tool-table scheme when there is one), bound prompt preset, memory count and enabled / entered / locked state. Read the archive here before saving a scene: a section you give later replaces it whole. Read-only; the scene in effect now is also the「本机当前的场景」reminder.',
+        description: 'List every scene with its archive (what entering it switches on: MCP servers, skills, personas, quick prompts, and the bound model tool-table scheme when there is one), bound prompt preset, memory count and enabled / entered / locked state. Read the archive here before saving a scene: a section you give later replaces it whole. Read-only; the scene in effect now is also the「本机当前的场景」reminder.',
         parameters: {},
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
         async execute() {
@@ -183,7 +204,7 @@ export function buildSceneTools(deps) {
         // 为什么 `action` 是必填枚举而不是一个布尔：与 `mcp_manager_switch` 同一条理由 ——
         // 让模型在 enter / exit 两个动词里选一个，比让它猜"scene 传 null 是什么意思"省一次往返。
         // 参数里刻意不出现 `null`：那是 op（`scene-mode-set`）的形态，模型照着填只会填错。
-        description: 'Enter a scene, or leave the one currently entered. Entering switches on exactly what its archive lists and everything else off — MCP servers, skills, personas, and the model tool table when the scene binds a scheme — narrows injection to its memories, and applies its bound prompt preset to AGENTS.md. Leaving restores the runtime snapshot taken on entry. Check the scene\'s archive in the scene listing before entering. Only when the user asks or approves.',
+        description: 'Enter a scene, or leave the one currently entered. Entering switches on exactly what its archive lists and everything else off — MCP servers, skills, personas, quick prompts, and the model tool table when the scene binds a scheme — narrows injection to its memories, and applies its bound prompt preset to AGENTS.md. Leaving restores the runtime snapshot taken on entry. Check the scene\'s archive in the scene listing before entering. Only when the user asks or approves.',
         parameters: {
             action: { type: 'string', required: true, enum: ['enter', 'exit'], description: 'enter = switch to the scene named in `scene`; exit = leave the current one (no scene needed).' },
             scene: { type: 'string', description: 'Scene name (one path segment), required for enter. Use the exact name, not the display label — the scene listing and the「本机当前的场景」reminder both print names.' },
@@ -271,7 +292,7 @@ export function buildSceneTools(deps) {
         // 「写入指引」保留（"写成指令而不是备注"—— 这是场景说明质量的杠杆），但不再声称
         // "注入后模型会被要求照办"：2026-09-23 定稿把场景段的授权语删了（注入只陈述现状），
         // 参数说明与注入侧各说各话时，模型信的那份是错的。改为如实说明去向。
-        description: 'Save a scene — a named bundle the user enters: entering it switches on exactly what its archive lists and everything else off. Creates it if absent, else updates it. An archive section you give replaces that section whole — include what should stay; the receipt reports what got displaced. Saving does not enter it; entering is a separate action. Only on the user\'s instruction.',
+        description: 'Save a scene — a named bundle the user enters: entering it switches on exactly what its archive lists (MCP servers, skills, personas, quick prompts, and the model tool table when a scheme is bound) and everything else off. Creates it if absent, else updates it. An archive section you give replaces that section whole — include what should stay; the receipt reports what got displaced. Saving does not enter it; entering is a separate action. Only on the user\'s instruction.',
         parameters: {
             scene: { type: 'string', required: true, description: 'Scene name (one path segment, no slashes). Created if absent.' },
             label: { type: 'string', description: 'Display name shown in the UI. Omit = keep.' },
@@ -280,6 +301,18 @@ export function buildSceneTools(deps) {
             // 界面 2026-10-10 补了「无」这个选项，工具侧的空串语义要跟着说清，否则模型只知道
             // 「省略 = 保持」，不知道还有一条「解绑」的路。
             prompt: { type: 'string', description: 'Prompt preset id to bind; while this scene is on it is the global baseline. Omit = keep; \'\' = bind none (this scene leaves AGENTS.md alone).' },
+            // 模型工具表方案绑定（0.20.0 补上模型侧入口：0.15.0 起界面可绑、档案里一直有这一栏，
+            // `_list` / `_switch` 也读它，唯独 `_save` 写不了）。'' = 解绑只能走
+            // `rules-update-scene` —— `scene-archive-save` 对载荷里**不带的栏**一律保留现值
+            // （archive-engine 的「不带 ≠ 解绑」），所以解绑与设置分成两条路，见 execute 的 ②。
+            // 哨兵 `factory-default` 与界面下拉同值（tools/table.ts 的 FACTORY_TOOL_TABLE_PRESET）；
+            // 不存在的方案名由引擎按 stale 丢弃并在进入时报告，op 不硬拒（与悬空绑定同口径）。
+            toolTablePreset: { type: 'string', description: "Model tool-table scheme to bind while this scene is on. Omit = keep; '' = unbind (the scene leaves the tool table alone); 'factory-default' = the factory default; otherwise the name of a scheme saved in the panel. An unknown name is dropped and reported." },
+            // 快捷提示词绑定（0.20.0）。段语义与上面三个档案段相反：**空数组是合法值**
+            // （进入后全部停用），不是"清除这一段"。本工具不提供解绑（界面可解）—— 与
+            // mcp / skills / subagents 三段没有解绑参数同一条口径。id 从场景清单里别的场景的
+            // 绑定、或用户口述里来；不存在的 id 被引擎丢弃并在回执报出来。
+            quickPrompts: { type: 'array', items: { type: 'string' }, description: 'Quick-prompt ids to switch on when this scene is entered; every other one is switched off, and the pre-entry state is restored on exit. Omit = keep; [] = switch all off on entry. Unknown ids are dropped and reported — copy them from a scene binding in the listing, or ask the user.' },
             mcp: {
                 type: 'object',
                 // 官方要求对象类型**显式声明开放性**（`additionalProperties` 是必需字段，且只能是
@@ -288,6 +321,14 @@ export function buildSceneTools(deps) {
                 additionalProperties: true,
                 description: "Archive: serverName -> '*' (whole server) or a list of tool names to leave on. Omit = keep; {} = switch none on.",
             },
+            // 场景级 MCP 备注覆盖（0.20.0）：进入这个场景时用这份盖掉全局备注，退出时还原。
+            // 与 mcp 段同一句式（省略 = 保持；{} = 一个都不覆盖）—— 界面存档编辑器早就能改，
+            // `_list` 也显示它，`_save` 此前不接这一段。
+            mcpNotes: {
+                type: 'object',
+                additionalProperties: true,
+                description: "Archive: serverName -> note that overrides that server's global note while this scene is on (the global note comes back on exit). Omit = keep; {} = drop every scene-level override.",
+            },
             skills: { type: 'array', items: { type: 'string' }, description: 'Archive: skill keys `<root>/<name>` to switch on. Omit = keep; [] = switch none on.' },
             subagents: { type: 'array', items: { type: 'string' }, description: 'Archive: persona names to switch on. Omit = keep; [] = switch none on.' },
         },
@@ -326,22 +367,72 @@ export function buildSceneTools(deps) {
             const created = await deps.rulesOps['rules-create-scene'](payload);
             if (!created || created.ok === false)
                 throw new Error((created && created.error) || '保存场景失败');
-            // ② 档案三段。**必须 read-modify-write**：`scene-archive-save` 是**整份替换**
-            //    （`slice.archives[scene] = archive`），只把模型给的段传过去，没给的段会被静默
-            //    清掉 —— 与 0.14.0 里 `subagent_manager_save` 省略字段被清空同一形状，只是这次
-            //    清掉的是"这个场景进入时要开哪些东西"。
-            //    注意档案的段语义：**段不存在 = 不限制（全部照常）**，段存在但为空 = 全部停用。
-            //    所以模型给 `mcp: {}` 得到的是"全不勾"，不是"清除该段" —— 后者只能靠不给。
+            // ② 两处「解绑」只能走 `rules-update-scene`：`scene-archive-save` 对载荷里**不带的栏**
+            //    一律保留现值（archive-engine 的「不带 ≠ 解绑」），从现值复制出来的合并档案会把
+            //    刚解掉的绑定又写回去 —— 所以解绑与设置分成两条路，合并前还要先摘掉刚解掉的键。
+            //    · `prompt` 的 '' 此前也走不到实处 —— `rules-create-scene` 的 upsert 分支把空串
+            //      当"没给"（ops/scene-records.ts），旧绑定原样保留而回执报"已更新"。
+            //    · `toolTablePreset` 的 '' 同解（那个 op 的更新分支认空串 = 解绑）。
+            const clearPrompt = args.prompt !== undefined && String(args.prompt).trim() === '';
+            const unbindToolTable = args.toolTablePreset !== undefined && String(args.toolTablePreset).trim() === '';
+            const setToolTable = args.toolTablePreset !== undefined && String(args.toolTablePreset).trim() !== '';
+            const setQuickPrompts = args.quickPrompts !== undefined;
+            if (setQuickPrompts && !Array.isArray(args.quickPrompts)) {
+                throw new Error('quickPrompts 必须是 id 数组（[] = 进入后全部停用；要解绑请到「场景」页）');
+            }
             const touched = ARCHIVE_SECTIONS.filter((k) => args[k] !== undefined);
-            let archiveNote = '';
-            if (touched.length) {
+            const mustWriteArchive = touched.length > 0 || setToolTable || setQuickPrompts;
+            // 档案现状在读的时候就取一次，且必须在 ② **之前** —— 解绑落盘后这一栏已经没了，
+            // 回执的「X → 解绑」要的是解绑前的那个 X。只为看回执的 diff 而读时（解绑且不写档案）
+            // 容忍读失败：那一步已经写成功了，别为一句对比话把整次调用判失败。
+            let before = {};
+            let beforeKnown = false;
+            if (mustWriteArchive || unbindToolTable) {
                 const cur = await deps.archiveOps['scene-mode-get']({});
-                if (!cur || cur.ok === false)
-                    throw new Error((cur && cur.error) || '读取场景档案失败');
-                const before = (cur.archives || {})[scene] || {};
+                if (!cur || cur.ok === false) {
+                    if (mustWriteArchive)
+                        throw new Error((cur && cur.error) || '读取场景档案失败');
+                }
+                else {
+                    before = (cur.archives || {})[scene] || {};
+                    beforeKnown = true;
+                }
+            }
+            let clearWarn = '';
+            if (clearPrompt || unbindToolTable) {
+                const upd = { name: scene };
+                if (clearPrompt)
+                    upd.prompt = '';
+                if (unbindToolTable)
+                    upd.toolTablePreset = '';
+                const u = await deps.rulesOps['rules-update-scene'](upd);
+                if (!u || u.ok === false) {
+                    // 主路径已成功、解绑没写上：如实报，别让回执假装绑定已经没了。
+                    clearWarn = '\nWARN: 解绑未写入（' + ((u && u.error) || '未知错误') + '），旧绑定仍然有效';
+                }
+            }
+            // ③ 档案 read-modify-write：段（mcp / mcpNotes / skills / subagents）与两个绑定栏的
+            //    「设置」方向合并成一份，只经 `scene-archive-save` 一条路落盘。
+            //    **必须 read-modify-write**：`scene-archive-save` 是**整份替换**，只把模型给的段
+            //    传过去，没给的段会被静默清掉 —— 与 0.14.0 里 `subagent_manager_save` 省略字段被
+            //    清空同一形状，只是这次清掉的是"这个场景进入时要开哪些东西"。
+            //    注意段语义：**段不存在 = 不限制（全部照常）**，段存在但为空 = 全部停用。所以模型给
+            //    `mcp: {}` 得到的是"全不勾"，不是"清除该段" —— 后者只能靠不给。
+            //    `quickPrompts` 与三段都不同：段缺席 = 这一域不碰，空数组 = 进入后全部停用。
+            let archiveNote = '';
+            let toolTableNote = '';
+            let quickNote = '';
+            let warnTail = '';
+            if (mustWriteArchive) {
                 const archive = { ...before };
                 for (const k of touched)
                     archive[k] = args[k];
+                if (unbindToolTable)
+                    delete archive.toolTablePreset;
+                if (setToolTable)
+                    archive.toolTablePreset = String(args.toolTablePreset).trim();
+                if (setQuickPrompts)
+                    archive.quickPrompts = quickPromptIds(args.quickPrompts);
                 const r = await deps.archiveOps['scene-archive-save']({ scene, archive });
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || '保存场景档案失败');
@@ -349,18 +440,41 @@ export function buildSceneTools(deps) {
                 // 静默清掉，所以"模型给什么就是什么"），但"给出去的段盖掉了原来的勾选"是**静默**的
                 // —— 不写出来，模型只会看到一句"档案段：mcp"，以为只是加了一项。
                 const diffs = touched.map((k) => segmentDiff(k, before[k], args[k]));
-                archiveNote = '档案段：' + diffs.map((d) => d.text).join('；');
-                if (diffs.some((d) => d.dropped.length > 0)) {
-                    archiveNote += '\n注意：这些段是整段替换，上面标 - 的项已被挤掉；要保留就把它们一并写进这次调用。';
+                if (diffs.length) {
+                    archiveNote = '档案段：' + diffs.map((d) => d.text).join('；');
+                    if (diffs.some((d) => d.dropped.length > 0)) {
+                        warnTail += '\n注意：这些段是整段替换，上面标 - 的项已被挤掉；要保留就把它们一并写进这次调用。';
+                    }
                 }
-                // 当前环境里不存在的键会被 op 丢弃并报告（改名或删除留下的）：如实说，
-                // 否则模型以为勾上了而实际没有。
+                // 当前环境里不存在的键会被 op 丢弃并报告（改名或删除留下的，含工具表方案名与
+                // 快捷提示词 id）：如实说，否则模型以为勾上了而实际没有。
                 if (r.stale && r.stale.length)
-                    archiveNote += '（丢弃了当前环境不存在的键：' + r.stale.join('、') + '）';
+                    warnTail += '\n（丢弃了当前环境不存在的键：' + r.stale.join('、') + '）';
                 // 存盘成功但应用到运行时失败：`scene-archive-save` 对"正是当前模式的那个场景"会就地
                 // 重应用，失败不回滚档案。如实报出去，别假装生效了（与界面同口径）。
                 if (r.applyError)
-                    archiveNote += '（已存盘，但应用到运行时失败：' + r.applyError + '）';
+                    warnTail += '\n（已存盘，但应用到运行时失败：' + r.applyError + '）';
+            }
+            // 解绑写失败了就别输出「X → 解绑」—— 上面那句 WARN 才是事实；设置方向不受 ② 影响。
+            if (args.toolTablePreset !== undefined && !(unbindToolTable && clearWarn !== '')) {
+                toolTableNote = beforeKnown
+                    ? '工具表方案：' + (toolTableLabel(before.toolTablePreset) || '未绑') + ' → ' +
+                        (unbindToolTable ? '解绑' : toolTableLabel(String(args.toolTablePreset).trim()))
+                    : '工具表方案：已解绑（档案现状读不到，无法对比）';
+            }
+            if (setQuickPrompts && beforeKnown) {
+                const beforeIds = Array.isArray(before.quickPrompts) ? before.quickPrompts.map((x) => String(x)) : [];
+                const afterIds = quickPromptIds(args.quickPrompts);
+                const added = afterIds.filter((id) => beforeIds.indexOf(id) < 0);
+                const dropped = beforeIds.filter((id) => afterIds.indexOf(id) < 0);
+                const marks = [];
+                if (added.length)
+                    marks.push('+' + toolNameList(added));
+                if (dropped.length)
+                    marks.push('-' + toolNameList(dropped));
+                quickNote = '快捷提示词：' + beforeIds.length + ' 条 → ' + afterIds.length + ' 条' +
+                    (afterIds.length === 0 ? '（进入后全部停用）' : '') +
+                    (marks.length ? '（' + marks.join(' ') + '）' : '');
             }
             // 收敛提示：`rules-create-scene` 在"历史默认（全部启用）"状态下会把启用集合收窄成
             // 单选（`collapseActiveForNewScene`）—— 那是一次**会改变运行时**的动作，必须说出来。
@@ -369,13 +483,17 @@ export function buildSceneTools(deps) {
             const parts = [touchedRecord.length ? '场景记录已更新（' + touchedRecord.join('、') + '）' : '场景已确保存在'];
             if (archiveNote)
                 parts.push(archiveNote);
+            if (toolTableNote)
+                parts.push(toolTableNote);
+            if (quickNote)
+                parts.push(quickNote);
             // 点名 scene_manager_switch 的那句按可见性分叉（它在出厂默认名单里就是关着的）：
             // 部分启用（开 save 不开 switch）时指向一条模型没有的工具，只会让它白跑一趟 ——
             // 与 mcp/skill 的 listHint 同一条纪律。
             const enterHint = deps.toolVisible('scene_manager_switch')
                 ? '要让它生效，用 scene_manager_switch 进入。'
                 : '要让它生效，由用户在「场景」页进入。';
-            return 'OK: scene「' + scene + '」' + parts.join('；') +
+            return 'OK: scene「' + scene + '」' + parts.join('；') + warnTail + clearWarn +
                 (collapsed
                     ? '\n注意：此前所有场景都处于启用状态（历史「全部启用」默认），本次已收窄为只启用一个，新建的这个不在其中 —— 让用户到「场景」页确认。'
                     : '') +

package/lib/trash-retention.js

@@ -6,9 +6,9 @@
 // 这里**刻意同形**：同一个 `{retentionDays, updatedAt}` 侧车形状、同一条到期判据、同一个
 // 「改设置即重置倒计时」语义。两处口径一旦分家，用户在两个页面看到的就是两套话术。
 //
-// 覆盖六类：hub 四类（`trash/<域>-trash/<id>/manifest.json`）+ 技能（`trash/skills-trash/`，
-// 元数据文件叫 `metadata.json`，是 core 层自己写的那套）+ 记忆（`memories-trash/`，
-// **hub 根下的独立目录**，不在 `trash/` 里 —— 见 hub.ts 顶部那张目录图）。
+// 覆盖六类：hub 五类（`trash/<域>-trash/<id>/manifest.json`，含记忆 —— 它的落点自
+// 2026-10-10 起也在这里，读写仍走 memories 域自己的实现）+ 技能（`trash/skills-trash/`，
+// 元数据文件叫 `metadata.json`，是 core 层自己写的那套）。
 //
 // 三条口径（改这个文件前先读）：
 //   ① `retentionDays <= 0` = **永久保留**，清扫是纯 no-op。这是默认值，也是本文件存在的

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-tool-management",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "description": "DSH plugin: one settings panel for MCP servers, skills, scenes, memories, subagent personas and AGENTS.md presets — a scene switches the whole environment, and the model can drive it from chat too.",
   "repository": {
     "type": "git",