dsh-plugin-tool-management 0.20.0 → 0.20.1

package/lib/subagents/tools.js

@@ -15,11 +15,18 @@ export function text(v) {
  *      绑定的人设启用，见 archive-engine 的 applySubagentSwitches）。
  *   ② 场景绑定校验（设计 §3.3）：启用场景的 subagents 并集；空并集 = 全部可用。
  * 之前只有②：全局默认所有子智能体都进上下文，没有开关可言。
+ *
+ * `includeUnavailable`（2026-10-14 对抗性审查 P1-7）**只给 `subagent_manager_list` 的
+ * `all=true` 用**，两道闸一起放开：停用的人设此前**在任何地方都查不到** —— 注入目录只列可用的，
+ * `subagent_manager_switch` 又默认关着，于是模型既发现不了它、也就无从提示用户去启用。
+ * 另外三个 `*_list`（MCP / 技能 / 记忆）早就有 `all=true` 这个出口，人设是缺的那一个。
+ * 注意放开的只是**可见性**：`subagent_manager_run` 仍然按完整两道闸判"能不能委派"，
+ * 列出来 ≠ 可委派（回执里那句「人设不可用」照旧成立）。
  */
-export async function filterBySceneBinding(docs, enabledSceneLists) {
-    const live = docs.filter((d) => d.enabled !== false);
+export async function filterBySceneBinding(docs, enabledSceneLists, includeUnavailable = false) {
+    const live = includeUnavailable ? docs : docs.filter((d) => d.enabled !== false);
     const bound = new Set(enabledSceneLists.flat());
-    if (!bound.size)
+    if (includeUnavailable || !bound.size)
         return { allowed: live, reason: null };
     const allowed = live.filter((d) => bound.has(d.name));
     return { allowed, reason: allowed.length ? null : `当前启用场景的子智能体绑定: ${[...bound].join('、')}` };
@@ -27,19 +34,32 @@ export async function filterBySceneBinding(docs, enabledSceneLists) {
 export function defineSubagentManagerListTool(subagents) {
     return {
         name: 'subagent_manager_list',
-        description: 'List personas (pre-configured subagent profiles) with their descriptions. The「可委派的子智能体」reminder carries the same catalog; call this for the always-current full list.',
-        parameters: {},
+        // `depth-filtered` 删掉（2026-10-15 注入文本审查）：注入深度是**注入侧**的实现细节，
+        // 模型看到的是"目录里有哪些人设"，`catalogDepth` 那个词对它没有任何可操作性。
+        description: 'List personas (pre-configured subagent profiles) with their descriptions. The「当前子智能体」reminder carries a view of the same catalog; call this for the always-current full list, or pass all=true to include personas that are disabled or outside the active scene.',
+        parameters: {
+            all: { type: 'boolean', description: 'Include disabled personas and ones outside the active scene (default false). Listed ≠ delegable: `run` still refuses those.' },
+        },
         output: {
             schema: { type: 'string' },
             render: (_a, v) => text(String(v)),
         },
-        async execute(_args, exec) {
-            const { allowed, reason } = await filterBySceneBinding(await subagents.list(), await subagents.sceneLists());
+        async execute(args, exec) {
+            const includeUnavailable = Boolean(args?.all === true);
+            const docs = await subagents.list();
+            const { allowed, reason } = await filterBySceneBinding(docs, await subagents.sceneLists(), includeUnavailable);
             // 这里**不再按深度过滤**（2026-09-17 用户裁定，方案 A）：`catalogDepth` 只决定常驻目录
             // 注入到哪些会话，与"能不能委派"无关 —— 委派由官方决定（`dsh-tool-subagent` 默认能嵌套
             // 到 3 层）。此前按深度过滤等于把可用人设藏起来：目录不注入时模型只能靠这个工具查，
             // 而工具又不列全，结果是"明明能委派却查不到人设"。
-            const lines = allowed.map((p) => '- ' + p.name + ' — ' + (p.description || '(无描述)') + (p.continuable === true ? CONTINUABLE_MARK : ''));
+            // `all=true` 时**标出哪些不可用**：只列名字的话，模型照样分不清哪个能直接委派
+            // （与技能列表标 `shadowed-by:` 同一条理由 —— 列出来不等于能用）。
+            const lines = allowed.map((p) => '- ' + p.name + ' — ' + (p.description || '(无描述)') +
+                (p.continuable === true ? CONTINUABLE_MARK : '') +
+                (includeUnavailable ? (p.enabled === false ? '（已停用，需先启用）' : '') : ''));
+            // 默认口径下有多少个没列出来（停用的 + 不在启用场景里的）：不报的话，模型看到一份短名单
+            // 会当成"本机只有这些人设"。数量照报，与另外三个 list 的表头同一口径。
+            const hiddenCount = includeUnavailable ? 0 : docs.length - allowed.length;
             let notice = '';
             try {
                 notice = typeof subagents.noticeFor === 'function' ? await subagents.noticeFor(exec) : '';
@@ -47,7 +67,9 @@ export function defineSubagentManagerListTool(subagents) {
             catch {
                 notice = '';
             }
-            return '人设子智能体（' + allowed.length + '）：\n' + (lines.join('\n') || '(无)') + (reason ? '\n注意：' + reason : '') + notice;
+            const header = '人设子智能体（' + allowed.length + '）' +
+                (hiddenCount > 0 ? '（另有 ' + hiddenCount + ' 个停用或不在当前场景，传 all=true 查看）' : '') + '：\n';
+            return header + (lines.join('\n') || '(无)') + (reason ? '\n注意：' + reason : '') + notice;
         },
     };
 }
@@ -69,8 +91,13 @@ export function defineSubagentManagerRunTool(subagents) {
         // `how` 行（context-inject.ts 的 `DOMAIN_FRAME.subagents`）已经逐字说过一遍，而两份都在
         // 每轮上下文里 = 同一件事付两次 token。留注入那份（它出现在"正在选工具"的那一刻）。
         // 代价如实记下：子智能体域被关掉、或走压制型预设时上下文里没有那条 how 行，模型只剩本
-        // 描述与 `agent` 参数说明（"Persona name from subagent_manager_list"）—— 够它认出这条是
-        // 带人设的委派通道，但"没有人设贴合时才用官方那两个"这层分界就没人说了。
+        // 描述与 `agent` 参数说明 —— 够它认出这条是带人设的委派通道，但"没有人设贴合时才用官方
+        // 那两个"这层分界就没人说了。
+        //
+        // 2026-10-14（对抗性审查 P0-2）：`subagent_manager_list` 已移出出厂默认隐藏名单，所以
+        // `agent` 参数说明可以点名它（此前只能写"Persona name."，因为那条工具默认不在模型手里）。
+        // 注释里那句 "Persona name from subagent_manager_list" 从 2026-09-23 起就与代码逐字不符，
+        // 现在代码终于跟上了。
         //
         // 2026-09-23（用户裁定）：本工具的 `task` / `inherit` 两个参数说明与上面的 Modes 段
         // **逐字重复**，而工具表每轮都发 —— 同一件事付两次 token。实测 `subagent_manager_run`
@@ -78,11 +105,14 @@ export function defineSubagentManagerRunTool(subagents) {
         // 最贵的单个参数。收完两处重复后目标 ≈325 tok。判据是"删掉的那句在描述里已经有了吗"：
         // Modes 段留着（它是模型的入口），参数说明只留"这一段独有的信息"。
         // `inherit` 那句"轮中委派拿不到当前轮"必须留 —— 它是这条参数唯一会让人写错 task 的地方。
-        description: 'Run a named persona as a subagent: it gets the persona as its own system prompt, works on `task`, and returns only its final output. A persona marked「允许追问」instead returns an agent id and runs in the background — continue it with `send_message`.\n\nModes: by default a fresh child that cannot see this conversation, so `task` must be self-contained. With `inherit: true` it also gets this conversation\'s **finished** turns (like the host\'s `subagent_fork`) — the current turn is never included, so a mid-turn hand-off still needs a self-contained `task`.\n\n`task` = the goal plus the context it needs; leave method and output format to the persona.\n\nUse it when the work matches a persona in the「可委派的子智能体」reminder (a review, an investigation, a piece of writing) and the detail should not sit in your own context. Not for reading a file (Read), finding a definition (Grep/Glob), or touching two or three files.',
+        description: 'Run a named persona as a subagent: it gets the persona as its own system prompt, works on `task`, and returns only its final output. A persona marked「允许追问」instead returns an agent id and runs in the background — continue it with `send_message`.\n\nModes: by default a fresh child that cannot see this conversation, so `task` must be self-contained. With `inherit: true` it also gets this conversation\'s **finished** turns (like the host\'s `subagent_fork`) — the current turn is never included, so a mid-turn hand-off still needs a self-contained `task`.\n\n`task` = the goal plus the context it needs; leave method and output format to the persona.\n\nUse it when the work matches a persona in the「当前子智能体」reminder (a review, an investigation, a piece of writing) and the detail should not sit in your own context. Not for reading a file (Read), finding a definition (Grep/Glob), or touching two or three files.',
         parameters: {
-            agent: { type: 'string', required: true, description: 'Persona name.' },
-            task: { type: 'string', required: true, description: 'The task for the subagent. Self-contained by default; with inherit: true only state what is new.' },
-            inherit: { type: 'boolean', description: 'Let the subagent see this conversation\'s finished turns (the current turn is never included). Default false = a fresh child.' },
+            agent: { type: 'string', required: true, description: 'Persona name — see the「当前子智能体」reminder, or list personas with subagent_manager_list.' },
+            // `task` 的说明只留"这是什么"（2026-10-15 注入文本审查）：上面描述里那句
+            // "leave method and output format to the persona." 此前在这里**逐字重复**了一遍
+            // （57 字符），而模型填这个参数时两处都在手上 —— 同一件事付两次 token。
+            task: { type: 'string', required: true, description: 'The task for the subagent.' },
+            inherit: { type: 'boolean', description: 'Inherit this conversation\'s finished turns (current turn excluded). Default false.' },
         },
         output: {
             schema: { type: 'string' },

package/lib/tool-table-switch.js

@@ -3,8 +3,8 @@ import { addPreset, buildToolTableReport, DEFAULT_HIDDEN_TOOLS, dropPreset, migr
 export function createToolTableSwitch(deps) {
     // ---------- 模型工具表开关（侧车 `tool-table.json`，界面在「兼容」页）----------
     // 工具表按**每个请求**付钱：20 个工具的整份定义合计 ≈3,769 tok 每轮都在。关掉某几个，
-    // 它们整份不进请求（实测口径与取舍见 src/tools/table.ts 的文件头）。**出厂就已经关了十五条**
-    // （20 条里实发只剩 5 条）—— 名单、判据与代价在 `DEFAULT_HIDDEN_TOOLS`，只在这个人从没记过
+    // 它们整份不进请求（实测口径与取舍见 src/tools/table.ts 的文件头）。**出厂就已经关了十四条**
+    // （20 条里实发 6 条）—— 名单、判据与代价在 `DEFAULT_HIDDEN_TOOLS`，只在这个人从没记过
     // 选择时铺（见下面的 `toolTableSettingsFrom`）。
     //
     // 为什么放在目录之前：两个目录的「用 `X` 查」提示要跟着这份设置变（工具关掉后那句话
@@ -33,8 +33,8 @@ export function createToolTableSwitch(deps) {
         // 0.14.0 旧工具名迁移：读侧翻译一次并**回写盘**（幂等）。不迁移的话，用户"关掉了某条"
         // 的意图会在新名字上静默失效 —— 那条工具照旧每轮发出去，而界面上看不出来。
         // 写失败不回滚本次读取：内存里已经是迁移后的值，下次读会再试一次。
-        // 侧车不存在（`readJsonFile` 给 null）= 用户从没记过选择 ⇒ 用**出厂默认**（十五条不发，
-        // 实发 5 条；判据与代价见 tools/table.ts 的 DEFAULT_HIDDEN_TOOLS）。存过盘的
+        // 侧车不存在（`readJsonFile` 给 null）= 用户从没记过选择 ⇒ 用**出厂默认**（十四条不发，
+        // 实发 6 条；判据与代价见 tools/table.ts 的 DEFAULT_HIDDEN_TOOLS）。存过盘的
         // 一律照盘上那份，包括显式的 `hidden: []` —— 那是"我全都要"，不能被默认值盖掉。
         const migrated = migrateLegacyToolNames(toolTableSettingsFrom(raw));
         const value = migrated.settings;
@@ -59,7 +59,7 @@ export function createToolTableSwitch(deps) {
     }
     /**
      * 同步快照（热路径用：工具门禁每次调用、注入通道每个 step 都要问一句）。还没加载时先给
-     * **空集**并异步预热 —— 空集不是出厂默认（出厂关着五条），是刻意的：预热前的这一瞬与
+     * **空集**并异步预热 —— 空集不是出厂默认（出厂关着十四条），是刻意的：预热前的这一瞬与
      * 用户的选择可能不一致，但方向必须是安全的那一侧（不隐藏任何东西，绝不因为读盘慢而让
      * 工具凭空消失）。
      */
@@ -71,7 +71,7 @@ export function createToolTableSwitch(deps) {
         return toolTableCache.off;
     }
     const toolTableRows = () => [...toolTableSizes].map(([name, bytes]) => ({ name, bytes }));
-    const toolTableReport = (hidden = [...toolTableHidden()]) => buildToolTableReport(toolTableRows(), hidden);
+    const toolTableReport = (hidden = [...toolTableHidden()]) => buildToolTableReport(toolTableRows(), hidden, deps.carrierHiddenTools ? deps.carrierHiddenTools() : []);
     /** 落盘 + 同步内存缓存（三条写路径共用：改勾选 / 存方案 / 删方案）。 */
     async function writeToolTableSettings(next) {
         await deps.ensurePaths();

package/lib/tools/deps.js

@@ -21,3 +21,46 @@ export function toolNameList(list) {
     const head = list.slice(0, TOOL_NAME_LIST_CAP).join('、');
     return list.length > TOOL_NAME_LIST_CAP ? head + ' 等 ' + list.length + ' 项' : head;
 }
+/**
+ * 按名字找技能落在哪个来源（root）。
+ *
+ * 为什么需要它（2026-10-15 smoke-test P0-1）：`skill-create` 的默认落点是 **hub**
+ * （`tool-management/skills/`，与界面「创建技能」一致），而 `skill-enable` / `skill-disable` /
+ * `skill-prefer` / `skill-delete` 这些 op 的默认 root 是 **dsh**。于是「建完就启用」这条
+ * 最自然的链路必然报「技能不存在」—— 同一个动作在工具侧落 hub、在开关侧查 dsh。
+ * 默认值改哪边都不对（面板显式传 root，两边都依赖自己的默认），所以判定放到工具侧：
+ * **没给 root 就在全部来源里按名字找胜出副本**，找到哪个就用哪个。
+ *
+ * 选取口径与 `skill_manager_read` 同一套（`markWinners` 已标出影子副本）：先取没被
+ * `shadowedBy` 盖住的那一份（同名组里胜出的只有一个），都没有就取第一个。
+ */
+export async function locateSkillRoot(skillsOps, name) {
+    const wanted = String(name || '').trim();
+    if (wanted === '')
+        return { ok: true, root: null, roots: [] };
+    let state;
+    try {
+        state = await skillsOps['skill-state']({});
+    }
+    catch {
+        return { ok: false, root: null, roots: [] };
+    }
+    if (!state || state.ok === false)
+        return { ok: false, root: null, roots: [] };
+    const roots = [];
+    const hits = [];
+    for (const root of (state.data && state.data.roots) || []) {
+        roots.push(String(root.key || ''));
+        for (const skill of root.skills || []) {
+            // 与 list / read / save 同一套名字口径：`declaredName || name`，再比目录名。
+            if (String(skill.declaredName || skill.name || '') !== wanted && String(skill.name || '') !== wanted)
+                continue;
+            hits.push({
+                rootKey: String(root.key || ''),
+                shadowedBy: skill.shadowedBy && skill.shadowedBy.root ? String(skill.shadowedBy.root) : '',
+            });
+        }
+    }
+    const winner = hits.find((hit) => hit.shadowedBy === '') || hits[0];
+    return { ok: true, root: winner ? winner.rootKey : null, roots };
+}

package/lib/tools/mcp.js

@@ -27,13 +27,22 @@
 // `resolveMaskedKv({}, 旧值)` 把整份 headers / env 静默清空、连 warning 都不给。
 import { DEFAULT_MCP_NOTE_MAX_LENGTH, normalizeMcpNote } from '../mcp/state-section.js';
 import { text } from './deps.js';
-/** 「去看清单」那句：`mcp_manager_list` 被关掉时不能点名它（调用方按 `toolVisible` 决定给不给）。 */
+/** 「去看清单」那句：`mcp_manager_list` 不在模型手里时不能点名它（调用方按 `toolVisibleFor` 决定给不给）。 */
 const MCP_LIST_HINT = '（用 mcp_manager_list 看清单，all=true 连停用的也列）';
+/**
+ * 指不到 `mcp_manager_list` 时的**中性出口**：不点名任何工具，两条常驻来源都成立
+ * —— 模型自己的 `mcp__<server>__<tool>` 工具名（就在它的 schema 里），以及注入段。
+ *
+ * 为什么必须有这一句（2026-10-14 对抗性审查 P0-1）：`mcp_manager_switch` 是默认**唯一可见**
+ * 的 MCP 工具，猜错 serverName 时若报错里只有「没有这台服务器：X」，模型拿不到任何补救线索
+ * —— 它只能猜第二次。出口要么指向工具（那条工具得在它手里），要么指向这两条常驻来源。
+ */
+const MCP_NEUTRAL_HINT = '（服务器名照抄你自己 `mcp__<server>__<tool>` 工具名里的那一段，或「当前 MCP 服务器」段里列出的名字）';
 /** 按 serverName 定位条目；同名（project + global 各一台）时要求 level 明确指定。 */
 function locate(rows, server, level, listHint = MCP_LIST_HINT) {
     const hits = (rows || []).filter((r) => String(r.serverName) === server);
     if (!hits.length) {
-        throw new Error('没有这台服务器：' + server + listHint);
+        throw new Error('没有这台服务器：' + server + (listHint || MCP_NEUTRAL_HINT));
     }
     if (level) {
         const picked = hits.filter((r) => r.level === level);
@@ -64,15 +73,27 @@ function argsToText(value) {
 }
 export function buildMcpTools(deps) {
     const { defineTool, register } = deps;
-    /** 那句"去看清单"要不要给：`mcp_manager_list` 在出厂默认里就是关着的，点名一条模型没有的工具
-     *  只会让它白跑一趟（执行侧拦住它，而它看不出为什么）。 */
-    const listHint = () => (deps.toolVisible('mcp_manager_list') ? MCP_LIST_HINT : '');
+    /**
+     * 那句"去看清单"要不要给：`mcp_manager_list` 在出厂默认里就是关着的，点名一条模型没有的工具
+     * 只会让它白跑一趟（执行侧拦住它，而它看不出为什么）。
+     *
+     * 判据按 **agent** 而不是全局开关（2026-10-14 对抗性审查 P0-1）：全局关着、但这个人设没砍掉
+     * 它时，那句话是对的；反过来，全局开着、而这个人设用 `toolsDeny` 砍掉了它时，只读全局开关
+     * 就会让我们点名一条它手里没有的工具。与注入框架 `how` 行同一份判据（`toolVisibleFor`）。
+     */
+    const listHint = (agent) => (deps.toolVisibleFor('mcp_manager_list', agent) ? MCP_LIST_HINT : '');
     register(defineTool({
         name: 'mcp_manager_list',
         // 注入段与本工具的关系要**如实说成筛过的视图**（而非"同一份清单"）：注入段只列可用 +
         // 曾连上现掉线的服务器（停用的不进），也不带 level / loader / 工具数。把这个盲区写出来
         // 是行动依据 —— 模型要知道"停用的那台去哪查"就得靠这句（all=true）。
-        description: 'List configured MCP servers (level, enabled state, live loader status, tool count excluding switched-off tools, note). Read a server\'s note before choosing it. The「本机 MCP 服务器的当前状态」reminder carries a filtered view (usable servers, ones that were reachable before but are down now, and their notes; disabled servers are omitted); this tool is the raw view — defaults to enabled servers, all=true for every configured one.',
+        //
+        // 2026-10-15 注入文本审查：删掉两处白付的 token ——
+        //   ① 括号里那句把「当前 MCP 服务器」reminder 的**内容**逐项列了一遍（可用 / 曾连上 /
+        //      备注 / 停用不进），而那段 reminder 每轮就在模型上下文里，它自己看得到；
+        //   ② `where loader:on:<phase> is the loader's current phase` —— 用自己解释自己
+        //      （phase 就是 phase），零信息。字段名本身留在输出里，模型照抄即可。
+        description: 'List configured MCP servers (level project|global; enabled state; live loader status; tool count excluding switched-off tools; user hint). The「当前 MCP 服务器」reminder is a filtered view; this tool is the raw one — defaults to enabled servers, all=true for every configured one. Pass tools=true to list each server\'s tool names.',
         parameters: {
             all: { type: 'boolean', description: 'Include disabled servers (default false).' },
             tools: { type: 'boolean', description: 'Also list each server\'s tool names, marking the switched-off ones (default false).' },
@@ -98,7 +119,7 @@ export function buildMcpTools(deps) {
                 // 工具数 = 可用数（停用表扣减后）：段里给模型的是同一个口径，模型据此与
                 // 自己 schema 里的 `mcp__*` 工具对得上；被场景收窄 / 手动关掉的工具不算。
                 const usableTools = typeof x.enabledToolCount === 'number' ? x.enabledToolCount : x.toolCount;
-                lines.push(x.id + ' | ' + x.serverName + ' | ' + x.level + ' | ' + (x.disabled ? 'disabled' : 'enabled') +
+                lines.push('server:' + x.serverName + ' | level:' + x.level + ' | ' + (x.disabled ? 'disabled' : 'enabled') +
                     (x.live ? ' | loader:' + (x.live.enabled ? 'on' : 'off') + (x.live.phase ? ':' + x.live.phase : '') : '') +
                     (typeof usableTools === 'number' ? ' | tools:' + usableTools : '') +
                     (note ? ' | user-hint:' + note : ''));
@@ -132,15 +153,22 @@ export function buildMcpTools(deps) {
         name: 'mcp_manager_switch',
         // 为什么 action 是必填枚举而不是两个可选布尔：模型最容易犯的错是"想重启却只传了 server"，
         // 让它在三个动词里选一个，比让它猜两个布尔的组合省一次往返。
-        description: 'Turn one configured MCP server on or off, or restart it (reconnects and re-syncs tools). Pass `tool` to switch just that tool. Only when the user asks or approves.',
+        // `restart` 的含义只在 `action` 参数里说一次（2026-10-15 注入文本审查）：描述里那句
+        // "(reconnects and re-syncs tools)" 与参数说明逐字重复，而模型读参数时两处都在手上。
+        description: 'Turn one configured MCP server on or off, or restart it. Pass `tool` to switch just that tool. Blocked while the active scene is locked — except restart, which is the recovery path. Only when the user asks or approves.',
         parameters: {
-            server: { type: 'string', required: true, description: 'Server name as shown in the list.' },
+            // 出口必须指向**常驻**来源，不能指向 `mcp_manager_list`（2026-10-14 对抗性审查 P0-1）：
+            // 那条工具在出厂默认里就是关着的，`listHint()` 在它不可见时返回空串，于是猜错名字时的
+            // 报错退化成「没有这台服务器：<你猜的>」—— 一个字都不告诉它还能去哪看。
+            // 指向模型自己的工具表（`mcp__<server>__<tool>` 就在它的 schema 里）与常驻注入段，
+            // 这两条**不需要任何工具可见**就成立。
+            server: { type: 'string', required: true, description: 'Server name, as it appears in your own `mcp__<server>__<tool>` tool names (the「当前 MCP 服务器」reminder lists the usable ones).' },
             action: { type: 'string', required: true, enum: ['on', 'off', 'restart'], description: 'on = enable, off = disable, restart = reconnect and re-sync tools.' },
             level: { type: 'string', description: 'project or global — only to disambiguate same-name servers.' },
             tool: { type: 'string', description: 'One tool name on that server (no mcp__ prefix). Only for on/off.' },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
-        async execute(args) {
+        async execute(args, exec) {
             const action = String((args && args.action) || '');
             if (action !== 'on' && action !== 'off' && action !== 'restart') {
                 throw new Error('action 只能是 on / off / restart（收到：' + (action || '(空)') + '）');
@@ -161,7 +189,7 @@ export function buildMcpTools(deps) {
             if (!list || list.ok === false)
                 throw new Error((list && list.error) || '读取 MCP 配置失败');
             const level = args && args.level !== undefined ? String(args.level) : undefined;
-            const row = locate(list.rows || [], server, level, listHint());
+            const row = locate(list.rows || [], server, level, listHint(exec && exec.agent));
             const enabled = action === 'on';
             if (tool !== '') {
                 const r = await deps.mcpmToolEnabled({ serverName: String(row.serverName), tool, enabled });
@@ -193,20 +221,24 @@ export function buildMcpTools(deps) {
     }));
     register(defineTool({
         name: 'mcp_manager_save',
-        description: 'Add a new MCP server, or update the one with this name — the receipt says which. Omitted fields keep their current values, so never restate the whole server. Only on the user\'s explicit request.',
+        description: 'Add a new MCP server, or update the one with this name — the receipt says which. Omitted fields keep their current values, so never restate the whole server. Pass `hint` to add a usage hint or fallback note. Blocked while the active scene is locked. Only on the user\'s instruction.',
         parameters: {
             server: { type: 'string', required: true, description: 'Server name (1-32 chars, [A-Za-z0-9_-]) — the name the mcp__<server>__ tools use.' },
             transport: { type: 'string', description: 'streamable-http or stdio. Required when creating; omit = keep.' },
             url: { type: 'string', description: 'Server URL (streamable-http). Omit = keep.' },
             command: { type: 'string', description: 'Executable to spawn (stdio). Omit = keep.' },
-            args: { type: 'string', description: 'Arguments, space separated (stdio). Omit = keep.' },
+            args: { type: 'string', description: 'Arguments, space or comma separated (stdio). Omit = keep.' },
             headers: { type: 'string', description: 'Extra headers, key=value per line (streamable-http). Omit = keep — omitting is what preserves the real secrets.' },
             env: { type: 'string', description: 'Extra env vars, key=value per line (stdio). Omit = keep.' },
             level: { type: 'string', description: 'project or global (project when creating); only needed for same-name servers.' },
-            note: { type: 'string', description: 'Short hint for later: how to use it, or which one to fall back to when it is down.' },
+            // 名字与注入段对齐（2026-10-14 对抗性审查 P1-2）：注入段与工具输出都写 `user-hint`
+            // （对应中文那句「用户提示：」），参数名跟着叫 `hint`，一份数据三个面一个词。
+            // 「写什么」那半句已经由注入框架的 `how` 行逐字说过（"选服务器之前先看一眼"），
+            // 这里只留参数独有的信息：长度上限与截断行为（2026-10-14 审查 P2-4）。
+            hint: { type: 'string', description: "Short hint for later (≤300 chars; longer is stored whole but truncated in listings). '' clears the existing hint; omit = keep." },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
-        async execute(args) {
+        async execute(args, exec) {
             const blocked = await deps.lockedSceneGuard();
             if (blocked)
                 throw new Error(blocked);
@@ -214,8 +246,13 @@ export function buildMcpTools(deps) {
             if (!server)
                 throw new Error('缺少参数：server（服务器名）');
             const levelArg = args && args.level !== undefined ? String(args.level) : undefined;
-            const noteText = args && args.note !== undefined ? String(args.note) : '';
-            const hasNote = noteText.trim() !== '';
+            // `hint` 的三态（2026-10-15 修 P1-5）：省略 = 保持；`''` = **清空**；非空 = 设置。
+            // 此前用 `hintText.trim() !== ''` 判"要不要写备注"，把"清空"与"省略"混成一件事 ——
+            // 模型传 `hint: ""` 想清掉已有备注时收到「没有要改的东西」，而 op 侧 `mcpm-note`
+            // 本来就支持空串清空（`manager.ts:431`）。判据改成"参数给没给"，不是"值空不空"。
+            const hintGiven = Boolean(args && args.hint !== undefined);
+            const hintText = hintGiven ? String(args.hint) : '';
+            const clearsNote = hintGiven && hintText.trim() === '';
             const list = await deps.mcpmListView();
             if (!list || list.ok === false)
                 throw new Error((list && list.error) || '读取 MCP 配置失败');
@@ -250,15 +287,15 @@ export function buildMcpTools(deps) {
                 // 备注单独走 `mcpm-note`（`mcpm-add` 不认这个字段）。失败**不回滚**主写入：
                 // 服务器已经建好了，"备注没写上"是 warning，不是失败（与 0.13.0 界面同规格）。
                 let warn = '';
-                if (hasNote) {
-                    const n = await deps.mcpmNote({ id: String(r.row.id), note: noteText });
+                if (hintGiven && !clearsNote) {
+                    const n = await deps.mcpmNote({ id: String(r.row.id), note: hintText });
                     if (!n || n.ok === false)
                         warn = '\nWARN: 服务器已建好，但备注没写进去（' + ((n && n.error) || '未知原因') + '）';
                 }
                 return 'OK: created ' + r.row.id + ' at ' + r.row.level + warn;
             }
             // ── 改：省略 = 保持，且必须**显式填回**（见文件头那条 parseKv 的坑）────────
-            const cur = locate(hits, server, levelArg, listHint());
+            const cur = locate(hits, server, levelArg, listHint(exec && exec.agent));
             const transport = args && args.transport !== undefined ? String(args.transport) : String(cur.transport);
             if (transport !== 'stdio' && transport !== 'streamable-http') {
                 throw new Error('transport 只能是 stdio 或 streamable-http（这台现在是：' + String(cur.transport) + '）');
@@ -327,26 +364,30 @@ export function buildMcpTools(deps) {
             // 只给了备注：不必走 `mcpm-edit` 把整条重建一遍（那是一次无意义的写盘 + 刷新 updatedAt），
             // 直接写备注。这与"三个可改字段一个都没给就拒"是同一条理由的两面。
             if (!touched.length && !levelChanged) {
-                if (!hasNote)
-                    throw new Error('没有要改的东西：transport / url / command / args / headers / env / level / note 至少给一个');
-                const n = await deps.mcpmNote({ id: cur.id, note: noteText });
+                if (!hintGiven)
+                    throw new Error('没有要改的东西：transport / url / command / args / headers / env / level / hint 至少给一个');
+                const n = await deps.mcpmNote({ id: cur.id, note: hintText });
                 if (!n || n.ok === false)
                     throw new Error((n && n.error) || '写备注失败');
-                return 'OK: updated ' + String(cur.serverName) + '（改了 note）';
+                return 'OK: updated ' + String(cur.serverName) + '（' + (clearsNote ? 'hint 已清空' : '改了 hint') + '）';
             }
             const r = await deps.mcpmEdit(payload);
             if (!r || r.ok === false)
                 throw new Error((r && r.error) || '修改服务器失败');
-            const changed = touched.concat(levelChanged ? ['level'] : [], hasNote ? ['note'] : []);
+            // `hint` 进 `changed` 必须**等写成功之后**（2026-10-15 修 P1-6）：此前按意图先算进去，
+            // mcpmNote 失败时回执一边说"改了 hint"、一边 WARN"备注没写进去"，模型读不出到底改没改。
+            const changed = touched.concat(levelChanged ? ['level'] : []);
             let warn = '';
             // `mcpm-edit` 的守卫会把"打码值被顶替回真值"这件事回报出来（只含键名，不含值）——
             // 转给模型，它才知道"我没重述的密钥确实保住了"。
             if (r.warning)
                 warn += '\nNOTE: ' + String(r.warning);
-            if (hasNote) {
-                const n = await deps.mcpmNote({ id: cur.id, note: noteText });
+            if (hintGiven) {
+                const n = await deps.mcpmNote({ id: cur.id, note: hintText });
                 if (!n || n.ok === false)
                     warn += '\nWARN: 服务器已保存，但备注没写进去（' + ((n && n.error) || '未知原因') + '）';
+                else
+                    changed.push(clearsNote ? 'hint（已清空）' : 'hint');
             }
             if (ignored.length) {
                 warn += '\nWARN: ' + ignored.join(' / ') + ' 与当前 transport（' + transport + '）无关，已忽略';

package/lib/tools/memory.js

@@ -26,15 +26,23 @@ export function buildMemoryTools(deps) {
         name: 'memory_manager_list',
         // 末尾**不点名** `scene_manager_list`：场景一族在出厂默认里就是关着的，指向一条模型没有的
         // 工具只会让它去猜名字（用户 2026-09-23 把默认名单扩到十五条时去掉的这句）。
-        description: 'List memories (id, scene, enabled, description) plus the scene injection currently follows. What is injected each turn is in the「本机当前的记忆」reminder; use this for ids and for entries that are off. all=true lists everything.',
+        description: 'List memories (id, scene, enabled, form flat|bundle, description) plus the scene injection currently follows. What is injected each turn is in the「当前记忆」reminder; use this for ids and for entries that are off. Pass a `scene` to filter by scene; all=true lists everything.',
         parameters: {
-            group: { type: 'string', description: 'Optional scene filter.' },
+            // 参数名与其余五个域同词（2026-10-14 对抗性审查 P1-3）：同一个概念在工具面只该有一个名字，
+            // 而 `scene` 是它在 `scene_manager_*`、`<scene>/<name>` 与注入段标题里的叫法。
+            // op 的内部契约字段仍是 `group`（`rules-list` 与界面侧调用方都读它），所以 execute 里
+            // 显式映射一次 —— 改 op 的字段名要动界面，那不是这一条能顺手做的事。
+            scene: { type: 'string', description: 'Optional scene filter.' },
             all: { type: 'boolean', description: 'Include memories that are off, in an inactive scene, or shadowed (default false).' },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
         async execute(args, exec) {
             const showAll = Boolean(args && args.all === true);
-            const r = await deps.rulesOps['rules-list'](args);
+            // `scene` → `group`：只把 op 认的那个字段传过去，别把 `scene` 也塞给它（它不认）。
+            const opArgs = {};
+            if (args && args.scene !== undefined)
+                opArgs.group = args.scene;
+            const r = await deps.rulesOps['rules-list'](opArgs);
             if (!r || r.ok === false)
                 throw new Error((r && r.error) || '读取规则失败');
             // 「会注入」的判定与记忆段同源（renderSceneMemory）：global 场景恒常注入，其余场景要
@@ -54,6 +62,11 @@ export function buildMemoryTools(deps) {
             const rows = (r.rules || []).map((x) => ({ x, ...stateOf(x) }));
             const shown = showAll ? rows : rows.filter((row) => row.injects);
             const lines = shown.map(({ x, label }) => ('- ' + x.id + ' [' + (x.group || '未归属场景') + '] ' + label +
+                // 形态与附件（2026-10-15）：此前不报，模型分不清哪条是 bundle、更不知道它带了几个附件
+                // （`rules-list` 早就把 `form` 与 bundle 的附件摘要给了出来，只是这里没渲染）。
+                (x.form === 'bundle'
+                    ? ' · bundle' + (x.attach && x.attach.count ? '（' + x.attach.count + ' 个附件）' : '')
+                    : '') +
                 (x.description ? ' — ' + x.description : '')));
             // 注入按哪个场景走 —— 上面那句「场景未启用」只有配上它才可解读：少了这一行，
             // 模型看到一片"未启用"会以为是条目自己的问题。（场景本身的清单在 `scene_manager_list`，
@@ -74,7 +87,10 @@ export function buildMemoryTools(deps) {
     }));
     register(defineTool({
         name: 'memory_manager_read',
-        description: 'Read the full body of one memory. Only for ones not already in your context (disabled, scene not active, or dropped by the byte budget).',
+        // "dropped by the byte budget" 改成"left out of it"（2026-10-15 注入文本审查）：byte budget
+        // 是本插件内部术语，模型没有这个概念 —— 它只知道"这条在不在我上下文里"。说内部机制
+        // 等于让它去猜一个它观测不到的量。
+        description: 'Read the full body of one memory, plus its form (flat|bundle) and the names of its attachments. Only for ones not already in your context (disabled, in an inactive scene, or left out of it). Attachment contents are not returned — read those with your file tools.',
         parameters: {
             memory: { type: 'string', required: true, description: 'Memory id like <scene>/<name>.' },
         },
@@ -84,7 +100,16 @@ export function buildMemoryTools(deps) {
             const r = await deps.rulesOps['rules-read']({ id: String((args && args.memory) || '') });
             if (!r || r.ok === false)
                 throw new Error((r && r.error) || '读取规则失败');
-            return '# ' + r.rule.id + '\n\n' + (r.rule.body || '');
+            const rule = r.rule || {};
+            // 形态与附件名（2026-10-15）：op 一直把 `attachments` 给了出来，这里此前**整个丢掉**，
+            // 于是模型连"这条记忆是 bundle、带了 3 个附件"都看不到。只给名字不给内容 ——
+            // 附件可能是图片或大 md，全文塞回来会吃光这一轮的上下文（与注入段附件行同口径）。
+            const attach = Array.isArray(rule.attachments) ? rule.attachments : [];
+            const form = rule.form === 'bundle' ? 'bundle' : 'flat';
+            const attLine = attach.length
+                ? '\n附件（' + attach.length + ' 个）：' + attach.map((a) => String((a && a.name) || a)).join('、')
+                : '';
+            return '# ' + rule.id + '（' + form + '）' + attLine + '\n\n' + (rule.body || '');
         },
     }));
     register(defineTool({
@@ -102,7 +127,9 @@ export function buildMemoryTools(deps) {
         // 三个写侧工具共用一句 consent（`Only when the user asks or approves.` / `Only on the
         // user's instruction.`）：这些动的都是"以后每一轮都会带上"的东西，模型不该顺手做。
         // 描述同时按"省 token"重写了一遍 —— 这几段文字每次请求都要发出去，废话是常驻成本。
-        description: 'Enable or disable one memory (index switch; the .md file is untouched). Disabled memories stop being injected, freeing the byte budget. Prefer this over deleting — it is reversible. Only when the user asks or approves.',
+        // 后半句"freeing the byte budget"删掉（2026-10-15 注入文本审查）：byte budget 是本插件
+        // 内部术语，模型据此做不了任何判断 —— "不再被注入"已经是它需要的全部因果。
+        description: 'Enable or disable one memory. Disabled memories stop being injected. Reversible. Only when the user asks or approves.',
         parameters: {
             memory: { type: 'string', required: true, description: 'Memory id like <scene>/<name>.' },
             enabled: { type: 'boolean', required: true, description: 'true = enable, false = disable; omission is refused.' },
@@ -145,12 +172,15 @@ export function buildMemoryTools(deps) {
         // （场景段 128 KiB），而模型很乐意把「这个项目用 pnpm」记一条 —— 那看一眼 `package.json`
         // 就知道，记下来却永久占着每一轮请求。合并 write/update 后这两句更要留：upsert 降低了
         // "再记一条"的摩擦，而摩擦正是这里唯一拦得住它的东西。
-        description: 'Create a memory, or update the one that already has this id — the receipt says which happened. Memories cost context on EVERY later request, so record only what cannot be re-derived from code, config or git, and check the list for one that already says this — update that instead of adding a near-duplicate. Only on the user\'s instruction.',
+        description: 'Create a memory, or update the one that already has this id — the receipt says which happened. Memories cost context on EVERY later request, so record only what cannot be re-derived from code, config or git, and check the list for one that already says this — update that instead of adding a near-duplicate. Blocked while the active scene is locked. Only on the user\'s instruction.',
         parameters: {
             memory: { type: 'string', required: true, description: 'Memory id like <scene>/<name> — copy it from the list. `global` is the always-on scene.' },
             description: { type: 'string', description: 'One-sentence description (<=500 chars). Required when creating. Empty string = drop it and re-derive from the body; omit = keep.' },
             body: { type: 'string', description: 'Markdown body (<=256 KiB). Required when creating. Omit to keep the current body.' },
-            nextName: { type: 'string', description: 'New memory name (= file name); omit to keep it. The old file goes to the trash.' },
+            // 不再承诺「旧文件进回收站」（2026-10-14 对抗性审查 P0-3）：bundle 记忆改名走的是
+            // 「只重写正文、目录不动」那条路，一个字都不进回收站 —— 对 bundle 说进回收站是假话。
+            // 与上一轮 P1-1 同口径：**只说可逆，不说实现细节**。
+            nextName: { type: 'string', description: 'New memory name (= file name); omit to keep it.' },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
         async execute(args) {
@@ -232,7 +262,17 @@ export function buildMemoryTools(deps) {
             const warn = dup.length
                 ? `\n注意：已有 ${dup.length} 条名字或描述与它很像（${dup.join('、')}）—— 若是同一件事，改那一条而不是留着两条。`
                 : '';
-            return 'OK: created ' + r.rule.id + '（场景「' + (r.rule.group || '未归属') + '」启用后自动生效）' + warn;
+            // 回执必须同时说清**两个**条件（2026-10-15 smoke-test P1-3）：新建的记忆在 op 层是
+            // `enabled: false`（ops/memory.ts 的 rulesCreate），而原先这句只提场景 —— 读起来像
+            // "场景一开它就自动生效"，模型据此以为已经生效，实际还差一次开关。与 skill_manager_save
+            // 的 enableHint 同一形状：点名的工具在出厂默认名单里是关着的，关着就改说"用户开启后"。
+            const sceneActive = group === 'global' ||
+                (group !== '' && (all.activeMode === 'all' || String(all.activeScene || '') === group));
+            const sceneTail = sceneActive ? '' : '，并启用场景「' + group + '」';
+            const enableHint = deps.toolVisible('memory_manager_switch')
+                ? '（新建默认停用，要生效先 memory_manager_switch 开它' + sceneTail + '）'
+                : '（新建默认停用，用户开启后才能生效' + sceneTail + '）';
+            return 'OK: created ' + r.rule.id + enableHint + warn;
         },
     }));
 }