pi-web-ui 0.68.2 → 0.69.0

package/dist/server/subagents.js

@@ -22,9 +22,13 @@
 // 本文件只定义：运行态快照类型、host 接口（由 ClientSession 实现，操作的是
 // 它的 conversation 体系）、以及注册给每个会话的 subagent_* 工具。真正创建
 // conversation / 跑 prompt 全部在 agent-service.ts 的 spawnSubagent 里完成。
+//
+// 双语约定（issue #91）：工具 definition 描述走 bilingual(en, zh) 内联双语
+// （英文在前）；per-call 返回文本按 lang 取 pick(lang, zh, en)。
 // ---------------------------------------------------------------------------
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { bilingual, pick } from "./i18n.js";
 /**
  * subagent_wait_all 的最长阻塞时间：必须短暂低于工具看门狗（默认 20 分钟，
  * PI_WEB_TOOL_TIMEOUT_MS 可调），否则看门狗会先中止整个会话而不是让 wait
@@ -45,12 +49,28 @@ export function subagentTitle(prompt) {
     const line = prompt.split("\n")[0]?.trim() ?? "";
     return line.length > 40 ? `${line.slice(0, 40)}…` : line;
 }
+/**
+ * 返回注入 ownerId 的 host 包装：每次 spawn 时自动把 ownerId（真正的派发会话）
+ * 作为子代理的 parentId 传给底层 host。
+ *
+ * 背景（issue #95）：子代理左栏嵌套靠 parentId，而派发方是某个会话的 runtime ——
+ * 必须按 runtime 归属记父对话，而不是派发瞬间的 active。后台对话继续产出时用户
+ * 可能已切到别的项目，直接读 activeId 会把孩子记到无关会话名下（错组/沉底）。
+ * 每个会话创建 runtime 时用本函数包一层，让它的 spawn 天然带自己的会话 id。
+ */
+export function withSubagentOwner(host, ownerId) {
+    return {
+        ...host,
+        spawnSubagent: (prompt, type, cwd, templateName, model) => host.spawnSubagent(prompt, type, cwd, templateName, model, ownerId),
+    };
+}
 /**
  * 子代理工具集（注册进每个会话的 customTools，供主 agent 驱动子代理）。
  * 用 `subagent_*` 前缀命名，避免与第三方 pi-subagents 的
  * `Agent`/`get_subagent_result`/`steer_subagent` 冲突。
  */
