dsh-plugin-tool-management 0.20.3 → 0.21.0

package/lib/tools/scene.js

@@ -60,7 +60,7 @@ function toolTableLabel(name) {
     const v = typeof name === 'string' ? name.trim() : '';
     if (!v)
         return '';
-    return v === FACTORY_TOOL_TABLE_PRESET ? '出厂默认' : v;
+    return v === FACTORY_TOOL_TABLE_PRESET ? 'factory default' : v;
 }
 /**
  * 一个档案的名单渲染（`_list` 用）。**点名而不是只给数量**：模型要判断"这个场景进入时会不会
@@ -68,23 +68,23 @@ function toolTableLabel(name) {
  */
 function archiveText(archive) {
     if (!archive || typeof archive !== 'object')
-        return '未建（进入时 MCP / 技能 / 人设 三个域全部停用）';
+        return 'not created (entering turns off all MCP / skill / persona domains)';
     const keys = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? Object.keys(v) : []);
     const list = (v) => (Array.isArray(v) ? v.map((x) => String(x)) : []);
     const parts = [
         'MCP ' + toolNameList(keys(archive.mcp)),
-        '技能 ' + toolNameList(list(archive.skills)),
-        '人设 ' + toolNameList(list(archive.subagents)),
+        'skills ' + toolNameList(list(archive.skills)),
+        'personas ' + toolNameList(list(archive.subagents)),
     ];
     const notes = keys(archive.mcpNotes);
     if (notes.length)
-        parts.push('备注 ' + toolNameList(notes));
+        parts.push('notes ' + toolNameList(notes));
     // 模型工具表方案（0.15.0 起档案里有这一栏）：进入时换的是**模型自己能用什么**，不报就是
     // 让它事后发现自己少了工具却说不出原因。只给方案名 —— 关停名单不在档案里，硬算要多读一次
     // 方案清单，而真正需要条数的时机是切换之后（那条回执有）。没绑就不冒这一格（与备注同口径）。
     const tt = toolTableLabel(archive.toolTablePreset);
     if (tt)
-        parts.push('工具表方案「' + tt + '」');
+        parts.push('tool-table preset "' + tt + '"');
     // 快捷提示词绑定（0.20.0）：进了这个场景会动到 `/` 菜单里哪些条目，不报就只能靠猜。
     // 空表是"进入后全部停用"，与"没绑"（这一域不碰）是两句相反的话，不能压成一个 "0 条"。
     //
