dsh-plugin-tool-management 0.20.0 → 0.20.1

package/lib/compat/preset-reach.js

@@ -468,10 +468,13 @@ export function reachNoticeFor(presetId, facts, inject) {
     const parts = [];
     const domainOff = (key) => inject?.domains?.[key] === false;
     if (isSuppressingPreset(facts) && inject?.underSuppressingPresets !== true) {
+        // 末尾那句「（想让它在这类预设下也注入：插件的「兼容」页 → 注入。）」已删（2026-10-15 用户裁定）：
+        // 它是**给人看的操作路径**（界面怎么点），而这段文字进的是**工具回执** —— 回执留在 transcript 里，
+        // 比工具 schema 还贵（每次调用都会带一份）。判据与上一轮 P1-5 从场景锁定守卫里清掉
+        // 「去界面解锁」逐字同一条：守卫/提示只**陈述事实**，"怎么改"由模型自己向用户解释。
         parts.push(`预设「${presetId}」声明只要它自己的文本（persona complete / 关闭运行时上下文）：` +
             '本插件注入的 —— 场景、记忆、MCP、技能、子智能体、提示词 —— 默认不注入，' +
-            '需要时用对应的 list / read 工具按需读取；不要假设你已经看到它们。' +
-            '（想让它在这类预设下也注入：插件的「兼容」页 → 注入。）');
+            '需要时用对应的 list / read 工具按需读取；不要假设你已经看到它们。');
     }
     else {
         if (facts.agentInstructions !== 'mounted' && domainOff('prompt')) {

package/lib/context-inject-frame.js

@@ -26,22 +26,22 @@ export const DOMAIN_FRAME = {
         // 现在这一段只回答一个问题：**当前处在哪个场景、它是什么**（`**「代码」—— 写代码**`）。
         // 它还比别的段少一层：因果句也删了 —— 它解释的是"另外四段是怎么产生的"（机制），
         // 不是当前情况本身，而且"清单里没有 ≠ 本机没有"这层反推被用户明确判为浪费。
-        title: '本机当前的场景',
+        title: '当前场景',
         supersede: SUPERSEDE_NOTE,
     },
     memory: {
-        title: '本机当前的记忆',
+        title: '当前记忆',
         supersede: SUPERSEDE_NOTE,
     },
     mcp: {
-        title: '本机 MCP 服务器的当前状态',
+        title: '当前 MCP 服务器',
         // how 只剩"怎么用备注"这半句：前半个分句「工具名是 `mcp__<服务器>__<工具>`」删掉了
         // —— 模型自己的工具表里就是这个命名（`mcp__context7__xxx`），告诉它格式是零信息量。
         how: '带「用户提示：」的行是用户写给这台服务器的决策提示，选服务器之前先看一眼。',
         supersede: SUPERSEDE_NOTE,
     },
     skills: {
-        title: '本机技能目录',
+        title: '当前技能目录',
         // 两句都只在预设没挂官方 `skill` 工具时出现，差别只在点名不点名那个取正文的工具
         // （工具被用户在兼容页关掉时不点名 —— 点名一个模型手里没有的工具只会让它去猜名字）。
         how: (toolHidden) => toolHidden('skill_manager_read')
@@ -50,20 +50,25 @@ export const DOMAIN_FRAME = {
         supersede: `${SUPERSEDE_NOTE.slice(0, -1)}；只列当前可调用的技能。`,
     },
     subagents: {
-        title: '可委派的子智能体',
+        title: '当前子智能体',
         // 分界规则（2026-09-17 方案 C，本机实测 session-ee722e23 逼出来的）：官方那两个
         // 委派工具（`subagent` / `subagent_fork`）不带人设，而此前没有任何一句话说明何时该
         // 用谁 —— 模型在"审查刚读过的 README"时选了 `subagent_fork`（fork 能继承已读内容、
         // 省一次复述）。现在人设通道也有 `inherit`（同一套 fork 机制），分界只剩"要不要后台跑"。
         // 带人设的委派工具被关掉时改说"本会话没有这条通道"：不说的话，模型看到有人设目录却
         // 找不到对应的工具，会去拿官方那两个凑（它们不接受人设，等于白跑一趟）。
+        //
+        // `inherit` 那半句 2026-10-14 删掉了（用户裁定）：它在 `subagent_manager_run` 的
+        // Modes 段与 `inherit` 参数说明里**各有一份**，三份都在每轮上下文里 = 同一件事付三次
+        // token。留这两份（它们就在"要传这个参数"的那一刻），这里只留 how 行独有的那半句 ——
+        // 与官方两个委派工具的分界规则。
         how: (toolHidden) => toolHidden('subagent_manager_run')
             ? '本会话没有带人设的委派工具；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。'
-            : '贴合人设的任务一律用 `subagent_manager_run`（要它看到本次会话就开 `inherit`）；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。',
+            : '贴合人设的任务一律用 `subagent_manager_run`；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。',
         supersede: SUPERSEDE_NOTE,
     },
     prompt: {
-        title: '本机提示词',
+        title: '当前提示词',
         supersede: SUPERSEDE_NOTE,
     },
 };
@@ -82,7 +87,7 @@ export const DOMAIN_FRAME = {
 export const HOW_NAMED_TOOLS = ['skill_manager_read', 'subagent_manager_run'];
 /** 域声明里没登记的 key（理论上到不了这里）：给一个不出错的通用框架。 */
 export const fallbackFrame = (label) => ({
-    title: `本机的${label}`,
+    title: `当前的${label}`,
     supersede: SUPERSEDE_NOTE,
 });
 export const domainFrame = (key, label) => DOMAIN_FRAME[key] ?? fallbackFrame(label);

package/lib/hub.js

@@ -43,8 +43,8 @@
 //   3. **每进程一次**——迁移是启动期的一次性动作，失败也不阻断服务（旧目录仍可读）。
 import { cp, lstat, mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { cpSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from 'node:fs';
-import { randomUUID } from 'node:crypto';
 import { basename, dirname, join } from 'node:path';
+import { newTrashId } from './trash-id.js';
 import { resolveDshHome } from './skills/core.js';
 import { isSameOrDescendant } from './paths.js';
 /** hub 根目录名（`$DSH_HOME` 下）。 */
@@ -258,10 +258,13 @@ const LEGACY_TRASH_KINDS = {
 export function trashKindDir(kind) {
     return hubPath('trash', `${kind}-trash`);
 }
-/** 新条目 id（时间戳 base36 + uuid 前 8 位，与记忆回收站同形）。 */
-export function newTrashId() {
-    return Date.now().toString(36) + '-' + randomUUID().slice(0, 8);
-}
+/**
+ * 新条目 id（时间戳 base36 + uuid 前 8 位，与记忆回收站同形）。
+ *
+ * 实现挪到 `./trash-id.ts`（2026-10-15）：本模块引了 `skills/core.js`，技能域要共用这个生成器
+ * 就不能再反过来引这里。这里保留同一条导出路径 —— `memories/service.ts` 等既有引方不动。
+ */
+export { newTrashId };
 /** id 只由本模块生成：严格白名单，杜绝路径穿越。 */
 export function isValidTrashId(id) {
     return /^[a-z0-9]+-[a-z0-9]{1,32}$/i.test(id);

package/lib/index.js

@@ -70,6 +70,7 @@ import { buildMcpTools } from './tools/mcp.js';
 import { buildSkillTools } from './tools/skills.js';
 import { buildPromptTools } from './tools/prompt.js';
 import { buildMemoryTools } from './tools/memory.js';
+import { buildRemoveTools } from './tools/remove.js';
 import { buildSceneTools } from './tools/scene.js';
 import { buildSubagentTools } from './tools/subagent.js';
 import { createScenePromptSync } from './scene-prompt-sync.js';
@@ -632,7 +633,7 @@ export default {
             return out;
         };
         /**
-         * `how` 行点名过的工具里，**这个 agent 手里没有**的那些（注入器每步同步问一次）。
+         * 这条工具**在这个 agent 手里吗** —— 注入侧（`how` 行、两个目录的尾句）与工具回执共用的一份。
          *
          * 两条路并起来，缺一条框架文本就会说谎：
          *   ① `toolTableHidden()` —— 兼容页「模型工具表」的全局开关。**必须留着**：它读的是设置
@@ -643,21 +644,33 @@ export default {
          *      scope 上（`dsh-subagent/lib/index.js:522`），全局开关表里看不到它 —— 于是人设砍掉
          *      `skill_manager_read` 之后，技能目录照注、`how` 行照样点名一个模型手里没有的工具。
          *      拿不到 agent 时跳过：`get(name, undefined)` 问的是**全局视图**，会得出相反结论。
+         *
+         * 为什么要有这一份（2026-10-14 对抗性审查 P0-1/P1-8）：此前只有全局开关一条路，于是
+         * `mcp_manager_switch` 的 `listHint`、技能目录与子智能体目录的尾句都会点名一条**这个模型
+         * 手里没有的**工具。它是这两处的唯一判据 —— 工具侧经 `toolVisibleFor` 依赖拿，注入侧经
+         * `injectHiddenToolsFor` 拿，同一个函数，不定义第二份。
          */
-        const howHiddenToolsFor = (agent) => {
-            const hidden = new Set(toolTableHidden());
+        const toolVisibleFor = (name, agent) => {
+            if (toolTableHidden().has(name))
+                return false;
             if (agent === null || (typeof agent !== 'object' && typeof agent !== 'function'))
-                return hidden;
-            const scope = agent;
-            for (const name of HOW_NAMED_TOOLS) {
-                if (hidden.has(name))
-                    continue;
-                try {
-                    if (tools.get(name, scope) === undefined)
-                        hidden.add(name);
-                }
-                catch { /* 读不到 = 按还在手里算 */ }
+                return true;
+            try {
+                return tools.get(name, agent) !== undefined;
             }
+            catch {
+                return true; /* 读不到 = 按还在手里算 */
+            }
+        };
+        /**
+         * `how` 行点名过的工具里，**这个 agent 手里没有**的那些（注入器每步同步问一次）。
+         * 判据就是上面那份 `toolVisibleFor`，这里只把它收成一份集合交给注入框架。
+         */
+        const injectHiddenToolsFor = (agent) => {
+            const hidden = new Set(toolTableHidden());
+            for (const name of HOW_NAMED_TOOLS)
+                if (!toolVisibleFor(name, agent))
+                    hidden.add(name);
             return hidden;
         };
         // ---------- 注入通道（场景 / 记忆 / MCP / 技能 / 子智能体 / 提示词，各一条消息）----------
@@ -674,8 +687,10 @@ export default {
         const subagentCatalog = createSubagentCatalog({
             list: () => subagentService.list(),
             sceneLists: subagentSceneLists,
-            // 人在「兼容」页把 `subagent_manager_list` 关掉后，截断提示里那句「用 X 查」就是假的。
-            listToolVisible: () => !toolTableHidden().has('subagent_manager_list'),
+            // 人在「兼容」页把 `subagent_manager_list` 关掉、或某个人设用 `toolsDeny` 砍掉它之后，
+            // 截断提示里那句「用 X 查」就是假的。判据按 **agent**（2026-10-14 对抗性审查 P1-8）：
+            // 与 `how` 行、MCP 回执同一份 `toolVisibleFor`，不再只看全局开关。
+            listToolVisible: (agent) => toolVisibleFor('subagent_manager_list', agent),
         });
         // ⚠️ 取数必须用 mcpmRowsWithNotes(false)：true 会带上**未打码**的 url/headers/env（含明文密钥）。
         // 技能目录与提示词两个域是**官方载体的兜底**：预设挂得到官方
@@ -683,7 +698,9 @@ export default {
         // CARRIER_FACT_OF），挂不到（极简）时才由这里送 —— 所以极简下也能按开关决定要不要。
         const skillCatalog = createSkillCatalog({
             state: () => skillsService.ops['skill-state']({}),
-            listToolVisible: () => !toolTableHidden().has('skill_manager_list'),
+            // 与子智能体目录同一份判据（2026-10-14 对抗性审查 P1-8）：只看全局开关时，人设用
+            // `toolsDeny` 砍掉 `skill_manager_list` 之后，技能目录尾句照样点名一条它手里没有的工具。
+            listToolVisible: (agent) => toolVisibleFor('skill_manager_list', agent),
         });
         // 三份界面设置侧车（inject / scene / slash）拆到 ./settings-sidecars.ts：读走 3 秒 TTL 缓存，
         // 写共用上面那条串行写锁。工厂只在这里调用一次，三份缓存仍是「每次 apply 一份」。
@@ -733,7 +750,7 @@ export default {
                         // 记忆（**内容**）：各场景下的条目。与场景段同源、同一条 `applicableTo`。
                         { key: 'memory', name: 'tool-management:memory', label: '记忆', form: 'snapshot', text: () => memoriesService.memoryText(), applicableTo: (agent) => subagentDepthOf(agent) === 0 },
                         { key: 'mcp', name: 'tool-management:mcp-state', label: 'MCP 服务器', form: 'catalog', text: () => mcp.stateCatalog.text() },
-                        { key: 'skills', name: 'tool-management:skill-catalog', label: '技能目录', form: 'catalog', text: () => skillCatalog.text() },
+                        { key: 'skills', name: 'tool-management:skill-catalog', label: '技能目录', form: 'catalog', text: (agent) => skillCatalog.text(agent) },
                         {
                             key: 'subagents',
                             name: 'tool-management:subagents',
@@ -746,7 +763,7 @@ export default {
                     ],
                     settings: () => injectSettingsSync(),
                     // 工具表开关：`how` 行里点名工具的那几句要跟着它换话术（关掉的不点名）。
-                    hiddenTools: howHiddenToolsFor,
+                    hiddenTools: injectHiddenToolsFor,
                     factsFor: (agent) => candidates.presetFactsForAgent(agent),
                     // 令牌门禁（2026-09-19，用户裁定「宿主侧硬拦截」）：令牌**在生效**（`TOKEN !== ''`，
                     // 关掉或没配都是空串）而本次启动还没有人验过 ⇒ 这一步不放行，宿主把 turn 收成
@@ -1506,7 +1523,7 @@ export default {
             // 清空流水。清完这一条 op 自己会被下面的包装层记进新流水（"谁清过"也留痕）。
             'audit-clear': async () => await clearAudit(),
             'skill-open': skillOpen,
-            // MCP 域 16 个 op（实现在 ./mcp/manager.ts）
+            // MCP 域 17 个 op（实现在 ./mcp/manager.ts）
             ...mcp.ops,
             // 技能管理 ops（由 ./skills/service.js 提供）：skill-state / skill-detail /
             // skill-browse / skill-enable / skill-disable / skill-source-enable /
@@ -1558,7 +1575,7 @@ export default {
             // -toggle / -remove 与回收站三条。它**不**碰 AGENTS.md、不进场景、不进注入。
             ...quickPromptOps,
             // 归档会话域（ops/history.ts 提供）：history-list / history-sessions /
-            // history-export-defaults / dir-list / history-archive / history-archive-batch /
+            // history-export-defaults / dir-list /
             // history-unarchive / history-delete / history-unarchive-batch / history-delete-batch /
             // history-workspace-register / history-import / bundle-export / history-export /
             // history-retention-get / history-retention-set。
@@ -2179,6 +2196,10 @@ export default {
             syncSwitchToScene,
             // 错误句里点名工具前要先问一句（判据与两个目录的 `listToolVisible` 同一份缓存）。
             toolVisible: (name) => !toolTableHidden().has(name),
+            // 同上一句，但把**该 agent 的工具限制**也算进去（2026-10-14 对抗性审查 P0-1/P1-8）：
+            // 人设用 `toolsDeny` 砍掉 `mcp_manager_list` 之后，只看全局开关就会让回执点名一条
+            // 这个模型手里没有的工具。与注入侧 `injectHiddenToolsFor` 同一个函数。
+            toolVisibleFor: (name, agent) => toolVisibleFor(name, agent),
             reachNoticeForAgent,
             presetRoster: candidates.presetRoster,
             injectNoticeOptions,
@@ -2245,6 +2266,21 @@ export default {
             toolFilterFor: subagentToolFilterFor,
             failures: subagentFailures,
         });
+        // 删除 / 回收站族（tools/remove.ts，2026-10-15）：五个域各一条 `*_manager_remove`。
+        // 此前模型只能停用、不能删除。删除一律进回收站（可恢复）；**不做永久删除**（低频且
+        // 不可恢复，留给面板）。`sceneRemove` 传 handlers 里那份（`withAgentsMdSync` 包过），
+        // 与 `sceneActivate` 同一条纪律：直调 `memoriesService.ops` 会静默漏掉 AGENTS.md 那一步。
+        buildRemoveTools({
+            ...toolDeps,
+            memoryOps: auditOps(memoriesService.ops),
+            skillOps: auditOps(skillsService.ops),
+            subagentOps: auditOps(subagentService.ops),
+            promptOps: auditOps(promptOps),
+            // 场景回收站（`scene-trash-list` / `scene-trash-restore`）在 **memoriesService** 的 op 表里
+            // （`archiveService` 只有 scene-mode-get / -set / scene-archive-save 三条）。
+            sceneOps: auditOps(memoriesService.ops),
+            sceneRemove: auditFn('rules-remove-scene', (args) => handlers['rules-remove-scene'](args)),
+        });
         if (typeof ctx.on === 'function') {
             // 三个确认门的统一前裁决。口径（用户裁定，方案 B）：会话审批策略为 never（「完全权限」预设）
             // = 用户已在预设层面预先批准一切确认门，**直接放行**并写审计日志留痕。

package/lib/mcp/manager.js

@@ -106,6 +106,8 @@ export function isToolDisabledIn(map, fullName) {
         return true;
     return list.indexOf(parts.tool) >= 0;
 }
+/** `mcpm-parse-patch` 的输入上限：粘贴框不是文件上传口，几十 KB 之外基本都是误贴。 */
+const PATCH_PARSE_MAX_CHARS = 200_000;
 export function createMcpManager(deps) {
     // 外部能力一次解构成局部名：块内代码是逐字搬来的，保持原样最不容易出错。
     const { readJsonFile, writeJsonFile, ensurePaths, withWriteLock, message, tools, pluginInventory, settings, readPatch, writePatch, memoriesService, wait, } = deps;
@@ -1734,6 +1736,24 @@ export function createMcpManager(deps) {
         const notes = importNotes.length ? { warning: importNotes.join('；') } : {};
         return overwrite ? { ok: true, added, overwritten, skipped, ...notes } : { ok: true, added, skipped, ...notes };
     }
+    /**
+     * 补丁片段解析（0.20.1 导入弹窗）：把用户粘贴的 dsh 补丁文本读成条目 —— 不读盘、不写盘。
+     *
+     * 为什么这件事在宿主侧：客户端那一半跑在浏览器里（`window.__ModuleLoader__`），那里的
+     * `require` 只解析宿主注册过的浏览器模块，`js-yaml` 永远取不到 —— 界面自己解析 YAML 补丁
+     * 是死路。这里走 `parseRows`：纯字符串运算，且正是本插件读真身补丁用的同一份口径（只收
+     * `name === MCP_CLIENT_MODULE` 的 insert 子条目、覆盖块按文件顺序生效）。
+     */
+    async function mcpmParsePatch(args) {
+        const text = String((args && args.text) || '');
+        if (!text.trim())
+            return { ok: false, error: '没有内容' };
+        if (text.length > PATCH_PARSE_MAX_CHARS) {
+            return { ok: false, error: `内容过长（${text.length} 字符，上限 ${PATCH_PARSE_MAX_CHARS}）：请只粘贴要导入的那几块` };
+        }
+        const rows = parseRows(text).rows.map((r) => ({ id: r.id, disabled: r.disabled, config: r.config }));
+        return { ok: true, rows };
+    }
     function parseKv(text) {
         const out = {};
         String(text || '').split(/\r?\n/).forEach((line) => {
@@ -1804,6 +1824,7 @@ export function createMcpManager(deps) {
             'mcpm-compact': mcpmCompact,
             'mcpm-export': mcpmExport,
             'mcpm-import': mcpmImport,
+            'mcpm-parse-patch': mcpmParsePatch,
         },
         readDisabledTools,
         readKnownMcpTools,

package/lib/mcp/state-section.js

@@ -122,7 +122,7 @@ export function renderMcpStateSection(rows, opts = {}) {
         ...shownUsable.map((r) => lineOf(r, liveEnabledOf(r), false)),
         ...shownOffline.map((r) => lineOf(r, knownOf(r), true)),
     ];
-    // 只有清单：标题（`# 本机 MCP 服务器的当前状态`）由注入通道的框架承担
+    // 只有清单：标题（`# 当前 MCP 服务器`）由注入通道的框架承担
     // （2026-09-18 起，见 context-inject.ts 的 DOMAIN_FRAME）—— 同一件事只有一个出处，
     // 框架已经写了标题，正文再写一遍就是每步多付一行 token。
     const out = [...lines];

package/lib/memories/archive-engine.js

@@ -449,10 +449,10 @@ export function createArchiveEngine(deps) {
             catch (e) {
                 return { ok: false, error: `读取技能启停现状失败：${msg(e)}` };
             }
-            const sourcesOn = [];
-            const sourcesOff = [];
-            for (const s of skillsPlan.sourceSwitches)
-                (s.enabled ? sourcesOn : sourcesOff).push(s.root);
+            // 来源级切换（skillsPlan.sourceSwitches）只做不说：它是技能启停的实现细节 ——
+            // 勾了技能的来源才启用、一条都没勾就停用。项目来源的 key 是路径哈希
+            // （`project-dsh:47d48f408c5edc5e`），目录对用户可能根本不存在、也不是新建技能的
+            // 落点，报上预览卡只会被当成故障（用户 2026-10-15 裁定：提醒不显示技能目录）。
             const stale = [...mcpPlan.stale, ...skillsPlan.stale];
             // 工具表方案（C1）：绑了就说清「会切成哪一份、关几条」。方案在别处被删掉 / 换机器之后
             // 查不到时 hiddenCount 给 null，界面那句会改成"方案已不存在，这次不会切换"——
@@ -498,7 +498,6 @@ export function createArchiveEngine(deps) {
                 enter: { servers: clip(enterServers) },
                 skills: {
                     on: clip(skillsOn), off: clip(skillsOff),
-                    sourcesOn: clip(sourcesOn), sourcesOff: clip(sourcesOff),
                 },
                 subagents: { on: clip(personas.on), off: clip(personas.off) },
                 quickPrompts,

package/lib/memories/constants.js

@@ -63,7 +63,7 @@ export const ATTACHMENT_LIST_MAX = 10;
  *
  * 用词：不用「常驻」「注入」这类内部行话（模型没有先验）。
  * ⚠️ 「用『信息』而不是『记忆』」那条**已被 2026-09-23 第四次裁定推翻**（见下）：用户
- * 给定的定稿文案里就是「记忆」，而板块标题本来就是「本机当前的记忆」—— 两者同名反而更好，
+ * 给定的定稿文案里就是「记忆」，而板块标题本来就是「当前记忆」—— 两者同名反而更好，
  * 当时那条理由（「记忆」在系统提示词里指代不明）在板块标题定名之后也不成立了。
  *
  * 2026-09-17 重写（用户：「当前模式会不重视这些提示词」）。上一版的三个毛病都在**授权**
@@ -110,7 +110,7 @@ export const ATTACHMENT_LIST_MAX = 10;
  * 时以实际情况为准、④ 与用户当场说的冲突时以用户为准、⑤ 无关不必提 + 完整性声明（防探测，
  * 见上，那半句是整句里唯一不能删的）。77 → 48 字符（219 → 144 字节），而它**每个场景块各来
  * 一次**，所以省的是 N 倍。删掉的只有修饰与重复：「以下是用户为本机写的记录」→「本机记录」
- * （板块标题 `# 本机当前的记忆` 已经把"这是本机的记忆"说过了），两句"冲突时以…为准"
+ * （板块标题 `# 当前记忆` 已经把"这是本机的记忆"说过了），两句"冲突时以…为准"
  * 合成一句。
  *
  * 2026-09-23 第四次裁定（用户直接给定稿文案，逐字）：

package/lib/op-registry.js

@@ -57,6 +57,8 @@ export const OP_REGISTRY = Object.freeze({
     // 会停在启用态 —— 是写不是读。（0.6.0 / 0.7.0 各有漏列前科，见文件头。）
     'mcpm-tools-refresh': { write: true },
     'mcpm-tools': { readonly: true },
+    // 把粘贴的补丁片段读成条目：纯文本运算，不读盘也不写盘（客户端在浏览器里解析不了 YAML）。
+    'mcpm-parse-patch': { readonly: true },
     // ── 技能域（22，含内联的 skill-open）───────────────────────────────────────
     'skill-state': { annotatesLock: true },
     'skill-detail': { readonly: true },
@@ -72,8 +74,10 @@ export const OP_REGISTRY = Object.freeze({
     'skill-prefer': { serviceWrite: true, frozen: true },
     'skill-unprefer': { serviceWrite: true, frozen: true },
     'skill-create': { serviceWrite: true, frozen: true },
-    // 改写 hub 里已存在的那一份技能（`skill_manager_save` 的改分支）。与 create 同规格：
-    // 都是往 hub 落文件。它**不动**官方根里的技能 —— 那层边界在 service 的胜出者判定里。
+    // 改写本插件自己写过的那一份技能（`skill_manager_save` 的改分支）。与 create 同规格：
+    // 落点只限本插件可写的两个根 —— hub（导入落点）+ dsh（新建默认落点，2026-10-15 裁定，
+    // 见 service.ts 的 PLUGIN_WRITABLE_ROOTS）。它**不动**官方根里的技能 —— 那层边界在
+    // service 的胜出者判定里。
     'skill-update': { serviceWrite: true, frozen: true },
     'skill-import': { serviceWrite: true, frozen: true },
     'skill-upload': { serviceWrite: true, frozen: true },
@@ -171,16 +175,14 @@ export const OP_REGISTRY = Object.freeze({
     'quickprompt-remove': { write: true, frozen: true },
     'quickprompt-trash-restore': { write: true, frozen: true },
     'quickprompt-trash-delete': { write: true, frozen: true },
-    // ── 历史会话域（16）────────────────────────────────────────────────────────
+    // ── 历史会话域（14）────────────────────────────────────────────────────────
     'history-list': { readonly: true },
     'history-sessions': { readonly: true },
     'history-export-defaults': { readonly: true },
     'history-retention-get': { readonly: true },
     'dir-list': { readonly: true },
-    'history-archive': { write: true },
     'history-unarchive': { write: true },
     'history-delete': { write: true },
-    'history-archive-batch': { write: true },
     'history-unarchive-batch': { write: true },
     'history-delete-batch': { write: true },
     'history-retention-set': { write: true },

package/lib/ops/memory.js

@@ -5,7 +5,7 @@
 //
 // ops 表里的包装（enqueueMutation / runWrite）**留在 service.ts**：本文件只导出裸 op，
 // 包装归属集中在一处，改门禁时一眼看全。
-import { lstat, mkdir, readFile, rm } from 'node:fs/promises';
+import { lstat, mkdir, readFile, rename, rm } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { parseSkillDoc, unquote } from '../skills/core.js';
 import { expandUploads, planMemoryImport } from '../imports/upload.js';
@@ -535,15 +535,46 @@ export function buildMemoryOps(rc) {
             await copyIntoMemoriesTrash(located, parts.group, parts.name);
             await rm(join(memoriesRoot, parts.group, parts.name + '.md'), { force: true });
         }
+        else if (located.kind === 'bundle' && newName !== parts.name) {
+            // bundle 改名 = **目录连同附件一起改**（2026-10-14 对抗性审查 P0-4）。
+            //
+            // 此前这条落到下面的 else：只把 frontmatter/正文写回**旧**路径，而索引照新名迁移 ——
+            // 实测（临时目录内复现）结果是索引里多一条指向不存在路径的记录（`rules-read` 报
+            // notFound），真实条目反而丢了索引记录，于是它承载的 `enabled` / `order` / `tags`
+            // 一起丢失：**一条停用的 bundle 记忆改个名就被静默重新启用**（重新进入每轮注入）。
+            // 面板的编辑框走同一个 op（`client/47-memory.js` 的 `submitUpdate`），所以两边同一条路。
+            //
+            // 形状与 flat 改名对齐：旧形态先整份进回收站（可恢复），再搬目录，最后把正文改名。
+            const oldDir = located.entryPath;
+            const newDir = join(memoriesRoot, parts.group, newName);
+            // 只改大小写时新旧是同一个目录（Windows / macOS 不区分大小写），不能按"已存在"拒。
+            const caseOnly = newName.toLowerCase() === parts.name.toLowerCase();
+            if (!caseOnly && await pathExists(newDir)) {
+                return fail('error.rules.exists', `同名记忆已存在（bundle）：${parts.group}/${newName}`);
+            }
+            // 正文文件名：新建的 bundle 一律 `<名>.md`；旧数据可能是 `SKILL.md`，那份**保持原名不动**
+            // （发现侧两个候选都认，改名时顺手动它只会把兼容数据弄坏）。
+            const keepLegacyDoc = basename(located.docPath) === LEGACY_BUNDLE_DOC;
+            await copyIntoMemoriesTrash(located, parts.group, parts.name);
+            await rename(oldDir, newDir);
+            const movedDoc = join(newDir, basename(located.docPath));
+            const targetDoc = join(newDir, keepLegacyDoc ? LEGACY_BUNDLE_DOC : bundleDocName(newName));
+            if (movedDoc !== targetDoc)
+                await rename(movedDoc, targetDoc);
+            await writeFileAtomically(targetDoc, serialize());
+        }
         else {
-            // bundle 不 rename 目录：只更新 frontmatter/正文
+            // bundle 不改名：只更新 frontmatter/正文
             await writeFileAtomically(located.docPath, serialize());
         }
         // 索引：改名则迁移记录（保留 order/tags/enabled 等），否则原地更新。
+        // 判据只看"名字变没变"，不再附加 `index.rules[id]` 存在 —— 磁盘上由外部新增、索引里
+        // 还没有记录的条目（发现侧会认它）改名时，旧判据会走到 else 把记录写回**旧名**，
+        // 于是新名下没有记录、旧名下多一条悬空的（2026-10-14 对抗性审查 P0-4 同族）。
         const index = await readIndex(stateDir);
         const newId = `${parts.group}/${newName}`;
-        if (newId !== id && index.rules[id]) {
-            index.rules[newId] = { ...index.rules[id], updatedAt: new Date().toISOString() };
+        if (newId !== id) {
+            index.rules[newId] = { ...(index.rules[id] || {}), updatedAt: new Date().toISOString() };
             delete index.rules[id];
         }
         else {
@@ -565,6 +596,13 @@ export function buildMemoryOps(rc) {
         if (typeof (args && args.enabled) !== 'boolean') {
             return fail('error.rules.invalidArgs', '缺少参数：enabled 必须是布尔值（toggle 只按传入值写入，不做"翻转"推断）');
         }
+        // 不存在的 id 必须拒绝（2026-10-15 smoke-test P1-4）：`parseId` 只校验 `<场景>/<名字>`
+        // 的形状，原先据此直接 `index.rules[id] = {...}` —— 于是一次拼错的 id 会**写进一条幽灵
+        // 索引**（磁盘上没有正文、清单里也列不出来，索引里却多一条 enabled），调用方还收到 ok。
+        // 判据与 `rulesRead` / `rulesUpdate` 同源：`locateRule` 在磁盘上找得到才算存在。
+        const located = await locateRule(parts.group, parts.name);
+        if (!located)
+            return fail('error.rules.notFound', `规则不存在：${id}`);
         const index = await readIndex(stateDir);
         const idxEntry = index.rules[id] || {};
         const enabled = args.enabled === true;

package/lib/ops/scene-records.js

@@ -514,9 +514,24 @@ export function buildSceneRecordOps(rc) {
     async function sceneTrashList() {
         return { ok: true, trash: await listTrashEntries('scenes') };
     }
+    /**
+     * 同名的场景里第一个空出来的退号名：`甲` → `甲（1）` → `甲（2）`…（全角括号，与界面
+     * `uniqueName` 同一写法）。超过段名长度上限的候选直接跳过 —— 退号名本身也得是合法段名。
+     */
+    function nextFreeSceneName(index, name) {
+        for (let i = 1; i <= 999; i += 1) {
+            const candidate = `${name}（${i}）`;
+            if (!isValidGroupPath(candidate))
+                return null;
+            if (!index.scenes?.[candidate])
+                return candidate;
+        }
+        return null;
+    }
     /**
      * 从回收站恢复一个场景：重建记忆目录 + 写回记录与档案。
-     * 同名场景已存在时**拒绝**（绝不覆盖既有场景）。
+     * 同名场景已存在时默认**拒绝**（绝不覆盖既有场景）；带 `dedupe: true` 时退号恢复
+     * （`甲` → `甲（1）`，用户 2026-10-14 裁定四个域都要能退号）。
      *
      * 场景名按**完整路径**寻址（2026-09-30 审查 P2-4，与删除侧同口径）：回收站里的名字来自
      * 当初删掉的那条记录，多段名同样得能恢复回来 —— 否则删得掉、恢复不了，数据就卡在回收站里。
@@ -526,12 +541,26 @@ export function buildSceneRecordOps(rc) {
         const entry = await readTrashEntry('scenes', id);
         if (!entry)
             return fail('error.rules.notFound', `回收站条目不存在：${id}`);
-        const name = String(entry.name || '').trim();
-        if (!isValidGroupPath(name))
-            return fail('error.rules.invalidGroup', `回收站里的场景名非法：${name || '(空)'}`);
+        const oldName = String(entry.name || '').trim();
+        if (!isValidGroupPath(oldName))
+            return fail('error.rules.invalidGroup', `回收站里的场景名非法：${oldName || '(空)'}`);
         const index = await readIndex(stateDir);
-        if (index.scenes?.[name])
-            return fail('error.rules.invalidGroup', `无法恢复，同名场景已存在：${name}`);
+        let name = oldName;
+        if (index.scenes?.[name]) {
+            // 「同名先问一句」（用户 2026-10-14）：拒绝时把候选名字一起回（`params.next`），
+            // 界面弹窗才能如实写出"确认后会叫 `甲（1）`"；用户确认后带 `dedupe: true` 重来。
+            const next = nextFreeSceneName(index, name);
+            if (args?.dedupe !== true || !next) {
+                // 专用错误码（四个回收站统一）：界面按它认出"这是撞名"并弹确认窗。原先这里复用
+                // `error.rules.invalidGroup`，那一条同时还表示"名字非法"，界面分不出来。
+                return fail('error.dup.conflict', `已存在同名场景：${name}`, {
+                    name,
+                    ...(next ? { next } : {}),
+                });
+            }
+            name = next;
+        }
+        const renamed = name !== oldName;
         const dir = join(memoriesRoot, name);
         // 恢复是**写入**方向：落点若是指向根外的目录链接，`mkdir` 会顺着链接成功、随后
         // `moveOutOfTrash` 把记忆文件写到**根外**去。与删除侧同一个根因（缺 realpath 根内断言），
@@ -590,17 +619,22 @@ export function buildSceneRecordOps(rc) {
         // 记忆条目随文件一起回来（删除时存进 `data.rules`，见 `rulesRemoveScene`）——
         // 否则恢复出来的记忆全部按 `enabled ?? true` 重置，用户停用的会复活（审查 P1-1）。
         // **只补不覆盖**：同名键若已存在以现有为准（上面已拒绝同名场景，正常情况下不会撞）。
+        //
+        // 退号恢复时这批记忆的 key 也要**跟着改名**：索引里的 key 是 `<场景>/<名>`，照抄旧 key
+        // 会让它们挂在旧场景名上 —— 文件躺在 `甲（1）/` 里、索引却指向 `甲/`，恢复出来的场景
+        // 一条记忆都看不见。前缀不匹配的（理论上不会有）原样保留，宁可留着也不猜。
         if (data.rules && typeof data.rules === 'object' && !Array.isArray(data.rules)) {
             const rules = index.rules || (index.rules = {});
             for (const [ruleId, ruleEntry] of Object.entries(data.rules)) {
-                if (rules[ruleId] === undefined)
-                    rules[ruleId] = ruleEntry;
+                const mapped = renamed && ruleId.startsWith(oldName + '/') ? name + ruleId.slice(oldName.length) : ruleId;
+                if (rules[mapped] === undefined)
+                    rules[mapped] = ruleEntry;
             }
         }
         await writeIndex(stateDir, index);
         await purgeTrashEntry('scenes', id);
         invalidateSnapshot();
-        return { ok: true, name, restoredFiles: restored.length };
+        return { ok: true, name, renamed, restoredFiles: restored.length };
     }
     /** 永久删除一条场景回收站条目。 */
     async function sceneTrashDelete(args) {

package/lib/ops/sessions.js

@@ -4,10 +4,13 @@
 // 整张表上（见 index.ts）。
 //
 // 本域的 op 名：history-list / history-sessions / history-export-defaults / dir-list /
-// history-archive / history-archive-batch / history-unarchive / history-delete /
+// history-unarchive / history-delete /
 // history-unarchive-batch / history-delete-batch / history-workspace-register /
 // history-import / bundle-export / history-export / history-retention-get /
 // history-retention-set。
+//
+// 归档（archive）不在这里：那是宿主的原生入口（官方侧栏），本插件只经 `domain/changed`
+// 事件同步归档时刻（见 src/sessions/bridge.ts），不替用户发起归档。
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
@@ -46,7 +49,7 @@ async function xdgDesktopDir() {
 export function buildSessionOps(deps) {
     return {
         // History（归档会话管理）ops。只读：history-list / history-retention-get；
-        // 写：history-archive / history-unarchive / history-delete / history-retention-set。
+        // 写：history-unarchive / history-delete / history-retention-set。
         // workspaceRegistry 缺失（补丁未生效）时返回明确错误，不崩页面。
         'history-list': async () => {
             const registry = deps.getSessionsRegistry();
@@ -204,43 +207,6 @@ export function buildSessionOps(deps) {
                 return { ok: false, error: deps.message(e) };
             }
         },
-        'history-archive': async (args) => {
-            const registry = deps.getSessionsRegistry();
-            if (!registry)
-                return { ok: false, error: '归档服务未挂载' };
-            const sessionId = String((args && args.sessionId) || '').trim();
-            if (!sessionId)
-                return { ok: false, error: '缺少 sessionId' };
-            try {
-                await registry.archiveSession(sessionId);
-                return { ok: true, sessionId };
-            }
-            catch (e) {
-                return { ok: false, error: deps.message(e) };
-            }
-        },
-        // 批量归档（导出弹窗「归档所选」）：把选中的会话收进 History，纳入保留期管理。
-        'history-archive-batch': async (args) => {
-            const registry = deps.getSessionsRegistry();
-            if (!registry)
-                return { ok: false, error: '归档服务未挂载' };
-            const rawIds = (args && args.sessionIds) || [];
-            const ids = Array.isArray(rawIds) ? rawIds.map((s) => String(s).trim()).filter(Boolean) : [];
-            if (!ids.length)
-                return { ok: false, error: '请至少选择一个会话' };
-            const archived = [];
-            const failed = [];
-            for (const sessionId of ids) {
-                try {
-                    await registry.archiveSession(sessionId);
-                    archived.push(sessionId);
-                }
-                catch (e) {
-                    failed.push({ sessionId, error: deps.message(e) });
-                }
-            }
-            return { ok: true, archived, failed };
-        },
         'history-unarchive': async (args) => {
             const registry = deps.getSessionsRegistry();
             if (!registry)