dsh-plugin-tool-management 0.20.2 → 0.21.0

package/lib/subagents/tools.js

@@ -29,14 +29,14 @@ export async function filterBySceneBinding(docs, enabledSceneLists, includeUnava
     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('、')}` };
+    return { allowed, reason: allowed.length ? null : `the enabled scene's subagent bindings: ${[...bound].join(', ')}` };
 }
 export function defineSubagentManagerListTool(subagents) {
     return {
         name: 'subagent_manager_list',
         // `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.',
+        description: 'List personas (pre-configured subagent profiles) with their descriptions. The "Current subagents" 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.' },
         },
@@ -54,9 +54,9 @@ export function defineSubagentManagerListTool(subagents) {
             // 而工具又不列全，结果是"明明能委派却查不到人设"。
             // `all=true` 时**标出哪些不可用**：只列名字的话，模型照样分不清哪个能直接委派
             // （与技能列表标 `shadowed-by:` 同一条理由 —— 列出来不等于能用）。
-            const lines = allowed.map((p) => '- ' + p.name + ' — ' + (p.description || '(无描述)') +
+            const lines = allowed.map((p) => '- ' + p.name + ' — ' + (p.description || '(no description)') +
                 (p.continuable === true ? CONTINUABLE_MARK : '') +
-                (includeUnavailable ? (p.enabled === false ? '（已停用，需先启用）' : '') : ''));
+                (includeUnavailable ? (p.enabled === false ? ' (disabled — turn it on first)' : '') : ''));
             // 默认口径下有多少个没列出来（停用的 + 不在启用场景里的）：不报的话，模型看到一份短名单
             // 会当成"本机只有这些人设"。数量照报，与另外三个 list 的表头同一口径。
             const hiddenCount = includeUnavailable ? 0 : docs.length - allowed.length;
@@ -67,9 +67,9 @@ export function defineSubagentManagerListTool(subagents) {
             catch {
                 notice = '';
             }
-            const header = '人设子智能体（' + allowed.length + '）' +
-                (hiddenCount > 0 ? '（另有 ' + hiddenCount + ' 个停用或不在当前场景，传 all=true 查看）' : '') + '：\n';
-            return header + (lines.join('\n') || '(无)') + (reason ? '\n注意：' + reason : '') + notice;
+            const header = 'persona subagents (' + allowed.length + ')' +
+                (hiddenCount > 0 ? ' (' + hiddenCount + ' more are disabled or outside the current scene; pass all=true to see them)' : '') + ':\n';
+            return header + (lines.join('\n') || '(none)') + (reason ? '\nnote: ' + reason : '') + notice;
         },
     };
 }
@@ -105,9 +105,9 @@ 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 `(continuable)` 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 "Current subagents" 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 — see the「当前子智能体」reminder, or list personas with subagent_manager_list.' },
+            agent: { type: 'string', required: true, description: 'Persona name — see the "Current subagents" reminder, or list personas with subagent_manager_list.' },
             // `task` 的说明只留"这是什么"（2026-10-15 注入文本审查）：上面描述里那句
             // "leave method and output format to the persona." 此前在这里**逐字重复**了一遍
             // （57 字符），而模型填这个参数时两处都在手上 —— 同一件事付两次 token。