@@ -94,7 +94,7 @@ function archiveText(archive) {
     // 与 `skills` / `subagents` 两段同款（那两段本来就是 `toolNameList` 印名字）。
     const qp = archive.quickPrompts;
     if (Array.isArray(qp))
-        parts.push(qp.length ? '快捷提示词 ' + toolNameList(qp) : '快捷提示词：进入后全部停用');
+        parts.push(qp.length ? 'quick prompts ' + toolNameList(qp) : 'quick prompts: all off after entering');
     return parts.join(' ｜ ');
 }
 /**
@@ -115,9 +115,9 @@ function segmentDiff(key, beforeValue, afterValue) {
     if (dropped.length)
         marks.push('-' + toolNameList(dropped));
     if (!marks.length && JSON.stringify(beforeValue ?? null) !== JSON.stringify(afterValue ?? null))
-        marks.push('勾选范围有调整');
+        marks.push('the checked set changed');
     return {
-        text: key + ' ' + b.length + ' 项 → ' + a.length + ' 项' + (marks.length ? '（' + marks.join(' ') + '）' : ''),
+        text: key + ' ' + b.length + ' -> ' + a.length + ' items' + (marks.length ? ' (' + marks.join(' ') + ')' : ''),
         dropped,
     };
 }
@@ -133,11 +133,11 @@ function agentsMdNote(sync) {
     if (!sync || typeof sync !== 'object')
         return '';
     if (sync.error)
-        return '\nWARN: 全局基线（AGENTS.md）未同步：' + String(sync.error);
+        return '\nWARN: the global baseline (AGENTS.md) was not synced: ' + String(sync.error);
     if (sync.applied)
-        return '\nAGENTS.md ← 场景绑定的预设「' + String(sync.applied) + '」';
+        return '\nAGENTS.md <- the scene-bound preset "' + String(sync.applied) + '"';
     if (sync.restored === true)
-        return '\nAGENTS.md ← 已恢复进场景前的基线';
+        return '\nAGENTS.md <- restored the pre-scene baseline';
     return '';
 }
 export function buildSceneTools(deps) {
@@ -148,15 +148,15 @@ export function buildSceneTools(deps) {
         // 这种筛选（未启用的场景照样要能被进入，藏着只会让模型以为它不存在）。
         // 描述与参数说明里**不点名同族工具**（scene_manager_list / _switch / _save 三条都在出厂
         // 默认的隐藏名单里）：静态文本没法按 toolVisible 改写，点名一条模型没有的工具只会让它
-        // 白跑一趟。要说"去哪看"就用中性说法（the scene listing / the「当前场景」reminder
+        // 白跑一趟。要说"去哪看"就用中性说法（the scene listing / the "Current scene" reminder
         // —— 后者是常驻源，只要场景域开着就在）。点名只留在**运行时回执**里、按可见性分叉。
-        description: 'List every scene with its archive (what entering it switches on: MCP servers, skills, personas, quick prompts, and the bound model tool-table scheme when there is one), bound prompt preset, memory count and enabled / entered / locked state. The scene currently entered is also shown in the「当前场景」reminder.',
+        description: 'List every scene with its archive (what entering it switches on: MCP servers, skills, personas, quick prompts, and the bound model tool-table scheme when there is one), bound prompt preset, memory count and enabled / entered / locked state. The scene currently entered is also shown in the "Current scene" reminder.',
         parameters: {},
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
         async execute() {
             const r = await deps.rulesOps['rules-list']({});
             if (!r || r.ok === false)
-                throw new Error((r && r.error) || '读取场景失败');
+                throw new Error((r && r.error) || 'failed to read scenes');
             // 档案与「已进入哪个场景」要额外读一次（纯读盘，`scene-mode-get`）。
             // 读不到**不阻断**清单：场景行退化成只有名字与启用状态，而不是让整条工具失败 ——
             // 一份少了档案的清单仍然有用，一次失败什么都没有。
@@ -180,28 +180,28 @@ export function buildSceneTools(deps) {
             const scenes = r.scenes || [];
             const lines = scenes.map((s) => {
                 const name = String(s.name);
-                const state = [s.active === true ? '启用' : '未启用'];
+                const state = [s.active === true ? 'on' : 'off'];
                 // 「启用」与「进入」是两个独立状态轴（见 README「进/出模式」），只报前者的话，
                 // 模型会把"启用着"读成"现在就是它" —— 而记忆与提示词只按**进入**的那一个注入。
                 if (entered !== null && name === entered)
-                    state.push('已进入');
+                    state.push('entered');
                 if (s.locked === true)
-                    state.push('已锁定');
+                    state.push('locked');
                 // 打**场景名**而不是 label：`scene_manager_save` / `_switch` 要的都是名字（单个
                 // 路径段），label 只是界面显示名。两者不同时把 label 放进括号，别让模型照抄错那个。
-                const title = name + (s.label && String(s.label) !== name ? '（' + String(s.label) + '）' : '');
-                const bits = ['- ' + title + ' [' + state.join('·') + '] · 记忆 ' + Number(s.count || 0) + ' 条'];
+                const title = name + (s.label && String(s.label) !== name ? ' (' + String(s.label) + ')' : '');
+                const bits = ['- ' + title + ' [' + state.join(', ') + '] · memories: ' + Number(s.count || 0)];
                 if (s.description)
-                    bits.push('说明：' + String(s.description));
+                    bits.push('description: ' + String(s.description));
                 if (s.prompt)
-                    bits.push('预设：' + String(s.prompt));
-                bits.push('档案：' + (archives === null ? '读不到（不代表没建）' : archiveText(archives[name])));
+                    bits.push('preset: ' + String(s.prompt));
+                bits.push('archive: ' + (archives === null ? 'unreadable (does not mean absent)' : archiveText(archives[name])));
                 return bits.join(' · ');
             });
-            return '场景（' + scenes.length + ' 个 · ' +
-                (r.activeMode === 'all' ? '启用集为历史默认（全部启用）' : '启用集已收窄为单选') +
-                (entered === null ? '；当前没有进入任何场景' : '；当前已进入「' + entered + '」') + '）：\n' +
-                (lines.join('\n') || '(无场景)');
+            return 'scenes (' + scenes.length + ' · ' +
+                (r.activeMode === 'all' ? 'the enabled set is the historical default (all enabled)' : 'the enabled set is narrowed to a single scene') +
+                (entered === null ? '; no scene is entered right now' : '; currently entered: "' + entered + '"') + '):\n' +
+                (lines.join('\n') || '(no scenes)');
         },
     }));
     register(defineTool({
@@ -212,13 +212,13 @@ export function buildSceneTools(deps) {
         description: 'Enter a scene, or leave the one currently entered. Entering switches on its archive and everything else off, narrows injection to its memories, and applies its bound prompt preset to AGENTS.md. Leaving restores the runtime snapshot taken on entry. Only when the user asks or approves.',
         parameters: {
             action: { type: 'string', required: true, enum: ['enter', 'exit'], description: 'enter = switch to the scene named in `scene`; exit = leave the current one (no scene needed).' },
-            scene: { type: 'string', description: 'Scene name (one path segment), required for enter. Use the exact name, not the display label — the scene listing and the「当前场景」reminder both print names.' },
+            scene: { type: 'string', description: 'Scene name (one path segment), required for enter. Use the exact name, not the display label — the scene listing and the "Current scene" reminder both print names.' },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
         async execute(args) {
             const action = String((args && args.action) || '');
             if (action !== 'enter' && action !== 'exit') {
-                throw new Error('action 只能是 enter / exit（收到：' + (action || '(空)') + '）');
+                throw new Error('action must be enter / exit (got: ' + (action || '(empty)') + ')');
             }
             // 刻意**不过** `lockedSceneGuard()`：场景**自身**的启停不在冻结清单里（冻结的是五个
             // 域的内容）。锁定中的场景正被进入时不能退出 —— 那条守卫在 `scene-mode-set` 的包装里
@@ -227,10 +227,10 @@ export function buildSceneTools(deps) {
             if (action === 'enter') {
                 scene = String((args && args.scene) || '').trim();
                 if (scene === '')
-                    throw new Error('action=enter 需要 scene：场景名（照抄 scene_manager_list 里那一行）');
+                    throw new Error('action=enter needs scene: the scene name (copy it from the scene_manager_list line)');
                 // 场景名是**单个路径段**（与 scene_manager_save 同一条校验、同一句报错）。
                 if (scene.indexOf('/') >= 0 || scene.indexOf('\\') >= 0) {
-                    throw new Error('场景名是单个路径段，不能含 / 或 \\：' + scene);
+                    throw new Error('a scene name is a single path segment (no / or \\): ' + scene);
                 }
             }
             // 先读一次"现在在哪个场景"：用来在回执里说清是"从 A 换到 B"还是"本来就在 B"。
@@ -247,14 +247,14 @@ export function buildSceneTools(deps) {
             // `rules-set-active` 写。少调后者，记忆与提示词仍按旧场景注入 —— 而运行时看起来已经切了。
             const mode = await deps.archiveOps['scene-mode-set']({ scene: action === 'enter' ? scene : null });
             if (!mode || mode.ok === false)
-                throw new Error((mode && mode.error) || (action === 'enter' ? '进入场景失败：' + scene : '退出场景失败'));
+                throw new Error((mode && mode.error) || (action === 'enter' ? 'failed to enter the scene: ' + scene : 'failed to exit the scene'));
             const act = await deps.sceneActivate({ scenes: action === 'enter' ? [scene] : [] });
             if (!act || act.ok === false) {
                 // 半成品状态：运行时已经切了，启用集合没跟上。**必须说出来** —— 不说的话模型以为
                 // 切完了，而记忆与提示词还是旧场景的。重试一次是安全的（两个 op 都幂等）。
-                throw new Error((action === 'enter' ? '场景「' + scene + '」的运行时已切换' : '运行时已退出场景') +
-                    '，但启用集合未写入（记忆与提示词仍按旧场景注入）：' + ((act && act.error) || '未知错误') +
-                    ' —— 重试一次 scene_manager_switch 即可（两个 op 都幂等）');
+                throw new Error((action === 'enter' ? 'runtime switched to scene "' + scene + '"' : 'runtime left the scene') +
+                    ', but the enabled set was not written (memories and prompts still inject per the old scene): ' + ((act && act.error) || 'unknown error') +
+                    ' — retry scene_manager_switch once (both ops are idempotent)');
             }
             // 回执：说清"从哪到哪 + 实际切了几台 / 几个来源 + 工具表换到哪一份 + 有没有键被丢弃 + AGENTS.md 那一步"。
             // 都是界面会如实报的同一批事实（`memory.result.modeSet` / `modeSwitched` / `archive.stale`），
@@ -268,10 +268,10 @@ export function buildSceneTools(deps) {
                 ? (mode.applied === null || mode.applied === undefined)
                 : !mode.restored;
             const head = noop
-                ? (action === 'enter' ? 'OK: already in scene「' + scene + '」' : 'OK: not in any scene (nothing to leave)')
+                ? (action === 'enter' ? 'OK: already in scene "' + scene + '"' : 'OK: not in any scene (nothing to leave)')
                 : action === 'enter'
-                    ? 'OK: ' + (before === null ? 'entered' : '「' + before + '」→') + ' scene「' + scene + '」'
-                    : 'OK: left the scene「' + (before || '') + '」';
+                    ? 'OK: ' + (before === null ? 'entered' : 'left "' + before + '", entered ') + 'scene "' + scene + '"'
+                    : 'OK: left the scene "' + (before || '') + '"';
             const parts = [];
             if (count(sw.mcpServers) || count(sw.skillSources)) {
                 parts.push('switched ' + count(sw.mcpServers) + ' MCP server(s) / ' + count(sw.skillSources) + ' skill source(s)');
@@ -280,16 +280,16 @@ export function buildSceneTools(deps) {
             // 原因，用户问"刚才改了什么"时拿回去的就是半截话。引擎只在**名单真的换了**时才回方案名。
             const tt = toolTableLabel(mode && mode.toolTablePreset);
             if (tt) {
-                parts.push('工具表切到方案「' + tt + '」（关 ' + count(sw.toolTableHidden) + ' 条）');
+                parts.push('tool table switched to preset "' + tt + '" (' + count(sw.toolTableHidden) + ' hidden)');
             }
             else if (action === 'exit' && mode.restored && mode.restored.toolTable === true) {
-                parts.push('工具表按进场景前的快照还原');
+                parts.push('tool table restored from the pre-scene snapshot');
             }
             if (Array.isArray(mode.stale) && mode.stale.length) {
-                parts.push('丢弃了本机不存在的键：' + mode.stale.join('、'));
+                parts.push('dropped keys this machine does not have: ' + mode.stale.join(', '));
             }
             return head + (parts.length ? ' · ' + parts.join(' · ') : '') + agentsMdNote(act.agentsMd) +
-                (noop ? '\n（' + (action === 'enter' ? '目标就是当前场景' : '本来就不在任何场景') + '，运行时没有改动）' : '');
+                (noop ? '\n(' + (action === 'enter' ? 'already in the target scene' : 'already outside every scene') + ' — runtime unchanged)' : '');
         },
     }));
     register(defineTool({
@@ -301,7 +301,7 @@ export function buildSceneTools(deps) {
         parameters: {
             scene: { type: 'string', required: true, description: 'Scene name (one path segment, ≤64 chars, no / \\ or < > : " | ? *, not `_shared`). Created if absent.' },
             label: { type: 'string', description: 'Display name for this scene. Omit = keep.' },
-            description: { type: 'string', description: 'What this scene is for; shown beside the scene name in the「当前场景」reminder while the scene is on — write an instruction, not a note. Omit = keep.' },
+            description: { type: 'string', description: 'What this scene is for; shown beside the scene name in the "Current scene" reminder while the scene is on — write an instruction, not a note. Omit = keep.' },
             // 与下面 `mcp` / `skills` / `subagents` 同一句式（"Omit = keep; X = 一个都不"）：
             // 界面 2026-10-10 补了「无」这个选项，工具侧的空串语义要跟着说清，否则模型只知道
             // 「省略 = 保持」，不知道还有一条「解绑」的路。
@@ -344,12 +344,12 @@ export function buildSceneTools(deps) {
                 throw new Error(blocked);
             const scene = String((args && args.scene) || '').trim();
             if (scene === '')
-                throw new Error('缺少参数：scene 是场景名');
+                throw new Error('missing argument: scene (the scene name)');
             // 场景名是**单个路径段**（界面把场景当一级列表展示，场景名就是 `memories/<场景>/` 那级
             // 目录名）。`rules-create-scene` 会做完整校验，但档案那条路不经过它 —— 这里先挡一次，
             // 报错也更贴模型要的东西（它要的是"这个名字不行"，不是内部规则）。
             if (scene.indexOf('/') >= 0 || scene.indexOf('\\') >= 0) {
-                throw new Error('场景名是单个路径段，不能含 / 或 \\：' + scene);
+                throw new Error('a scene name is a single path segment (no / or \\): ' + scene);
             }
             // ① 场景记录：`rules-create-scene` 本身是**幂等 upsert**（已存在则更新描述/标签/绑定的
             //    预设，不报错），所以不必先查再分建/改 —— 与记忆 save 的"有则改、无则建"同一口径。
@@ -371,7 +371,7 @@ export function buildSceneTools(deps) {
             }
             const created = await deps.rulesOps['rules-create-scene'](payload);
             if (!created || created.ok === false)
-                throw new Error((created && created.error) || '保存场景失败');
+                throw new Error((created && created.error) || 'failed to save the scene');
             // ② 两处「解绑」只能走 `rules-update-scene`：`scene-archive-save` 对载荷里**不带的栏**
             //    一律保留现值（archive-engine 的「不带 ≠ 解绑」），从现值复制出来的合并档案会把
             //    刚解掉的绑定又写回去 —— 所以解绑与设置分成两条路，合并前还要先摘掉刚解掉的键。
@@ -383,7 +383,7 @@ export function buildSceneTools(deps) {
             const setToolTable = args.toolTablePreset !== undefined && String(args.toolTablePreset).trim() !== '';
             const setQuickPrompts = args.quickPrompts !== undefined;
             if (setQuickPrompts && !Array.isArray(args.quickPrompts)) {
-                throw new Error('quickPrompts 必须是 id 数组（[] = 进入后全部停用；解绑需用户手动操作，本工具不提供）');
+                throw new Error('quickPrompts must be an array of ids ([] = turn them all off on entry; unbinding is a manual step in the panel, not offered here)');
             }
             const touched = ARCHIVE_SECTIONS.filter((k) => args[k] !== undefined);
             const mustWriteArchive = touched.length > 0 || setToolTable || setQuickPrompts;
@@ -396,7 +396,7 @@ export function buildSceneTools(deps) {
                 const cur = await deps.archiveOps['scene-mode-get']({});
                 if (!cur || cur.ok === false) {
                     if (mustWriteArchive)
-                        throw new Error((cur && cur.error) || '读取场景档案失败');
+                        throw new Error((cur && cur.error) || 'failed to read the scene archive');
                 }
                 else {
                     before = (cur.archives || {})[scene] || {};
@@ -413,7 +413,7 @@ export function buildSceneTools(deps) {
                 const u = await deps.rulesOps['rules-update-scene'](upd);
                 if (!u || u.ok === false) {
                     // 主路径已成功、解绑没写上：如实报，别让回执假装绑定已经没了。
-                    clearWarn = '\nWARN: 解绑未写入（' + ((u && u.error) || '未知错误') + '），旧绑定仍然有效';
+                    clearWarn = '\nWARN: the unbind was not written (' + ((u && u.error) || 'unknown error') + '); the old binding still applies';
                 }
             }
             // ③ 档案 read-modify-write：段（mcp / mcpNotes / skills / subagents）与两个绑定栏的
@@ -440,32 +440,32 @@ export function buildSceneTools(deps) {
                     archive.quickPrompts = quickPromptIds(args.quickPrompts);
                 const r = await deps.archiveOps['scene-archive-save']({ scene, archive });
                 if (!r || r.ok === false)
-                    throw new Error((r && r.error) || '保存场景档案失败');
+                    throw new Error((r && r.error) || 'failed to save the scene archive');
                 // 回执必须回显**这一次替换挤掉了什么**。整段替换本身是对的（省略的段不填回就会被
                 // 静默清掉，所以"模型给什么就是什么"），但"给出去的段盖掉了原来的勾选"是**静默**的
                 // —— 不写出来，模型只会看到一句"档案段：mcp"，以为只是加了一项。
                 const diffs = touched.map((k) => segmentDiff(k, before[k], args[k]));
                 if (diffs.length) {
-                    archiveNote = '档案段：' + diffs.map((d) => d.text).join('；');
+                    archiveNote = 'archive segments: ' + diffs.map((d) => d.text).join('; ');
                     if (diffs.some((d) => d.dropped.length > 0)) {
-                        warnTail += '\n注意：这些段是整段替换，上面标 - 的项已被挤掉；要保留就把它们一并写进这次调用。';
+                        warnTail += '\nnote: these segments are replaced as a whole; entries marked "-" above were dropped. To keep them, include them in this same call.';
                     }
                 }
                 // 当前环境里不存在的键会被 op 丢弃并报告（改名或删除留下的，含工具表方案名与
                 // 快捷提示词 id）：如实说，否则模型以为勾上了而实际没有。
                 if (r.stale && r.stale.length)
-                    warnTail += '\n（丢弃了当前环境不存在的键：' + r.stale.join('、') + '）';
+                    warnTail += '\n(dropped keys the current environment does not have: ' + r.stale.join(', ') + ')';
                 // 存盘成功但应用到运行时失败：`scene-archive-save` 对"正是当前模式的那个场景"会就地
                 // 重应用，失败不回滚档案。如实报出去，别假装生效了（与界面同口径）。
                 if (r.applyError)
-                    warnTail += '\n（已存盘，但应用到运行时失败：' + r.applyError + '）';
+                    warnTail += '\n(saved, but applying it to the runtime failed: ' + r.applyError + ')';
             }
             // 解绑写失败了就别输出「X → 解绑」—— 上面那句 WARN 才是事实；设置方向不受 ② 影响。
             if (args.toolTablePreset !== undefined && !(unbindToolTable && clearWarn !== '')) {
                 toolTableNote = beforeKnown
-                    ? '工具表方案：' + (toolTableLabel(before.toolTablePreset) || '未绑') + ' → ' +
-                        (unbindToolTable ? '解绑' : toolTableLabel(String(args.toolTablePreset).trim()))
-                    : '工具表方案：已解绑（档案现状读不到，无法对比）';
+                    ? 'tool-table preset: ' + (toolTableLabel(before.toolTablePreset) || 'unbound') + ' -> ' +
+                        (unbindToolTable ? 'unbind' : toolTableLabel(String(args.toolTablePreset).trim()))
+                    : 'tool-table preset: unbound (the current archive is unreadable, no diff available)';
             }
             if (setQuickPrompts && beforeKnown) {
                 const beforeIds = Array.isArray(before.quickPrompts) ? before.quickPrompts.map((x) => String(x)) : [];
@@ -477,15 +477,15 @@ export function buildSceneTools(deps) {
                     marks.push('+' + toolNameList(added));
                 if (dropped.length)
                     marks.push('-' + toolNameList(dropped));
-                quickNote = '快捷提示词：' + beforeIds.length + ' 条 → ' + afterIds.length + ' 条' +
-                    (afterIds.length === 0 ? '（进入后全部停用）' : '') +
-                    (marks.length ? '（' + marks.join(' ') + '）' : '');
+                quickNote = 'quick prompts: ' + beforeIds.length + ' -> ' + afterIds.length + ' ids' +
+                    (afterIds.length === 0 ? ' (all off after entering)' : '') +
+                    (marks.length ? ' (' + marks.join(' ') + ')' : '');
             }
             // 收敛提示：`rules-create-scene` 在"历史默认（全部启用）"状态下会把启用集合收窄成
             // 单选（`collapseActiveForNewScene`）—— 那是一次**会改变运行时**的动作，必须说出来。
             // 界面上同样如实报（`scenes.result.created.collapsed`）。
             const collapsed = created.collapsedActive === true;
-            const parts = [touchedRecord.length ? '场景记录已更新（' + touchedRecord.join('、') + '）' : '场景已确保存在'];
+            const parts = [touchedRecord.length ? 'scene record updated (' + touchedRecord.join(', ') + ')' : 'scene existence ensured'];
             if (archiveNote)
                 parts.push(archiveNote);
             if (toolTableNote)
@@ -496,13 +496,13 @@ export function buildSceneTools(deps) {
             // 部分启用（开 save 不开 switch）时指向一条模型没有的工具，只会让它白跑一趟 ——
             // 与 mcp/skill 的 listHint 同一条纪律。
             const enterHint = deps.toolVisible('scene_manager_switch')
-                ? '要让它生效，用 scene_manager_switch 进入。'
-                : '要让它生效，需用户手动进入该场景（本会话未开放 scene_manager_switch）。';
-            return 'OK: scene「' + scene + '」' + parts.join('；') + warnTail + clearWarn +
+                ? 'To take effect, enter it with scene_manager_switch.'
+                : 'To take effect, the user has to enter this scene manually (scene_manager_switch is not available in this session).';
+            return 'OK: scene "' + scene + '"' + parts.join('; ') + warnTail + clearWarn +
                 (collapsed
-                    ? '\n注意：此前所有场景都处于启用状态（历史「全部启用」默认），本次已收窄为只启用一个，新建的这个不在其中 —— 需用户确认启用状态。'
+                    ? '\nnote: every scene was enabled until now (the historical all-enabled default); this call narrowed the enabled set to one scene, and the new one is not it — the user should confirm the enabled state.'
                     : '') +
-                '\n保存不改运行时：' + enterHint;
+                '\nSaving does not change the runtime: ' + enterHint;
         },
     }));
 }

package/lib/tools/skills.js

@@ -16,7 +16,7 @@ export function buildSkillTools(deps) {
         // （2026-10-15 注入文本审查）：可行动的那半句已经写在 `skill_manager_read` 的描述里
         // （"Not sent when the official `skill` tool is mounted — use that instead."），
         // 这里再预告一遍同一个条件，只是同一件事付两次 token。
-        description: 'List skills with enabled state, effective/shadowed status and source file path. The「当前技能目录」reminder carries callable skills and summaries only; use this for entries that are off, for each entry\'s source-file path, and to see which source wins a name collision. Defaults to enabled only; all=true for every entry. A copy marked "shadowed-by:<root>" stays inactive even if enabled; "preferred" marks the copy that wins a name collision.',
+        description: 'List skills with enabled state, effective/shadowed status and source file path. The "Current skills" reminder carries callable skills and summaries only; use this for entries that are off, for each entry\'s source-file path, and to see which source wins a name collision. Defaults to enabled only; all=true for every entry. A copy marked "shadowed-by:<root>" stays inactive even if enabled; "preferred" marks the copy that wins a name collision.',
         parameters: {
             all: { type: 'boolean', description: 'Include disabled and shadowed entries (default false).' },
         },
@@ -84,7 +84,7 @@ export function buildSkillTools(deps) {
     // 已在上面标出胜出者），再走 `skill-detail` 读那一份 —— 读到的永远是目录列出来的那一份。
     register(defineTool({
         name: 'skill_manager_read',
-        description: 'Read one skill\'s full SKILL.md body by name — what the「当前技能目录」reminder deliberately leaves out (it has names and summaries only). Also lists the other files living in that skill folder (references/, scripts/), which the body often points at. Resolves name collisions the same way, so you get the copy actually in effect; pass root only to inspect a specific (e.g. shadowed) source. Not sent when the official `skill` tool is mounted — use that instead.',
+        description: 'Read one skill\'s full SKILL.md body by name — what the "Current skills" reminder deliberately leaves out (it has names and summaries only). Also lists the other files living in that skill folder (references/, scripts/), which the body often points at. Resolves name collisions the same way, so you get the copy actually in effect; pass root only to inspect a specific (e.g. shadowed) source. Not sent when the official `skill` tool is mounted — use that instead.',
         parameters: {
             name: { type: 'string', required: true, description: 'Skill name, exactly as it appears in the catalog (kebab-case).' },
             root: { type: 'string', description: 'Source root key (dsh/hub/agents/codex/claude, a project key, or a custom one). Default: the winning copy of this name.' },
@@ -204,35 +204,35 @@ export function buildSkillTools(deps) {
             const preferGiven = Boolean(args && args.prefer !== undefined);
             const prefer = args && args.prefer === true;
             if (preferGiven && typeof args.prefer !== 'boolean')
-                throw new Error('prefer 必须是 true 或 false');
+                throw new Error('prefer must be true or false');
             if (name && source)
-                throw new Error('name 与 source 只能给一个：name 是单个技能，source 是整个来源目录');
+                throw new Error('give either name or source, not both: name is one skill, source is a whole source folder');
             if (preferGiven && source)
-                throw new Error('prefer 只对单个技能有意义：给 name，不要给 source');
+                throw new Error('prefer only makes sense for a single skill: pass name, not source');
             if (!name && !source)
-                throw new Error('缺少参数：name（单个技能）或 source（整个来源目录）');
+                throw new Error('missing argument: name (one skill) or source (a whole source folder)');
             if (preferGiven && !name)
-                throw new Error('缺少参数：prefer 需要 name');
+                throw new Error('missing argument: prefer needs name');
             if (preferGiven && String((args && args.root) || '').trim() === '') {
-                throw new Error('prefer 需要 root：明确指定哪一份同名副本胜出（dsh / hub / agents / codex / claude 或项目键）');
+                throw new Error('prefer needs root: name the copy that should win this collision (dsh / hub / agents / codex / claude or a project key)');
             }
             // 两个动作一个都没给就拒：`args.enabled ? enable : disable` 会把"忘了给"静默当成"停用"。
             if (args.enabled === undefined && !preferGiven) {
-                throw new Error('缺少参数：enabled 必须是 true 或 false（只想改同名首选就传 prefer）');
+                throw new Error('missing argument: enabled must be true or false (pass prefer if you only want to change which copy wins the collision)');
             }
             if (source) {
                 // 来源级启停：登记表里 `skill-source-enable` / `skill-source-disable` 都是
                 // `{ serviceWrite, frozen, syncsArchive }`，所以守卫已过、档案也要同步
                 // —— 同步的入参是 `{ root }`（来源级没有独立字段，档案靠"来源下有没有被勾的技能"反推）。
                 if (args.root !== undefined)
-                    throw new Error('source 已经是来源级的键，不要再给 root');
+                    throw new Error('source is already a source-level key; do not pass root with it');
                 const op = args.enabled ? 'skill-source-enable' : 'skill-source-disable';
                 const r = await deps.skillsOps[op]({ root: source });
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || 'skill source toggle failed');
                 const syncErr = await deps.syncSwitchToScene(op, { root: source, enabled: args.enabled === true });
                 return 'OK: source ' + source + ' now ' + (args.enabled ? 'enabled' : 'disabled') +
-                    (syncErr ? '\nWARN: 当前场景档案未同步（' + syncErr + '）' : '');
+                    (syncErr ? '\nWARN: the current scene archive was not synced (' + syncErr + ')' : '');
             }
             // 不给 root 就在全部来源里找（2026-10-15 smoke-test P0-1）：`skill_manager_save` 的落点
             // 是 hub（`tool-management/skills/`），而这里的默认值原本是 dsh —— 「建完就启用」这条
@@ -248,7 +248,7 @@ export function buildSkillTools(deps) {
                 // 探得到、就是没这个技能：当场把"查过哪些来源"说清楚。否则模型收到 op 那句不带
                 // 来源信息的「技能不存在」后，只能猜该传哪个 root（smoke-test P1-4-old 同一处）。
                 if (found.ok) {
-                    throw new Error('技能不存在: ' + name + (found.roots.length ? '（已查 ' + found.roots.join('、') + '）' : ''));
+                    throw new Error('no such skill: ' + name + (found.roots.length ? ' (searched ' + found.roots.join(', ') + ')' : ''));
                 }
                 // 探不到（skill-state 失败）就别在这里编结论：退回旧默认，交给 op 报它自己的错。
                 return 'dsh';
@@ -262,7 +262,7 @@ export function buildSkillTools(deps) {
                 const op = prefer ? 'skill-prefer' : 'skill-unprefer';
                 const p = await deps.skillsOps[op]({ name: args.name, root });
                 if (!p || p.ok === false)
-                    throw new Error((p && p.error) || '设置同名首选失败');
+                    throw new Error((p && p.error) || 'failed to set the collision winner');
                 // `skill-prefer` 会在"记下了但不会生效"时回 ok:true + warning（首选指向**停用**的来源，
                 // 而同名首选会挡住其他副本 → 两份都不生效）。原样转出去，否则模型以为已经生效。
                 out.push((prefer
@@ -303,7 +303,7 @@ export function buildSkillTools(deps) {
                 const warn = shadowedBy
                     ? ' — BUT this copy is shadowed by the same-name skill in "' + shadowedBy + '", so it stays inactive: enable that copy instead, or make it win with prefer=true and root="' + shadowedBy + '"'
                     : '';
-                const sceneWarn = syncErr ? '\nWARN: 当前场景档案未同步（' + syncErr + '）' : '';
+                const sceneWarn = syncErr ? '\nWARN: the current scene archive was not synced (' + syncErr + ')' : '';
                 out.push('OK: ' + args.name + ' now ' + (args.enabled ? 'enabled' : 'disabled') + warn + sceneWarn);
             }
             return out.join('\n');
@@ -339,10 +339,10 @@ export function buildSkillTools(deps) {
                 throw new Error(blocked);
             const wanted = String((args && args.name) || '').trim();
             if (!wanted)
-                throw new Error('缺少参数：name');
+                throw new Error('missing argument: name');
             const kebab = toKebab(wanted);
             if (!kebab)
-                throw new Error('无法生成合法 kebab-case 名称（原始名: ' + wanted + '）');
+                throw new Error('cannot build a valid kebab-case name (raw name: ' + wanted + ')');
             // 建还是改：先看这个（规范化后的）名字在不在。`skill-create` 对同名是**拒绝**的，
             // 所以这条判定只能在这里做 —— 不能指望 op 层兜，也不能让模型自己先查一次
             // （它手里的清单可能已经过期）。
@@ -367,7 +367,7 @@ export function buildSkillTools(deps) {
                     body === '' ? 'body' : '',
                 ].filter((x) => x !== '');
                 if (missing.length)
-                    throw new Error('新建技能必须给 ' + missing.join(' 与 ') + '（' + kebab + ' 还不存在）');
+                    throw new Error('creating a skill needs ' + missing.join(' and ') + ' (' + kebab + ' does not exist yet)');
                 const r = await deps.skillsOps['skill-create']({ name: wanted, description: args.description, body: args.body });
                 if (!r || r.ok === false)
                     throw new Error((r && r.error) || 'skill create failed');
@@ -377,8 +377,8 @@ export function buildSkillTools(deps) {
                 // 里只有这一条不报启用状态）。点名的 `skill_manager_switch` 在出厂默认名单里就是关着的，
                 // 关着就改说"用户启用后才能用"，别指一条模型没有的工具。
                 const enableHint = deps.toolVisible('skill_manager_switch')
-                    ? '（默认未启用，要启用先 skill_manager_switch）'
-                    : '（默认未启用，用户启用后才能用）';
+                    ? ' (created disabled; use skill_manager_switch to enable it)'
+                    : ' (created disabled; the user has to enable it first)';
                 return 'Created DSH skill ' + (data.name || kebab) + ' at ' + (data.path || '(unknown)') + enableHint;
             }
             // 改的分支：省略 = 保持。两个可改字段一个都没给就拒 —— op 会按"保持原样"重写一次文件
@@ -389,12 +389,12 @@ export function buildSkillTools(deps) {
             if (args.body !== undefined)
                 touched.push('body');
             if (!touched.length)
-                throw new Error('没有要改的东西：description / body 至少给一个');
+                throw new Error('nothing to change: pass description and/or body');
             const r = await deps.skillsOps['skill-update']({ name: wanted, description: args.description, body: args.body });
             if (!r || r.ok === false)
                 throw new Error((r && r.error) || 'skill update failed');
             const data = r.data || {};
-            return 'Updated DSH skill ' + (data.name || kebab) + ' at ' + (data.path || '(unknown)') + '（改了 ' + touched.join('、') + '）';
+            return 'Updated DSH skill ' + (data.name || kebab) + ' at ' + (data.path || '(unknown)') + ' (changed ' + touched.join(', ') + ')';
         },
     }));
 }

package/lib/tools/subagent.js

@@ -78,7 +78,7 @@ export function buildSubagentTools(deps) {
     try {
         register(deps.defineTool({
             name: 'subagent_manager_switch',
-            description: 'Enable or disable one persona. Only enabled personas appear in the「当前子智能体」catalog and can be given work. Reversible. Only when the user asks or approves.',
+            description: 'Enable or disable one persona. Only enabled personas appear in the "Current subagents" catalog and can be given work. Reversible. Only when the user asks or approves.',
             parameters: {
                 name: { type: 'string', required: true, description: 'Persona name.' },
                 enabled: { type: 'boolean', required: true, description: 'true = enable, false = disable; omission is refused.' },
@@ -91,12 +91,12 @@ export function buildSubagentTools(deps) {
                 const name = String((args && args.name) || '').trim();
                 const r = await ops()['subagent-toggle']({ name, enabled: args.enabled === true });
                 if (!r || r.ok === false)
-                    throw new Error((r && r.error) || '切换人设启停失败');
+                    throw new Error((r && r.error) || 'failed to toggle the persona');
                 // 场景内改开关要同步进当前场景档案（与 HTTP 层 syncsArchive 同一口径 —— 模型工具
                 // 直接调 service op，绕过了那一层包装，所以这里自己叫一声）。
                 const syncErr = await deps.syncSwitchToScene('subagent-toggle', { name, enabled: args.enabled === true });
                 return 'OK: persona ' + name + ' ' + (args.enabled === true ? 'enabled' : 'disabled') +
-                    (syncErr ? '\nWARN: 当前场景档案未同步（' + syncErr + '）' : '');
+                    (syncErr ? '\nWARN: the current scene archive was not synced (' + syncErr + ')' : '');
             },
         }));
     }
@@ -138,11 +138,11 @@ export function buildSubagentTools(deps) {
                 // 高级字段的形状校验：填错会在 op 侧**静默**（`serializePersona` 对非数组 `tools`
                 // 是"当空处理"，等于把用户原有的名单清掉）。在这里先挡一句。
                 if (args && args.continuable !== undefined && typeof args.continuable !== 'boolean') {
-                    throw new Error('continuable 必须是 true 或 false');
+                    throw new Error('continuable must be true or false');
                 }
                 for (const k of ['tools', 'toolsDeny']) {
                     if (args && args[k] !== undefined && !Array.isArray(args[k])) {
-                        throw new Error(k + ' 必须是字符串数组（[] = 清空）');
+                        throw new Error(k + ' must be an array of strings ([] = clear)');
                     }
                 }
                 const current = await ops()['subagent-get']({ name });
@@ -156,17 +156,17 @@ export function buildSubagentTools(deps) {
                         body === '' ? 'body' : '',
                     ].filter((x) => x !== '');
                     if (missing.length)
-                        throw new Error('新建人设必须给 ' + missing.join(' 与 ') + '（' + name + ' 还不存在）');
+                        throw new Error('creating a persona needs ' + missing.join(' and ') + ' (' + name + ' does not exist yet)');
                     const r = await ops()['subagent-create']({ name, description: args.description, body: args.body, output: args.output, ...advancedArgs(args) });
                     if (!r || r.ok === false)
-                        throw new Error((r && r.error) || '创建人设失败');
+                        throw new Error((r && r.error) || 'failed to create the persona');
                     // 新建的人设默认停用（与 MCP / 技能同口径）。这句必须留：不说的话模型会直接去委派，
                     // 然后收到"人设不可用"，而它并不知道自己少拨了一个开关。点名的 subagent_manager_switch
                     // 在出厂默认名单里就是关着的 —— 关着就改说"用户启用后才能委派"，别指一条模型没有的
                     // 工具（与 mcp/skill 的 listHint 同一条纪律）。
                     const enableHint = deps.toolVisible('subagent_manager_switch')
-                        ? '（默认未启用，要委派它先 subagent_manager_switch）'
-                        : '（默认未启用，用户启用后才能委派）';
+                        ? ' (created disabled; use subagent_manager_switch to enable it before delegating)'
+                        : ' (created disabled; the user has to enable it before you can delegate)';
                     return 'OK: persona ' + String(r.name || name) + ' created' + enableHint;
                 }
                 const keep = current.persona || {};
@@ -179,7 +179,7 @@ export function buildSubagentTools(deps) {
                         touched.push(k);
                 }
                 if (!touched.length)
-                    throw new Error('没有要改的东西：description / body / output / nextName 或任一高级字段至少给一个');
+                    throw new Error('nothing to change: pass at least one of description / body / output / nextName or any advanced field');
                 const merged = {
                     name,
                     nextName: args.nextName,
@@ -200,9 +200,9 @@ export function buildSubagentTools(deps) {
                 };
                 const r = await ops()['subagent-update'](merged);
                 if (!r || r.ok === false)
-                    throw new Error((r && r.error) || '更新人设失败');
-                return 'OK: persona ' + String(r.name || name) + ' updated（改了 ' + touched.join('、') + '）' +
-                    (r.renamedFrom ? ' — 原名「' + r.renamedFrom + '」,场景档案里的绑定已一起改名' : '');
+                    throw new Error((r && r.error) || 'failed to update the persona');
+                return 'OK: persona ' + String(r.name || name) + ' updated (changed ' + touched.join(', ') + ')' +
+                    (r.renamedFrom ? ' — was named "' + r.renamedFrom + '"; the scene-archive binding was renamed too' : '');
             },
         }));
     }

package/lib/tools/table.js

@@ -35,7 +35,7 @@ import { INJECT_DOMAIN_KEYS, domainOfTool } from '../context-inject.js';
  * 判据是用户 2026-09-23 的三轮裁定，同一条：**这些信息或动作常态下由注入段与面板承担，
  * 平时也用不到模型自己伸手**。三组：
  *   · **写侧五条** —— 三个 `*_save`（MCP / 技能 / 人设：配置本体在面板上改）+ 提示词两条
- *     （这一族只有两条，而当前生效的那份本来就在「当前提示词」注入段里）。
+ *     （这一族只有两条，而当前生效的那份本来就在 `Current prompt` 注入段里）。
  *   · **读侧三条** —— 两个 `*_list`（MCP / 技能）+ `memory_manager_read`。会话开头注入的那几段
  *     目录已经写了当前有什么，模型不必每轮再带一份查询工具。
  *   · **场景三条 + 开关三条** —— 场景一族（建 / 勾档案 / 进入退出）与 `skill` / `memory` /
@@ -58,7 +58,7 @@ import { INJECT_DOMAIN_KEYS, domainOfTool } from '../context-inject.js';
  * 绑定且深度够的、技能目录只列可调用的），所以"没开的那几台 / 被同名覆盖的那份技能 / 没进
  * 上下文的记忆正文"在会话里查不到；`*_switch` 关掉后模型也不能再替你拨启停。三处配套改动为
  * 的就是不把模型往墙上推：目录被条数上限截断时那句「用 `X_manager_list` 查」自动退回「另有
- * N 个未列出。」（`listToolVisible`）；`mcp_manager_list` / `skill_manager_read` 里"没找到 →
+ * N more not listed.)」（`listToolVisible`）；`mcp_manager_list` / `skill_manager_read` 里"没找到 →
  * 去调 list"那两句先问 `deps.toolVisible`；`memory_manager_list` 的描述不再点名已关的工具。
  *
  * 只在**用户从没记过选择**时生效（见 index.ts 的 `toolTableSettingsFrom`：侧车文件读不出来