-export function makeSubagentTools(host) {
+export function makeSubagentTools(host, lang) {
+    const getLang = lang ?? host.lang ?? (() => "en");
     const text = (t, details = {}) => ({
         content: [{ type: "text", text: t }],
         details,
@@ -59,108 +79,165 @@ export function makeSubagentTools(host) {
         defineTool({
             name: "subagent_spawn",
             label: "Spawn subagent",
-            description: "在后台启动一个独立的子代理对话，用一个明确的指令去完成一项可独立交付的工作（调研/实现/审查等）。" +
+            description: bilingual("Spawn an independent background subagent conversation for a self-contained deliverable task " +
+                '(research/implement/review, etc.). Subagents appear in the left "Running conversations" list with a ' +
+                "subagent badge; the user can open, supplement, or stop them. The main agent may spawn several in parallel: " +
+                "use subagent_wait_all to wait for all at once (no polling), subagent_list for live status, " +
+                "subagent_get_result for results, subagent_steer to redirect mid-run, subagent_stop to stop. " +
+                "Good for: long-running exploration, parallel research, delegating independent subtasks. Optional template " +
+                "param: use a subagent template configured in the settings panel " +
+                "(role system prompt + skills/extensions whitelist + optional model); optional model param: explicitly set " +
+                'the subagent model (provider/id, e.g. "anthropic/claude-opus-4-5"), which overrides the template and panel ' +
+                "default; omit both = follow the main conversation's model.", "在后台启动一个独立的子代理对话，用一个明确的指令去完成一项可独立交付的工作（调研/实现/审查等）。" +
                 "子代理会出现在左栏「运行的对话」列表（带子代理标识），用户可点开查看、补充、中止。主 agent 可并行派发多个：" +
                 "用 subagent_wait_all 一次性等全部完成（不用轮询）、subagent_list 查看运行态、subagent_get_result 取结果、" +
                 "subagent_steer 中途改向、subagent_stop 停止。" +
                 "适合：长耗时探索、并行调研、独立子任务委派。可选 template 参数：使用设置面板配置的子代理模板" +
                 "（角色系统提示词 + 技能/扩展白名单 + 可选模型）；可选 model 参数：显式指定子代理模型（provider/id 格式，" +
-                '如 "anthropic/claude-opus-4-5"），优先级高于模板与设置面板的默认模型；都不传 = 跟随主对话当前模型。',
+                '如 "anthropic/claude-opus-4-5"），优先级高于模板与设置面板的默认模型；都不传 = 跟随主对话当前模型。'),
             promptSnippet: "spawn an independent background subagent for a deliverable task (parallel work)",
             parameters: Type.Object({
-                prompt: Type.String({ description: "交给子代理的完整指令（要达成的目标 + 约束 + 期望产出）。" }),
-                type: Type.Optional(Type.String({ description: "子代理类型/角色名（如 explore/implement/review），用于展示。默认 general。" })),
+                prompt: Type.String({
+                    description: bilingual("Full instructions for the subagent (goal + constraints + expected output).", "交给子代理的完整指令（要达成的目标 + 约束 + 期望产出）。"),
+                }),
+                type: Type.Optional(Type.String({
+                    description: bilingual("Subagent type/role name (e.g. explore/implement/review), for display. Default general.", "子代理类型/角色名（如 explore/implement/review），用于展示。默认 general。"),
+                })),
                 template: Type.Optional(Type.String({
-                    description: "可选：子代理模板名（设置面板「子代理模板」配置的预设，见 subagent_templates 工具）。" +
-                        "模板 = 角色系统提示词 + 技能/扩展白名单 + 可选模型；不传 = 不使用模板，按主会话默认配置运行。",
+                    description: bilingual("Optional: subagent template name (a preset configured under Settings → Subagent Templates, see the " +
+                        "subagent_templates tool). Template = role system prompt + skills/extensions whitelist + optional " +
+                        "model; omit = run with the main session defaults.", "可选：子代理模板名（设置面板「子代理模板」配置的预设，见 subagent_templates 工具）。" +
+                        "模板 = 角色系统提示词 + 技能/扩展白名单 + 可选模型；不传 = 不使用模板，按主会话默认配置运行。"),
                 })),
                 model: Type.Optional(Type.String({
-                    description: '可选：子代理模型 "provider/id"（如 "anthropic/claude-opus-4-5"），显式指定本次子代理的模型，' +
-                        "优先级高于模板自带模型与设置面板默认模型；不传 = 模板模型 → 设置面板默认模型 → 跟随主对话当前模型。",
+                    description: bilingual('Optional: subagent model "provider/id" (e.g. "anthropic/claude-opus-4-5") for this run; overrides the ' +
+                        "template model and the settings-panel default; omit = template model → panel default → follow the " +
+                        "main conversation model.", '可选：子代理模型 "provider/id"（如 "anthropic/claude-opus-4-5"），显式指定本次子代理的模型，' +
+                        "优先级高于模板自带模型与设置面板默认模型；不传 = 模板模型 → 设置面板默认模型 → 跟随主对话当前模型。"),
+                })),
+                cwd: Type.Optional(Type.String({
+                    description: bilingual("Subagent working directory (relative/absolute). Defaults to the main session's cwd.", "子代理工作目录（相对/绝对）。默认继承主会话工作目录。"),
                 })),
-                cwd: Type.Optional(Type.String({ description: "子代理工作目录（相对/绝对）。默认继承主会话工作目录。" })),
             }),
             execute: async (_id, p, _signal, _onUpdate, ctx) => {
                 if (p.template && !host.isTemplateUsable(p.template)) {
-                    return text(`子代理模板不可用：${p.template}（不存在或已停用）。用 subagent_templates 查看当前可用模板清单；不传 template 则按默认配置运行。`);
+                    return text(pick(getLang(), `子代理模板不可用：${p.template}（不存在或已停用）。用 subagent_templates 查看当前可用模板清单；不传 template 则按默认配置运行。`, `Subagent template unavailable: ${p.template} (missing or disabled). Use subagent_templates to list available templates; omit template to run with defaults.`, "subagents.spawn.template.unavailable", { "p.template": p.template }));
                 }
                 const convId = await host.spawnSubagent(p.prompt, p.type ?? "general", p.cwd ?? ctx.cwd, p.template, p.model);
-                return text(`子代理已启动（运行列表可见）：${convId}\n类型：${p.type ?? "general"} · 标题：${subagentTitle(p.prompt)}` +
+                const subagentType = p.type ?? "general";
+                const subagentTitleText = subagentTitle(p.prompt);
+                return text(pick(getLang(), `子代理已启动（运行列表可见）：${convId}\n类型：${subagentType} · 标题：${subagentTitleText}` +
                     (p.template ? `\n模板：${p.template}` : "") +
                     (p.model ? `\n模型：${p.model}` : "") +
-                    `\n用 subagent_wait_all 一次等全部完成（不用轮询），subagent_get_result 取单个结果，subagent_list 看运行态，subagent_steer 改向，subagent_stop 停止。`, { convId, template: p.template, model: p.model });
+                    `\n用 subagent_wait_all 一次等全部完成（不用轮询），subagent_get_result 取单个结果，subagent_list 看运行态，subagent_steer 改向，subagent_stop 停止。`, `Subagent started (visible in the running list): ${convId}\nType: ${subagentType} · Title: ${subagentTitleText}` +
+                    (p.template ? `\nTemplate: ${p.template}` : "") +
+                    (p.model ? `\nModel: ${p.model}` : "") +
+                    `\nUse subagent_wait_all to wait for all at once (no polling), subagent_get_result for a single result, subagent_list for live status, subagent_steer to redirect, subagent_stop to stop.`, "subagents.spawn.started", {
+                    convId: convId,
+                    subagentType: subagentType,
+                    subagentTitleText: subagentTitleText,
+                    "p.template": p.template,
+                    "p.model": p.model,
+                }), { convId, template: p.template, model: p.model });
             },
         }),
         defineTool({
             name: "subagent_get_result",
             label: "Get subagent result",
-            description: "取一个子代理的结果或当前运行态。若尚未完成，返回当前状态与已产出的文本；运行报错（如 provider 400）会在这里明确标出错误。",
+            description: bilingual("Fetch a subagent's result or current progress. If not finished yet, returns the current status and partial " +
+                "output; runtime errors (e.g. provider 400) are surfaced here as explicit errors.", "取一个子代理的结果或当前运行态。若尚未完成，返回当前状态与已产出的文本；运行报错（如 provider 400）会在这里明确标出错误。"),
             promptSnippet: "fetch a subagent's result / current progress",
             parameters: Type.Object({
-                runId: Type.String({ description: "subagent_spawn 返回的 convId。左栏点击同名对话可直接查看。" }),
+                runId: Type.String({
+                    description: bilingual("ConvId returned by subagent_spawn. Clicking the same conversation in the left panel opens it directly.", "subagent_spawn 返回的 convId。左栏点击同名对话可直接查看。"),
+                }),
             }),
             execute: async (_id, p) => {
                 const r = host.getSubagent(p.runId);
+                const missingId = shortId(p.runId);
                 if (!r)
-                    return text(`未找到子代理 ${shortId(p.runId)}（可能已移出）。`, undefined);
-                const verdict = subagentVerdict(r);
+                    return text(pick(getLang(), `未找到子代理 ${missingId}（可能已移出）。`, `Subagent ${missingId} not found (may have been dismissed).`, "subagents.get.not.found", { missingId: missingId }), undefined);
+                const verdict = subagentVerdict(r, getLang());
+                const doneId = shortId(r.convId);
+                const doneDetail = verdictText(r, getLang());
+                const doneOutput = r.output || (getLang() === "zh" ? "（无结果）" : "(no result)");
                 if (r.streaming || r.state === "running") {
-                    return text(`子代理 ${shortId(r.convId)}（${r.type}）仍在运行（状态 ${r.state}）。\n当前输出：\n${r.output || "（暂无输出）"}`, r);
+                    const runningId = shortId(r.convId);
+                    const runningOutput = r.output || (getLang() === "zh" ? "（暂无输出）" : "(no output yet)");
+                    return text(pick(getLang(), `子代理 ${runningId}（${r.type}）仍在运行（状态 ${r.state}）。\n当前输出：\n${runningOutput}`, `Subagent ${runningId} (${r.type}) is still running (state ${r.state}).\nCurrent output:\n${runningOutput}`, "subagents.get.running", { runningId: runningId, "r.type": r.type, "r.state": r.state, runningOutput: runningOutput }), r);
                 }
-                return text(`子代理 ${shortId(r.convId)}（${r.type}）状态：${verdict}\n${verdictText(r)}\n${r.output || "（无结果）"}`, r);
+                return text(pick(getLang(), `子代理 ${doneId}（${r.type}）状态：${verdict}\n${doneDetail}\n${doneOutput}`, `Subagent ${doneId} (${r.type}) status: ${verdict}\n${doneDetail}\n${doneOutput}`, "subagents.get.done", { doneId: doneId, "r.type": r.type, verdict: verdict, doneDetail: doneDetail, doneOutput: doneOutput }), r);
             },
         }),
         defineTool({
             name: "subagent_steer",
             label: "Steer subagent",
-            description: "向一个子代理注入一条消息，重定向/补充它的工作方向（等同用户在它的对话里发消息）。",
+            description: bilingual("Inject a message into a subagent to redirect or supplement its work (same as the user sending a message in its conversation).", "向一个子代理注入一条消息，重定向/补充它的工作方向（等同用户在它的对话里发消息）。"),
             promptSnippet: "inject a message into a running subagent to redirect its work",
             parameters: Type.Object({
-                runId: Type.String({ description: "目标子代理 convId。" }),
-                message: Type.String({ description: "要注入的方向调整/补充信息。" }),
+                runId: Type.String({
+                    description: bilingual("Target subagent convId.", "目标子代理 convId。"),
+                }),
+                message: Type.String({
+                    description: bilingual("Redirect / supplementary info to inject.", "要注入的方向调整/补充信息。"),
+                }),
             }),
             execute: async (_id, p) => {
                 await host.steerSubagent(p.runId, p.message);
-                return text(`已向子代理 ${shortId(p.runId)} 注入消息。`);
+                const steerId = shortId(p.runId);
+                return text(pick(getLang(), `已向子代理 ${steerId} 注入消息。`, `Message injected into subagent ${steerId}.`, "subagents.steer.injected", { steerId: steerId }));
             },
         }),
         defineTool({
             name: "subagent_list",
             label: "List subagents",
-            description: "列出全部子代理的运行态：convId、类型、状态、标题、消息数（报错/中止的会在状态里标出）。",
+            description: bilingual("List all subagents and their live status: convId, type, state, title, message count (errors/aborts are marked in the state).", "列出全部子代理的运行态：convId、类型、状态、标题、消息数（报错/中止的会在状态里标出）。"),
             promptSnippet: "list all subagents and their live status",
             parameters: Type.Object({}),
             execute: async () => {
                 const list = host.listSubagents();
                 if (list.length === 0)
-                    return text("当前没有子代理。");
-                const lines = list.map((r) => `- ${r.convId} · ${r.type} · ${subagentVerdict(r)} · ${r.title}（msg: ${r.messageCount}）`);
+                    return text(pick(getLang(), "当前没有子代理。", "No subagents running.", "subagents.list.empty"));
+                const tLang = getLang();
+                const lines = list.map((r) => `- ${r.convId} · ${r.type} · ${subagentVerdict(r, tLang)} · ${r.title}` +
+                    (tLang === "zh" ? `（msg: ${r.messageCount}）` : ` (msg: ${r.messageCount})`));
                 return text(lines.join("\n"));
             },
         }),
         defineTool({
             name: "subagent_stop",
             label: "Stop subagent",
-            description: "停止一个运行中的子代理（等同用户在它的对话里点中止）。已完成的不受影响。",
+            description: bilingual("Stop a running subagent (same as the user aborting it in its conversation). Already-finished ones are unaffected.", "停止一个运行中的子代理（等同用户在它的对话里点中止）。已完成的不受影响。"),
             promptSnippet: "stop a running subagent",
-            parameters: Type.Object({ runId: Type.String({ description: "目标子代理 convId。" }) }),
+            parameters: Type.Object({
+                runId: Type.String({
+                    description: bilingual("Target subagent convId.", "目标子代理 convId。"),
+                }),
+            }),
             execute: async (_id, p) => {
                 await host.stopSubagent(p.runId);
-                return text(`已请求停止子代理 ${shortId(p.runId)}。`);
+                const stopId = shortId(p.runId);
+                return text(pick(getLang(), `已请求停止子代理 ${stopId}。`, `Stop requested for subagent ${stopId}.`, "subagents.stop.requested", { stopId: stopId }));
             },
         }),
         defineTool({
             name: "subagent_wait_all",
             label: "Wait for subagents",
-            description: "一次性等待多个子代理全部完成（阻塞本回合直到它们都到达终态或超时），然后汇总返回每个的结果/错误——" +
+            description: bilingual("Wait for multiple subagents to finish at once (blocks this round until all reach a terminal state or time out), " +
+                "then summarize each result/error — no need to poll subagent_get_result. Pass runIds for specific subagents " +
+                "(convIds returned by subagent_spawn); omit = wait for all currently running ones. On timeout or abort of this " +
+                "round, returns the remaining unfinished list; call again to continue waiting. " +
+                "Good for: collecting parallel subagents.", "一次性等待多个子代理全部完成（阻塞本回合直到它们都到达终态或超时），然后汇总返回每个的结果/错误——" +
                 "不用反复调 subagent_get_result 轮询。传 runIds 指定要等的子代理（subagent_spawn 返回的 convId）；" +
                 "不传 = 等当前全部运行中的子代理。超时或本轮被中止时返回剩余未完成名单，可再次调用继续等。" +
-                "适合：并行派发多个子代理后收口。",
+                "适合：并行派发多个子代理后收口。"),
             promptSnippet: "wait for multiple subagents to finish (no polling) and get all results",
             parameters: Type.Object({
-                runIds: Type.Optional(Type.Array(Type.String({ description: "要等待的子代理 convId（subagent_spawn 返回值）。缺省 = 等当前全部运行中的。" }))),
+                runIds: Type.Optional(Type.Array(Type.String({
+                    description: bilingual("ConvId of a subagent to wait for (returned by subagent_spawn). Omit = wait for all currently running.", "要等待的子代理 convId（subagent_spawn 返回值）。缺省 = 等当前全部运行中的。"),
+                }))),
                 timeoutSeconds: Type.Optional(Type.Integer({
-                    description: `最多等待秒数（默认 600，上限约 ${Math.floor(WAIT_CAP_MS / 1000)}——必须低于工具看门狗，超时返回未完成名单可再调）。`,
+                    description: bilingual(`Max wait in seconds (default 600, cap ~${Math.floor(WAIT_CAP_MS / 1000)} — must stay below the tool watchdog; on timeout returns the unfinished list so you can call again).`, `最多等待秒数（默认 600，上限约 ${Math.floor(WAIT_CAP_MS / 1000)}——必须低于工具看门狗，超时返回未完成名单可再调）。`),
                     minimum: 1,
                     maximum: Math.floor(WAIT_CAP_MS / 1000),
                 })),
@@ -179,41 +256,62 @@ export function makeSubagentTools(host) {
                 while (pending().length > 0 && Date.now() < deadline && !(signal?.aborted ?? false)) {
                     await new Promise((resolve) => setTimeout(resolve, 300));
                 }
+                const tLang = getLang();
                 const remaining = pending();
                 const lines = [...wanted]
                     .map((id) => {
                     const r = host.getSubagent(id);
                     if (!r)
-                        return `- ${shortId(id)}：未找到（可能已移出）`;
-                    const body = verdictText(r);
-                    return (`- ${shortId(r.convId)}（${r.type}）· ${r.title} · ${subagentVerdict(r)}` +
+                        return tLang === "zh"
+                            ? `- ${shortId(id)}：未找到（可能已移出）`
+                            : `- ${shortId(id)}: not found (may have been dismissed)`;
+                    const body = verdictText(r, tLang);
+                    return ((tLang === "zh"
+                        ? `- ${shortId(r.convId)}（${r.type}）· ${r.title} · ${subagentVerdict(r, tLang)}`
+                        : `- ${shortId(r.convId)} (${r.type}) · ${r.title} · ${subagentVerdict(r, tLang)}`) +
                         (body ? `\n  ${body}` : "") +
                         (r.output ? `\n  ${r.output.split("\n").slice(0, 30).join("\n  ")}` : ""));
                 })
                     .join("\n");
+                const timeoutSecs = Math.round(timeoutMs / 1000);
+                const waitedSecs = Math.round((Date.now() - waitStart) / 1000);
                 const head = remaining.length === 0
-                    ? `全部 ${wanted.size} 个子代理已收口：`
+                    ? pick(tLang, `全部 ${wanted.size} 个子代理已收口：`, `All ${wanted.size} subagent(s) collected:`, "subagents.wait.collected", { "wanted.size": wanted.size })
                     : signal?.aborted
-                        ? `本轮被中止，${remaining.length} 个仍在运行：`
-                        : `等待超过 ${Math.round(timeoutMs / 1000)}s 超时（实际等待 ${Math.round((Date.now() - waitStart) / 1000)}s），${remaining.length} 个仍在运行：`;
-                return text(`${head}\n${lines}\n` + promptRemaining(remaining));
+                        ? pick(tLang, `本轮被中止，${remaining.length} 个仍在运行：`, `This round was aborted, ${remaining.length} still running:`, "subagents.wait.aborted", { "remaining.length": remaining.length })
+                        : pick(tLang, `等待超过 ${timeoutSecs}s 超时（实际等待 ${waitedSecs}s），${remaining.length} 个仍在运行：`, `Wait timed out after ${timeoutSecs}s (actually waited ${waitedSecs}s), ${remaining.length} still running:`, "subagents.wait.timeout", { timeoutSecs: timeoutSecs, waitedSecs: waitedSecs, "remaining.length": remaining.length });
+                return text(`${head}\n${lines}\n` + promptRemaining(remaining, tLang));
             },
         }),
         defineTool({
             name: "subagent_templates",
             label: "List subagent templates",
-            description: "列出设置面板「子代理模板」配置的可用模板（角色系统提示词 + 技能/扩展白名单 + 可选模型 的组合预设），" +
-                "供 subagent_spawn 的 template 参数选用。已停用的模板不会出现在这里。list 为空 = 未配置模板，子代理按默认配置运行。",
+            description: bilingual("List the configurable subagent templates (role system prompt + skills/extensions whitelist + optional model " +
+                "presets) for the subagent_spawn template param. Disabled templates never appear here. " +
+                "Empty list = no templates configured; subagents run with defaults.", "列出设置面板「子代理模板」配置的可用模板（角色系统提示词 + 技能/扩展白名单 + 可选模型 的组合预设），" +
+                "供 subagent_spawn 的 template 参数选用。已停用的模板不会出现在这里。list 为空 = 未配置模板，子代理按默认配置运行。"),
             promptSnippet: "list configurable subagent templates (role prompt + skills/extensions whitelist presets)",
             parameters: Type.Object({}),
             execute: async () => {
                 const list = host.listTemplates();
+                const tLang = getLang();
                 if (list.length === 0) {
-                    return text("当前没有可用的子代理模板（设置面板 → 子代理模板 添加后可用）。子代理默认按主会话配置运行。");
+                    return text(pick(tLang, "当前没有可用的子代理模板（设置面板 → 子代理模板 添加后可用）。子代理默认按主会话配置运行。", "No subagent templates available (add some under Settings → Subagent Templates). Subagents run with the main session defaults.", "subagents.templates.empty"));
                 }
-                const lines = list.map((t) => `- ${t.name}${t.description ? `：${t.description}` : ""}` +
-                    (t.model ? `（模型：${t.model}）` : "（跟随主对话模型）"));
-                return text(`可用的子代理模板（subagent_spawn 的 template 参数传名字，如 subagent_spawn(template="${list[0]?.name}"))：\n${lines.join("\n")}`);
+                const lines = list.map((t) => {
+                    const desc = tLang === "zh" ? t.description : t.descriptionEn || t.description;
+                    return ((tLang === "zh" ? `- ${t.name}${desc ? `：${desc}` : ""}` : `- ${t.name}${desc ? `: ${desc}` : ""}`) +
+                        (tLang === "zh"
+                            ? t.model
+                                ? `（模型：${t.model}）`
+                                : "（跟随主对话模型）"
+                            : t.model
+                                ? ` (model: ${t.model})`
+                                : " (follows the main conversation model)"));
+                });
+                const firstTemplateName = list[0]?.name;
+                const templateLines = lines.join("\n");
+                return text(pick(getLang(), `可用的子代理模板（subagent_spawn 的 template 参数传名字，如 subagent_spawn(template="${firstTemplateName}"))：\n${templateLines}`, `Available subagent templates (pass the name as subagent_spawn's template param, e.g. subagent_spawn(template="${firstTemplateName}")):\n${templateLines}`, "subagents.templates.list", { firstTemplateName: firstTemplateName, templateLines: templateLines }));
             },
         }),
     ];
@@ -223,24 +321,27 @@ function shortId(id) {
     return id.slice(0, 8);
 }
 /** 人类可读的终态判定：报错 > 中止 > done > running。 */
-function subagentVerdict(r) {
+function subagentVerdict(r, lang = "en") {
     if (r.error)
-        return "error（报错）";
+        return pick(lang, "error（报错）", "error", "subagents.verdict.error");
     if (r.canceled)
-        return "canceled（已中止）";
+        return pick(lang, "canceled（已中止）", "canceled", "subagents.verdict.canceled");
     return r.state;
 }
 /** 终态的可读说明（错误文本 / 中止说明 / 空）。运行中返回空。 */
-function verdictText(r) {
+function verdictText(r, lang = "en") {
     if (r.error)
-        return `错误：${r.error}`;
+        return pick(lang, `错误：${r.error}`, `Error: ${r.error}`, "subagents.verdict.error.detail", {
+            "r.error": r.error,
+        });
     if (r.canceled)
-        return "（被中止，未产出结论）";
+        return pick(lang, "（被中止，未产出结论）", "(Aborted, no conclusion produced.)", "subagents.verdict.aborted");
     return "";
 }
 /** 未完成部分的引导文案。 */
-function promptRemaining(remaining) {
+function promptRemaining(remaining, lang = "en") {
     if (remaining.length === 0)
         return "";
-    return `\n未完成：${remaining.map(shortId).join(", ")}。可再次调用 subagent_wait_all（或 subagent_steer 补充指令 / subagent_stop 中止）。`;
+    const pendingIds = remaining.map(shortId).join(", ");
+    return pick(lang, `\n未完成：${pendingIds}。可再次调用 subagent_wait_all（或 subagent_steer 补充指令 / subagent_stop 中止）。`, `\nPending: ${pendingIds}. You may call subagent_wait_all again (or subagent_steer to add instructions / subagent_stop to abort).`, "subagents.wait.pending", { pendingIds: pendingIds });
 }

package/dist/server/tabs.js

@@ -0,0 +1,87 @@
+/**
+ * tabs — choose what an instance offers.
+ *
+ * pi-web-ui shows Chat, Terminal, Git, Search, Background tasks and Settings,
+ * always, plus a tab per installed plugin. On the machine you are working on
+ * that is the point of the tool. Exposed to other people it is not: Terminal
+ * opens a shell as the server's user, and Git shows the working copy with
+ * commit and diff a click away. Today there is no way to leave those out.
+ *
+ * `PI_WEB_TABS=chat,search,settings` is that way. Absent — the default —
+ * means every tab, so nothing changes for anybody who does not set it.
+ *
+ * The rule that shapes the whole thing: **a hidden tab whose messages the
+ * server still accepts is a hidden tab, not a disabled one.** Anything that
+ * can open the WebSocket can send `terminal_create`. So the client stops
+ * drawing them and the server stops answering them, and the second half is the
+ * one that matters.
+ *
+ * Chat is never off: it is the application.
+ */
+/** Every tab that can be listed. `chat` is always on and is listed for symmetry. */
+export const ALL_TABS = ["chat", "terminal", "git", "search", "tasks", "settings", "plugins"];
+/**
+ * The messages each tab owns exclusively.
+ *
+ * Only exclusive ones: `abort_bash` stops the agent's own bash tool inside a
+ * chat answer, not a terminal the user opened, so it is not listed — turning
+ * off the Terminal tab must not change what the agent can do in a conversation.
+ *
+ * `run_command` is listed under terminal because it starts a process in one:
+ * leaving it out would take the tab away and leave the shell reachable, which
+ * is exactly the failure this module exists to prevent.
+ */
+const OWNED = {
+    terminal: ["terminal_create", "terminal_input", "terminal_resize", "terminal_kill", "rename_terminal", "run_command"],
+    git: ["scm_status", "scm_history", "scm_filediff", "scm_commit"],
+    tasks: ["list_bg_servers", "kill_background_server", "kill_background_servers"],
+    search: ["search_files", "search_sessions"],
+};
+/**
+ * The allow-list, or null when there is none.
+ *
+ * Case and spaces are forgiven because this is written by hand in a systemd
+ * unit or a compose file. Unknown names are kept rather than rejected: a
+ * plugin tab, or a tab a later version adds, should not make the server fail
+ * to start.
+ */
+export function parseTabs(env = process.env) {
+    const raw = (env.PI_WEB_TABS ?? "").trim();
+    if (!raw)
+        return null;
+    const tabs = new Set(raw
+        .split(",")
+        .map((t) => t.trim().toLowerCase())
+        .filter(Boolean));
+    if (tabs.size === 0)
+        return null;
+    tabs.add("chat");
+    return tabs;
+}
+/** Whether a tab is offered. No list means every tab. */
+export function isTabAllowed(tab, tabs) {
+    if (!tabs)
+        return true;
+    if (tab === "chat")
+        return true;
+    return tabs.has(tab.toLowerCase());
+}
+/**
+ * The reason to refuse a message, or null when it may proceed.
+ *
+ * Returning the sentence rather than a boolean keeps the call site one line and
+ * puts the explanation next to the rule: the user sees why, instead of a
+ * message that vanishes.
+ */
+export function tabsRefusal(type, tabs) {
+    if (!tabs)
+        return null;
+    for (const [tab, messages] of Object.entries(OWNED)) {
+        if (!messages.includes(type))
+            continue;
+        if (isTabAllowed(tab, tabs))
+            return null;
+        return `The ${tab} tab is not enabled on this instance (PI_WEB_TABS).`;
+    }
+    return null;
+}