@@ -123,22 +123,23 @@ export function defineSubagentManagerRunTool(subagents) {
             const task = String((args && args.task) || '').trim();
             const inherit = args && args.inherit === true;
             if (!task)
-                throw new Error('task 不能为空');
+                throw new Error('task must not be empty');
             // 官方 SubagentStartRequest.parent 必填：调用方 agent 缺失时给结构化错误，不把 undefined 透传下去。
             if (!exec || !exec.agent)
-                throw new Error('缺少调用方 agent（exec.agent 不可用）：无法创建子代理运行');
+                throw new Error('no caller agent (exec.agent is unavailable): cannot create a subagent run');
             const docs = await subagents.list();
             const { allowed, reason } = await filterBySceneBinding(docs, await subagents.sceneLists());
             const persona = allowed.find((p) => p.name === name);
             if (!persona) {
-                const available = allowed.map((p) => p.name).join('、') || '(无)';
-                throw new Error('人设不可用: ' + name + (reason ? '（' + reason + '）' : '（可用: ' + available + '）'));
+                const available = allowed.map((p) => p.name).join(', ') || '(none)';
+                throw new Error('persona unavailable: ' + name + (reason ? ' (' + reason + ')' : ' (available: ' + available + ')'));
             }
             // 这里**刻意没有**"深度不够就拒绝"的检查（2026-09-17 用户裁定，方案 A）。
             // 它此前基于一个错误假设：以为传 `maxDepth: 1` 会让子会话再委派必然失败。实际上官方
-            // `dsh-tool-subagent` 的默认是 **3**、provider 只在**传了值**时才校验，所以子代理本来
-            // 就能继续嵌套。那个检查的唯一净效果是让**我们的**工具比官方严 —— 同一个子会话里官方
-            // 工具能委派、我们的被自己拦下 —— 而用户真想禁止嵌套也禁止不了（官方工具照样能）。
+            // 的 `maxDepth` 只用**宿主配置**那一档（0.2.1 默认 1）、provider 只在**传了值**时才校验，
+            // 所以能不能继续委派问官方就行。那个检查的唯一净效果是让**我们的**工具比官方严 ——
+            // 同一个子会话里官方工具能委派、我们的被自己拦下 —— 而用户真想禁止嵌套也禁止不了
+            // （官方工具照样能）。
             // `catalogDepth` 现在只管"目录注入到哪些会话"，不参与委派可行性判断。
             // 按当前会话的 Agent 预设算工具限制：判断不了当前预设、或名单里的工具已经不存在时，
             // 结论里会带一句实话，跟着结果一起返回——不静默改变限制的强度。
@@ -149,14 +150,20 @@ export function defineSubagentManagerRunTool(subagents) {
             const prefix = r.stopReason && r.stopReason !== 'completed' ? `[stopReason: ${r.stopReason}]\n` : '';
             const note = decision && decision.note ? `⚠ ${decision.note}\n\n` : '';
             // 允许追问通道（人设 `continuable: true`）：产出是**异步**到达的，这里只拿到子会话 id。
-            // 回执必须把"id + 怎么追问 + 怎么中止"三件事写全 —— 少写一句，模型就会把"没拿到结果"
-            // 读成"委派失败"而重试一次（那会再起一个后台子代理，白白翻倍）。
+            // 回执必须把"id + 产出怎么回来 + 怎么追问 + 怎么中止"写全 —— 少写一句，模型就会把
+            // "没拿到结果"读成"委派失败"而重试一次（那会再起一个后台子代理，白白翻倍）。
+            // "产出怎么回来"说的是**宿主的结算通知**（0.2.1 核实 `dsh-subagent/lib/types/manager.js`
+            // 的 `notifySettlement` → `createSettlementMessage`）：子代理结束时父代理会收到一条
+            // `subagent-settled` 通知，含收尾一行说明 + 子代理最终的非空 text 块（+ 结构化结果与
+            // 诊断）。它自己发回来的 `send_message` 是**补充**（`withContinuableReturnGuidance`
+            // 要求它在收尾前把自包含结果发给父代理），不是产出的唯一来路 —— 回执不能只说前者，
+            // 否则子代理没主动发消息时父代理会把"还没收到结果"当成"还在跑"。
             if (r.continuable === true) {
-                return note + '已启动允许追问的子代理「' + name + '」（后台运行）\n'
+                return note + 'started the continuable subagent "' + name + '" (running in the background)\n'
                     + 'agent_id: ' + r.runId + '\n\n'
-                    + '它的产出稍后自己发到这里，届时你会收到一条通知。要追问就 '
-                    + 'send_message({ agent_id: "' + r.runId + '", message: "..." })，'
-                    + '要中止就 interrupt_agent({ agent_id: "' + r.runId + '" })。';
+                    + 'you will get a notification carrying its final output when it settles. To follow up: '
+                    + 'send_message({ agent_id: "' + r.runId + '", message: "..." }), '
+                    + 'To stop it: interrupt_agent({ agent_id: "' + r.runId + '" }).';
             }
             return note + prefix + r.text;
         },

package/lib/tools/deps.js

@@ -7,7 +7,7 @@ export function text(value) {
     return [{ type: 'text', text: value }];
 }
 /**
- * 名单渲染：超过 `TOOL_NAME_LIST_CAP` 项就截断，并把总数写在后面（"等 N 项"）。
+ * 名单渲染：超过 `TOOL_NAME_LIST_CAP` 项就截断，并把总数写在后面（"…(N total)"）。
  *
  * 为什么两个地方都要它：`scene_manager_list` 用它列档案，`scene_manager_save` 用它
  * 在回执里回显"这一次替换挤掉了什么"。两处都必须**点名、不能只给数量** —— 只给数量
@@ -17,9 +17,9 @@ export function text(value) {
 export const TOOL_NAME_LIST_CAP = 6;
 export function toolNameList(list) {
     if (!list.length)
-        return '空';
-    const head = list.slice(0, TOOL_NAME_LIST_CAP).join('、');
-    return list.length > TOOL_NAME_LIST_CAP ? head + ' 等 ' + list.length + ' 项' : head;
+        return 'none';
+    const head = list.slice(0, TOOL_NAME_LIST_CAP).join(', ');
+    return list.length > TOOL_NAME_LIST_CAP ? head + ' ...(' + list.length + ' total)' : head;
 }
 /**
  * 按名字找技能落在哪个来源（root）。

package/lib/tools/mcp.js

@@ -28,7 +28,7 @@
 import { DEFAULT_MCP_NOTE_MAX_LENGTH, normalizeMcpNote } from '../mcp/state-section.js';
 import { text } from './deps.js';
 /** 「去看清单」那句：`mcp_manager_list` 不在模型手里时不能点名它（调用方按 `toolVisibleFor` 决定给不给）。 */
-const MCP_LIST_HINT = '（用 mcp_manager_list 看清单，all=true 连停用的也列）';
+const MCP_LIST_HINT = ' (see mcp_manager_list — all=true also lists disabled ones)';
 /**
  * 指不到 `mcp_manager_list` 时的**中性出口**：不点名任何工具，两条常驻来源都成立
  * —— 模型自己的 `mcp__<server>__<tool>` 工具名（就在它的 schema 里），以及注入段。
@@ -37,22 +37,22 @@ const MCP_LIST_HINT = '（用 mcp_manager_list 看清单，all=true 连停用的
  * 的 MCP 工具，猜错 serverName 时若报错里只有「没有这台服务器：X」，模型拿不到任何补救线索
  * —— 它只能猜第二次。出口要么指向工具（那条工具得在它手里），要么指向这两条常驻来源。
  */
-const MCP_NEUTRAL_HINT = '（服务器名照抄你自己 `mcp__<server>__<tool>` 工具名里的那一段，或「当前 MCP 服务器」段里列出的名字）';
+const MCP_NEUTRAL_HINT = ' (copy the server name from your own `mcp__<server>__<tool>` tool names, or take one listed in the "Current MCP servers" reminder)';
 /** 按 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 || MCP_NEUTRAL_HINT));
+        throw new Error('no such server: ' + server + (listHint || MCP_NEUTRAL_HINT));
     }
     if (level) {
         const picked = hits.filter((r) => r.level === level);
         if (!picked.length) {
-            throw new Error('「' + server + '」没有 level=' + level + ' 的那一台（现有：' + hits.map((r) => r.level).join(' / ') + '）');
+            throw new Error('"' + server + '" has no level=' + level + ' entry (existing: ' + hits.map((r) => r.level).join(' / ') + ')');
         }
         return picked[0];
     }
     if (hits.length > 1) {
-        throw new Error('「' + server + '」在 ' + hits.map((r) => r.level).join(' 与 ') + ' 各有一台，无法确定动哪一台 —— 传 level 指定');
+        throw new Error('"' + server + '" exists at both ' + hits.map((r) => r.level).join(' and ') + ' — pass level to say which one to touch');
     }
     return hits[0];
 }
@@ -89,11 +89,11 @@ export function buildMcpTools(deps) {
         // 是行动依据 —— 模型要知道"停用的那台去哪查"就得靠这句（all=true）。
         //
         // 2026-10-15 注入文本审查：删掉两处白付的 token ——
-        //   ① 括号里那句把「当前 MCP 服务器」reminder 的**内容**逐项列了一遍（可用 / 曾连上 /
+        //   ① 括号里那句把 "Current MCP servers" 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.',
+        description: 'List configured MCP servers (level project|global; enabled state; live loader status; tool count excluding switched-off tools; user hint). The "Current MCP servers" 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).' },
@@ -162,7 +162,7 @@ export function buildMcpTools(deps) {
             // 报错退化成「没有这台服务器：<你猜的>」—— 一个字都不告诉它还能去哪看。
             // 指向模型自己的工具表（`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).' },
+            server: { type: 'string', required: true, description: 'Server name, as it appears in your own `mcp__<server>__<tool>` tool names (the "Current MCP servers" 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.' },
@@ -171,12 +171,12 @@ export function buildMcpTools(deps) {
         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 || '(空)') + '）');
+                throw new Error('action must be on / off / restart (got: ' + (action || '(empty)') + ')');
             }
             const server = String((args && args.server) || '').trim();
             const tool = args && args.tool !== undefined ? String(args.tool).trim() : '';
             if (tool !== '' && action === 'restart') {
-                throw new Error('重启是整台服务器的动作（先停用、等断开、再按原状态启用），不能只重启一个工具');
+                throw new Error('restart is a whole-server action (off, wait for it to drop, then back on at its previous state); a single tool cannot be restarted');
             }
             // on|off 会写补丁（`mcpm-set-enabled` / `mcpm-tool-enabled` 在登记表里是 frozen），
             // 所以过场景冻结守卫；restart 不过 —— 它是锁定期间唯一的恢复入口（见文件头）。
@@ -187,36 +187,36 @@ export function buildMcpTools(deps) {
             }
             const list = await deps.mcpmListView();
             if (!list || list.ok === false)
-                throw new Error((list && list.error) || '读取 MCP 配置失败');
+                throw new Error((list && list.error) || 'failed to read the MCP config');
             const level = args && args.level !== undefined ? String(args.level) : undefined;
             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 });
                 if (!r || r.ok === false)
-                    throw new Error((r && r.error) || '切换工具启停失败');
+                    throw new Error((r && r.error) || 'failed to switch this tool');
                 // 与面板同一条同步：`mcpm-tool-enabled` 在登记表里带 syncsArchive，漏了就是
                 // "页面拨的进档案、模型拨的不进"。
                 const syncErr = await deps.syncSwitchToScene('mcpm-tool-enabled', { serverName: String(row.serverName), tool, enabled });
                 // 整台停用时，工具级开关在运行时本来就不生效（那个工具压根不存在）—— 不说的话
                 // 模型会以为已经生效。与记忆族"启用了一条不在启用场景里的记忆"同一条理由。
-                const offNote = row.disabled ? '（注意：整台服务器当前是停用的，这个工具级开关要等它启用才生效）' : '';
+                const offNote = row.disabled ? ' (note: the whole server is off right now, so this tool-level switch only takes effect once the server is on)' : '';
                 return 'OK: ' + String(row.serverName) + ' tool ' + tool + ' now ' + (enabled ? 'enabled' : 'disabled') + offNote +
-                    (syncErr ? '\nWARN: 当前场景档案未同步（' + syncErr + '）' : '');
+                    (syncErr ? '\nWARN: the current scene archive was not synced (' + syncErr + ')' : '');
             }
             if (action === 'restart') {
                 const r = await deps.mcpmRestart({ id: row.id, level: row.level });
                 if (!r || r.ok === false)
-                    throw new Error((r && r.error) || '重启失败');
+                    throw new Error((r && r.error) || 'restart failed');
                 return 'OK: ' + String(row.serverName) + ' (' + row.level + ') restarted';
             }
             const r = await deps.mcpmSetEnabled({ id: row.id, level: row.level, enabled });
             if (!r || r.ok === false)
-                throw new Error((r && r.error) || '切换服务器启停失败');
+                throw new Error((r && r.error) || 'failed to switch this server');
             // 场景未锁定时，页面 / 模型改的开关都要落进当前场景的档案（与 handlers 层同一套同步）。
             const syncErr = await deps.syncSwitchToScene('mcpm-set-enabled', { id: row.id, level: row.level, enabled });
             return 'OK: ' + String(row.serverName) + ' (' + row.level + ') now ' + (enabled ? 'enabled' : 'disabled') +
-                (syncErr ? '\nWARN: 当前场景档案未同步（' + syncErr + '）' : '');
+                (syncErr ? '\nWARN: the current scene archive was not synced (' + syncErr + ')' : '');
         },
     }));
     register(defineTool({
@@ -232,7 +232,7 @@ export function buildMcpTools(deps) {
             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.' },
             // 名字与注入段对齐（2026-10-14 对抗性审查 P1-2）：注入段与工具输出都写 `user-hint`
-            // （对应中文那句「用户提示：」），参数名跟着叫 `hint`，一份数据三个面一个词。
+            // （对应注入行里那句 `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." },
@@ -244,7 +244,7 @@ export function buildMcpTools(deps) {
                 throw new Error(blocked);
             const server = String((args && args.server) || '').trim();
             if (!server)
-                throw new Error('缺少参数：server（服务器名）');
+                throw new Error('missing argument: server (the server name)');
             const levelArg = args && args.level !== undefined ? String(args.level) : undefined;
             // `hint` 的三态（2026-10-15 修 P1-5）：省略 = 保持；`''` = **清空**；非空 = 设置。
             // 此前用 `hintText.trim() !== ''` 判"要不要写备注"，把"清空"与"省略"混成一件事 ——
@@ -255,20 +255,20 @@ export function buildMcpTools(deps) {
             const clearsNote = hintGiven && hintText.trim() === '';
             const list = await deps.mcpmListView();
             if (!list || list.ok === false)
-                throw new Error((list && list.error) || '读取 MCP 配置失败');
+                throw new Error((list && list.error) || 'failed to read the MCP config');
             const rows = list.rows || [];
             const hits = rows.filter((r) => String(r.serverName) === server);
             // ── 建：transport 与它那一侧的必填项都得给 ─────────────────────────────
             if (!hits.length) {
                 const transport = String((args && args.transport) || '').trim();
                 if (transport !== 'stdio' && transport !== 'streamable-http') {
-                    throw new Error('新建服务器必须给 transport：stdio 或 streamable-http');
+                    throw new Error('creating a server needs transport: stdio or streamable-http');
                 }
                 if (transport === 'stdio' && String((args && args.command) || '').trim() === '') {
-                    throw new Error('新建 stdio 服务器必须给 command（宿主会按它 spawn 进程）');
+                    throw new Error('a new stdio server needs command (the host spawns that process)');
                 }
                 if (transport === 'streamable-http' && String((args && args.url) || '').trim() === '') {
-                    throw new Error('新建 streamable-http 服务器必须给 url');
+                    throw new Error('a new streamable-http server needs url');
                 }
                 const payload = {
                     serverName: server,
@@ -283,14 +283,14 @@ export function buildMcpTools(deps) {
                     payload.level = levelArg;
                 const r = await deps.mcpmAdd(payload);
                 if (!r || r.ok === false)
-                    throw new Error((r && r.error) || '新增服务器失败');
+                    throw new Error((r && r.error) || 'failed to add the server');
                 // 备注单独走 `mcpm-note`（`mcpm-add` 不认这个字段）。失败**不回滚**主写入：
                 // 服务器已经建好了，"备注没写上"是 warning，不是失败（与 0.13.0 界面同规格）。
                 let warn = '';
                 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) || '未知原因') + '）';
+                        warn = '\nWARN: the server was created, but the hint was not written (' + ((n && n.error) || 'unknown reason') + ')';
                 }
                 return 'OK: created ' + r.row.id + ' at ' + r.row.level + warn;
             }
@@ -298,7 +298,7 @@ export function buildMcpTools(deps) {
             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) + '）');
+                throw new Error('transport must be stdio or streamable-http (this one is: ' + String(cur.transport) + ')');
             }
             const touched = [];
             const ignored = [];
@@ -365,15 +365,15 @@ export function buildMcpTools(deps) {
             // 直接写备注。这与"三个可改字段一个都没给就拒"是同一条理由的两面。
             if (!touched.length && !levelChanged) {
                 if (!hintGiven)
-                    throw new Error('没有要改的东西：transport / url / command / args / headers / env / level / hint 至少给一个');
+                    throw new Error('nothing to change: give at least one of 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) + '（' + (clearsNote ? 'hint 已清空' : '改了 hint') + '）';
+                    throw new Error((n && n.error) || 'failed to write the hint');
+                return 'OK: updated ' + String(cur.serverName) + ' (' + (clearsNote ? 'hint cleared' : 'hint changed') + ')';
             }
             const r = await deps.mcpmEdit(payload);
             if (!r || r.ok === false)
-                throw new Error((r && r.error) || '修改服务器失败');
+                throw new Error((r && r.error) || 'failed to update the server');
             // `hint` 进 `changed` 必须**等写成功之后**（2026-10-15 修 P1-6）：此前按意图先算进去，
             // mcpmNote 失败时回执一边说"改了 hint"、一边 WARN"备注没写进去"，模型读不出到底改没改。
             const changed = touched.concat(levelChanged ? ['level'] : []);
@@ -385,14 +385,14 @@ export function buildMcpTools(deps) {
             if (hintGiven) {
                 const n = await deps.mcpmNote({ id: cur.id, note: hintText });
                 if (!n || n.ok === false)
-                    warn += '\nWARN: 服务器已保存，但备注没写进去（' + ((n && n.error) || '未知原因') + '）';
+                    warn += '\nWARN: the server was saved, but the hint was not written (' + ((n && n.error) || 'unknown reason') + ')';
                 else
-                    changed.push(clearsNote ? 'hint（已清空）' : 'hint');
+                    changed.push(clearsNote ? 'hint (cleared)' : 'hint');
             }
             if (ignored.length) {
-                warn += '\nWARN: ' + ignored.join(' / ') + ' 与当前 transport（' + transport + '）无关，已忽略';
+                warn += '\nWARN: ' + ignored.join(' / ') + ' do not apply to the current transport (' + transport + ') and were ignored';
             }
-            return 'OK: updated ' + String(cur.serverName) + '（改了 ' + changed.join('、') + '）' + warn;
+            return 'OK: updated ' + String(cur.serverName) + ' (changed ' + changed.join(', ') + ')' + warn;
         },
     }));
 }

package/lib/tools/memory.js

@@ -26,7 +26,7 @@ export function buildMemoryTools(deps) {
         name: 'memory_manager_list',
         // 末尾**不点名** `scene_manager_list`：场景一族在出厂默认里就是关着的，指向一条模型没有的
         // 工具只会让它去猜名字（用户 2026-09-23 把默认名单扩到十五条时去掉的这句）。
-        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.',
+        description: 'List memories (id, scene, enabled, form flat|bundle, description) plus the scene injection currently follows. What is injected each turn is in the "Current memories" reminder; use this for ids and for entries that are off. Pass a `scene` to filter by scene; all=true lists everything.',
         parameters: {
             // 参数名与其余五个域同词（2026-10-14 对抗性审查 P1-3）：同一个概念在工具面只该有一个名字，
             // 而 `scene` 是它在 `scene_manager_*`、`<scene>/<name>` 与注入段标题里的叫法。
@@ -44,7 +44,7 @@ export function buildMemoryTools(deps) {
                 opArgs.group = args.scene;
             const r = await deps.rulesOps['rules-list'](opArgs);
             if (!r || r.ok === false)
-                throw new Error((r && r.error) || '读取规则失败');
+                throw new Error((r && r.error) || 'failed to read memories');
             // 「会注入」的判定与记忆段同源（renderSceneMemory）：global 场景恒常注入，其余场景要
             // 在 index.active 里，再叠加单条 enabled 与同名 bundle 的 shadowed。默认只列这些，
             // 全列一次会把没启用的条目也算进上下文（用户裁定 2026-09-16，与技能列表同口径）。
@@ -52,37 +52,37 @@ export function buildMemoryTools(deps) {
                 (group !== '' && (r.activeMode === 'all' || String(r.activeScene || '') === group));
             const stateOf = (x) => {
                 if (x.shadowed === true)
-                    return { injects: false, label: '被同名覆盖' };
+                    return { injects: false, label: 'shadowed' };
                 if (x.enabled === false)
-                    return { injects: false, label: '已停用' };
+                    return { injects: false, label: 'disabled' };
                 if (!sceneOn(String(x.group || '')))
-                    return { injects: false, label: '场景未启用' };
-                return { injects: true, label: '已启用' };
+                    return { injects: false, label: 'scene off' };
+                return { injects: true, label: 'injects' };
             };
             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 +
+            const lines = shown.map(({ x, label }) => ('- ' + x.id + ' [' + (x.group || 'no scene') + '] ' + label +
                 // 形态与附件（2026-10-15）：此前不报，模型分不清哪条是 bundle、更不知道它带了几个附件
                 // （`rules-list` 早就把 `form` 与 bundle 的附件摘要给了出来，只是这里没渲染）。
                 (x.form === 'bundle'
-                    ? ' · bundle' + (x.attach && x.attach.count ? '（' + x.attach.count + ' 个附件）' : '')
+                    ? ' · bundle' + (x.attach && x.attach.count ? ' (' + x.attach.count + ' attachment(s))' : '')
                     : '') +
                 (x.description ? ' — ' + x.description : '')));
             // 注入按哪个场景走 —— 上面那句「场景未启用」只有配上它才可解读：少了这一行，
             // 模型看到一片"未启用"会以为是条目自己的问题。（场景本身的清单在 `scene_manager_list`，
             // 2026-09-23 拆过去了；这里只留"记忆按哪一集注入"，因为那是记忆域自己的现状。）
             const scope = r.activeMode === 'all'
-                ? '全部场景（历史默认，未收窄）'
-                : (r.activeScene ? '「' + String(r.activeScene) + '」' : '未启用任何场景');
-            const header = '记忆：' + (showAll
-                ? rows.length + ' 条'
-                : shown.length + ' 条会注入 / 共 ' + rows.length + ' 条' +
-                    (shown.length === rows.length ? '' : '（传 all=true 看全部）')) +
-                '\n注入范围：' + scope + ' + global（global 恒常注入）\n';
+                ? 'every scene (historical default, not narrowed)'
+                : (r.activeScene ? '"' + String(r.activeScene) + '"' : 'no scene is on');
+            const header = 'memories: ' + (showAll
+                ? rows.length + ' total'
+                : shown.length + ' injecting / ' + rows.length + ' total' +
+                    (shown.length === rows.length ? '' : ' (pass all=true for all)')) +
+                '\ninjects from: ' + scope + ' + global (global always injects)\n';
             // 注入边界：压制型预设（persona complete / 关闭运行时上下文）下本插件默认不注入，
             // 此时列出的记忆**不在**模型上下文里。必须说出来，否则模型会假设自己已经看到正文。
             const notice = await deps.reachNoticeForAgent(deps.presetRoster(), exec && exec.agent && exec.agent.ctx, deps.injectNoticeOptions());
-            return header + (lines.join('\n') || '(无记忆)') + notice;
+            return header + (lines.join('\n') || '(none)') + notice;
         },
     }));
     register(defineTool({
@@ -99,7 +99,7 @@ export function buildMemoryTools(deps) {
             // op 的字段名是 `id`，不改 op：这里显式转换（键名对模型是 `<场景>/<名字>`，对 op 是 `id`）。
             const r = await deps.rulesOps['rules-read']({ id: String((args && args.memory) || '') });
             if (!r || r.ok === false)
-                throw new Error((r && r.error) || '读取规则失败');
+                throw new Error((r && r.error) || 'failed to read memories');
             const rule = r.rule || {};
             // 形态与附件名（2026-10-15）：op 一直把 `attachments` 给了出来，这里此前**整个丢掉**，
             // 于是模型连"这条记忆是 bundle、带了 3 个附件"都看不到。只给名字不给内容 ——
@@ -107,9 +107,9 @@ export function buildMemoryTools(deps) {
             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('、')
+                ? '\nattachments (' + attach.length + '): ' + attach.map((a) => String((a && a.name) || a)).join(', ')
                 : '';
-            return '# ' + rule.id + '（' + form + '）' + attLine + '\n\n' + (rule.body || '');
+            return '# ' + rule.id + ' (' + form + ')' + attLine + '\n\n' + (rule.body || '');
         },
     }));
     register(defineTool({
@@ -143,10 +143,10 @@ export function buildMemoryTools(deps) {
             // `enabled` 必须是布尔：`rules-toggle` 缺了它直接拒（ops/memory.ts），但那是给用户看的
             // 中文 op 错；这里先挡一句说清"这条工具要什么"。
             if (typeof (args && args.enabled) !== 'boolean')
-                throw new Error('缺少参数：enabled 必须是 true 或 false');
+                throw new Error('missing argument: enabled must be true or false');
             const r = await deps.rulesOps['rules-toggle']({ id: memory, enabled: args.enabled });
             if (!r || r.ok === false)
-                throw new Error((r && r.error) || '切换记忆启停失败');
+                throw new Error((r && r.error) || 'failed to switch this memory');
             const rule = r.rule || {};
             // 「启用了一条不在启用场景里的记忆」是一次静默无效：单条开关拨上去了，注入集里却没有它。
             // 这一句不说，模型会以为已经生效 —— 与 skill_manager_switch 说清影子副本同一条理由。
@@ -157,7 +157,7 @@ export function buildMemoryTools(deps) {
                     const group = String(rule.group || '');
                     const on = group === 'global' || (group !== '' && (all.activeMode === 'all' || String(all.activeScene || '') === group));
                     if (!on)
-                        sceneNote = ' — BUT its scene「' + group + '」is not the active one, so it still will not be injected; enable that scene (or move it to global) first';
+                        sceneNote = ' — BUT its scene "' + group + '" is not the one injecting, so it still will not be injected; turn that scene on (or move it to global) first';
                 }
             }
             catch {
@@ -193,7 +193,7 @@ export function buildMemoryTools(deps) {
             // 清单里打印的就是 `<场景>/<名字>`，照抄比拼装准（§2 规则一）。
             const slash = memory.indexOf('/');
             if (slash <= 0 || slash === memory.length - 1) {
-                throw new Error('memory 必须是 <场景>/<名字> 两段（照抄清单里那一行；全局场景写 global/<名字>）：' + (memory || '(空)'));
+                throw new Error('memory must be <scene>/<name> (copy that from the listing; the always-on scene is written global/<name>): ' + (memory || '(empty)'));
             }
             const group = memory.slice(0, slash);
             const name = memory.slice(slash + 1);
@@ -201,7 +201,7 @@ export function buildMemoryTools(deps) {
             // 这一侧 —— `rules-create` 对同名是**拒绝**的（`error.rules.exists`），op 不会 upsert。
             const all = await deps.rulesOps['rules-list']({});
             if (!all || all.ok === false)
-                throw new Error((all && all.error) || '读取规则失败');
+                throw new Error((all && all.error) || 'failed to read memories');
             const hit = (all.rules || []).find((x) => String(x.id) === memory);
             if (hit) {
                 // 改的分支一律 read-modify-write（省略 = 保持），因为 `rules-update` 是整份重写。
@@ -209,7 +209,7 @@ export function buildMemoryTools(deps) {
                 // 模型以为改了点什么，其实只是把文件重写了一遍。
                 const touched = ['body', 'description', 'nextName'].filter((k) => args[k] !== undefined);
                 if (!touched.length)
-                    throw new Error('没有要改的东西：body / description / nextName 至少给一个');
+                    throw new Error('nothing to change: give at least one of body / description / nextName');
                 const payload = { id: memory };
                 // 只带模型真给过的键：`description` 传空串在 op 里是"删除并重新派生"，与"未给"是两种
                 // 意图，都必须原样透传 —— 所以用 `!== undefined` 而不是真值判断。
@@ -221,10 +221,10 @@ export function buildMemoryTools(deps) {
                     payload.name = args.nextName;
                 const r = await deps.rulesOps['rules-update'](payload);
                 if (!r || r.ok === false)
-                    throw new Error((r && r.error) || '更新记忆失败');
+                    throw new Error((r && r.error) || 'failed to update the memory');
                 const rule = r.rule || {};
-                return 'OK: updated ' + String(rule.id || memory) + '（改了 ' + touched.join('、') + '）' +
-                    (rule.id && String(rule.id) !== memory ? ' → 现在是 ' + rule.id : '');
+                return 'OK: updated ' + String(rule.id || memory) + ' (changed ' + touched.join(', ') + ')' +
+                    (rule.id && String(rule.id) !== memory ? ' → now ' + rule.id : '');
             }
             // 建的分支：正文与描述都必填。`rules-create` 自己会拒空正文与非法名（ops/memory.ts），
             // 但那是给用户看的中文 op 错；模型需要的是"这条工具要什么"，所以在工具侧先挡、点名缺哪个。
@@ -235,7 +235,7 @@ export function buildMemoryTools(deps) {
                 description.trim() === '' ? 'description' : '',
             ].filter((x) => x !== '');
             if (missing.length)
-                throw new Error('新建记忆必须给 ' + missing.join(' 与 ') + '（' + memory + ' 还不存在）');
+                throw new Error('creating a memory needs ' + missing.join(' and ') + ' (' + memory + ' does not exist yet)');
             // 查重只**说出来**，不拒绝 —— 猜错一次就把该记的东西记不下去，比多记一条代价大得多；
             // 而且"像不像同一条"本来就是人判断的事。只在建的分支提示：改的分支没有"再记一条"的风险。
             const norm = (value) => String(value ?? '').toLowerCase().replace(/\s+/g, ' ').trim();
@@ -256,11 +256,11 @@ export function buildMemoryTools(deps) {
                 .slice(0, 3);
             const r = await deps.rulesOps['rules-create']({ group, name, description, body });
             if (!r || r.ok === false)
-                throw new Error((r && r.error) || '创建规则失败');
+                throw new Error((r && r.error) || 'failed to create the memory');
             // 刚建好的这条自己会在列表里，从名单里去掉。
             const dup = similar.filter((id) => id !== String(r.rule.id));
             const warn = dup.length
-                ? `\n注意：已有 ${dup.length} 条名字或描述与它很像（${dup.join('、')}）—— 若是同一件事，改那一条而不是留着两条。`
+                ? `\nnote: ${dup.length} existing memories have a similar name or description (${dup.join(', ')}) — if it is the same thing, update that one instead of keeping two.`
                 : '';
             // 回执必须同时说清**两个**条件（2026-10-15 smoke-test P1-3）：新建的记忆在 op 层是
             // `enabled: false`（ops/memory.ts 的 rulesCreate），而原先这句只提场景 —— 读起来像
@@ -268,10 +268,10 @@ export function buildMemoryTools(deps) {
             // 的 enableHint 同一形状：点名的工具在出厂默认名单里是关着的，关着就改说"用户开启后"。
             const sceneActive = group === 'global' ||
                 (group !== '' && (all.activeMode === 'all' || String(all.activeScene || '') === group));
-            const sceneTail = sceneActive ? '' : '，并启用场景「' + group + '」';
+            const sceneTail = sceneActive ? '' : ', and turn scene "' + group + '" on';
             const enableHint = deps.toolVisible('memory_manager_switch')
-                ? '（新建默认停用，要生效先 memory_manager_switch 开它' + sceneTail + '）'
-                : '（新建默认停用，用户开启后才能生效' + sceneTail + '）';
+                ? ' (created disabled — turn it on first with memory_manager_switch' + sceneTail + ')'
+                : ' (created disabled — the user has to turn it on first' + sceneTail + ')';
             return 'OK: created ' + r.rule.id + enableHint + warn;
         },
     }));