pi-web-ui 0.94.1 → 0.96.0

package/dist/server/control-socket.js

@@ -19,6 +19,28 @@
 import { createServer, createConnection } from "node:net";
 import { chmodSync, existsSync, rmSync } from "node:fs";
 import { join } from "node:path";
+/** 探测既有 socket 的超时：活实例对 connect 的响应是内核级的，300ms 足够。 */
+const CONTROL_PROBE_TIMEOUT_MS = 300;
+/** 控制路径探测：连得上（有活实例在 listen）→ null；失败 → errno
+ *  （ECONNREFUSED/ENOENT = 崩溃残留，可安全删除）。超时按「可能是活实例」
+ *  保守处理，返回超时码 —— 宁可不删残留也别摘掉正在服务的 socket。 */
+function probeControlPath(path) {
+    return new Promise((resolve) => {
+        const sock = createConnection(path);
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            sock.destroy();
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish("ETIMEDOUT"), CONTROL_PROBE_TIMEOUT_MS);
+        sock.once("connect", () => finish(null));
+        sock.once("error", (err) => finish(err.code ?? "EUNKNOWN"));
+    });
+}
 /** How long a control connection may sit idle before the server closes it. */
 const CONTROL_IDLE_TIMEOUT_MS = 5_000;
 /** How long the CLI waits for a reply before giving up. */
@@ -32,21 +54,45 @@ export function startControlServer(opts) {
     const { service, dataDir, port } = opts;
     const path = controlPath(dataDir, port);
     let server;
+    // 只有本实例真正 bind 成功才允许 stop 时删 socket 文件：探测发现活实例而
+    // listen 失败时，path 上是对方的 socket，删了会让后续客户端全部失联。
+    let bound = false;
     if (process.platform === "win32") {
+        // Windows named pipe 不落盘（最后一个句柄关闭即消失），不存在崩溃残留
+        // 文件可清理；撞上活实例时 listen 直接 EADDRINUSE，走下方统一 error
+        // 处理。无需探测。
         server = createServer(handleConnection);
+        server.listen(path, () => {
+            bound = true;
+            console.log(`  control    : ${path}`);
+        });
     }
     else {
-        // Remove a stale socket left by a previous crash (only if it's ours —
-        // an existing socket file that refuses connections is stale).
-        if (existsSync(path)) {
-            try {
-                rmSync(path);
-            }
-            catch {
-                /* best-effort */
-            }
-        }
         server = createServer(handleConnection);
+        // POSIX socket 文件崩溃后会残留，但先探测再删：无条件 rmSync 会把正在
+        // 服务的实例（比如被新的 pi-web 抢占前仍在跑的旧实例）的 socket 文件摘
+        // 走，新旧实例互相踩。只有连不上的残留（ECONNREFUSED/ENOENT）才删；
+        // 探测超时保守当作活实例，让 listen 自己以 EADDRINUSE 失败告警。
+        void probeControlPath(path).then((probeErr) => {
+            if (probeErr && existsSync(path)) {
+                try {
+                    rmSync(path);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            server.listen(path, () => {
+                bound = true;
+                try {
+                    chmodSync(path, 0o600);
+                }
+                catch {
+                    /* best-effort */
+                }
+                console.log(`  control    : ${path}`);
+            });
+        });
     }
     // A second instance on the same data dir / port would fail to bind — don't
     // crash the server over it, just log and run without a control socket.
@@ -105,27 +151,10 @@ export function startControlServer(opts) {
         });
         sock.on("close", () => clearTimeout(timer));
     }
-    if (process.platform === "win32") {
-        // net.Server on a named pipe: listen on the pipe name directly.
-        server.listen(path, () => {
-            console.log(`  control    : ${path}`);
-        });
-    }
-    else {
-        server.listen(path, () => {
-            try {
-                chmodSync(path, 0o600);
-            }
-            catch {
-                /* best-effort */
-            }
-            console.log(`  control    : ${path}`);
-        });
-    }
     return () => {
         server.close();
         try {
-            if (process.platform !== "win32" && existsSync(path))
+            if (process.platform !== "win32" && bound && existsSync(path))
                 rmSync(path);
         }
         catch {

package/dist/server/conversation-read-tool.js

@@ -16,12 +16,12 @@
 // 长对话分多次 offset 翻页。跨标签页的实时运行读不到——以落盘历史为准，
 // description 里会告诉模型这一点。
 //
-// 双语约定（issue #91）：definition 走 bilingual(en, zh) 内联双语；per-call
+// 文案约定：工具 definition（description/promptSnippet/promptGuidelines）为纯英文；per-call
 // 返回文本按 lang 取 pick(lang, zh, en, key, vars)，缺表回落英文内联。
 // ---------------------------------------------------------------------------
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { bilingual, pick } from "./i18n.js";
+import { pick } from "./i18n.js";
 import { CONVERSATION_READ_TOOL_NAME } from "./tool-manager.js";
 import { extractTouches, formatTouchEntry, formatTouchesCompact, toolCallRefsOfContent, unionTouchLists, } from "./conversation-touches.js";
 /** 由 content 块提 toolCalls 字段（additive；格式化输出不受影响，见接口注释）。 */
@@ -369,21 +369,11 @@ export function makeConversationReadTool(host, lang, extras) {
     return defineTool({
         name: CONVERSATION_READ_TOOL_NAME,
         label: "Read another conversation",
-        description: bilingual('Read ANOTHER conversation: a running conversation of this client (including subagents — use its conversation id like "c3", see action=list) or a persisted history session transcript (use its file path). ' +
-            'Use it when the user references another chat (a quoted conversation, a pasted conversation id, or "see the other chat about X"). ' +
-            "action=list shows running conversations plus history sessions (kind=running|history|all, query filter, limit; history defaults to 15). " +
-            'action=read returns one transcript: view=chat (default: only user/assistant text) or full (incl. tool calls/results); last=N takes the latest N messages instead of guessing offset; query searches within the conversation (hits ±1 context); each message is capped (~600 chars, marked "… +N chars"). ' +
-            "action=files lists files the conversation created/modified (with counts). " +
-            "action=status gives a short summary: last tool call, last assistant text, recently touched files, whether it is waiting for a question answer. " +
-            "Only sessions from the session list can be read (arbitrary file paths are refused). " +
-            "Live runs in OTHER browser tabs are not readable here — they appear in history once persisted.", "读取**另一个对话**：本客户端的运行中对话（含子代理——用 action=list 查 conversation id，如 c3）或已落盘的历史会话转录（用它的文件 path）。" +
-            "用户引用了别的对话（引用 chip、粘过来的对话 id、“看看之前那个关于 X 的对话”）时用它。" +
-            "action=list 列运行中对话与历史会话（kind=running|history|all，query 过滤，limit；历史默认 15 条）。" +
-            "action=read 取某一份转录：view=chat（默认：只给 user/assistant 文本）或 full（含工具调用与结果）；last=N 取最新 N 条（不用猜 offset）；query 在对话内搜索（命中 ±1 条上下文）；每条消息独立截断（约 600 字符，超出标 “… +N chars”）。" +
-            "action=files 列该对话创建/修改过的文件（含次数）。" +
-            "action=status 给一两行摘要：最后一次工具调用、最后一句 assistant、最近动过的文件、是否在等用户回答问卷。" +
-            "只能读会话列表里的转录（任意文件路径会被拒绝）。" +
-            "其他浏览器标签页里的实时运行在这里读不到——它们落盘后会出现在历史里。"),
+        description: "Read ANOTHER conversation: a running conversation of this client (incl. subagents — id from action=list) or a persisted history session (file path). " +
+            "Use when the user references another chat. list: running + history sessions (query filter, limit). " +
+            "read: one transcript — view=chat (default, user/assistant text) or full (incl. tool calls); last=N latest; query searches within (±1 context); messages capped ~600 chars. " +
+            "files: files it created/modified. status: last tool call, last assistant text, pending question. " +
+            "Only listed sessions are readable; other tabs' live runs appear in history once persisted.",
         promptSnippet: "read another conversation: list/find chats, read transcript (chat view / tail / search), touched files, status summary",
         parameters: Type.Object({
             action: Type.Optional(Type.String({

package/dist/server/dangling-tools.js

@@ -0,0 +1,229 @@
+/**
+ * 悬空 toolCall 检测与修复（issue #280、issue #332）。
+ *
+ * 背景：流式中模型卡死 → 工具看门狗 abort 无效 → forceResetConversation
+ * dispose 在飞运行时并从磁盘重建。内存里未落盘的工具结果静默蒸发，
+ * 会话文件尾留下一个「有调用、无结果」的悬空 toolCall；重建后继续
+ * prompt 会把非法转录链喂给 provider——请求有发起迹象但零落盘、零报错，
+ * 用户在往黑洞里打字。
+ *
+ * 缺陷与收紧（issue #332）：
+ * 不能将全文件所有找不到 toolResult 的调用一律视为悬空并追加合成结果：
+ * 1. 上线检查：若 assistant 的 stopReason 是 "error" 或 "aborted"，
+ *    pi 在发送给 provider 前会丢弃该 assistant（transformMessages）。
+ *    该调用属于永不上线的幽灵调用，补合成结果反而会构造出没有前置 tool_calls
+ *    的孤儿 role: "tool"，导致 provider 400（DeepSeek/OpenAI Responses 等）；
+ * 2. 分支检查：会话文件由树状结构追加存储，老分支被遗弃的 toolCall 不在当前分支上；
+ *    若在文件尾（当前活跃分支末尾）追加老分支调用的合成结果，也会制造孤儿 toolResult。
+ *    因此落盘修复必须沿当前活跃分支（lastId 开始回溯）定位尾部生效 assistant。
+ *
+ * 本模块：
+ * - findDanglingToolCalls：纯函数，消息/条目数组里找「有调用、无后继结果」的 toolCall；
+ * - tailAssistantToolCallIds：沿当前分支回溯，定位尾部会上线的 assistant 的 toolCallId 集合；
+ * - healDanglingToolCallFile：落盘版，仅针对当前分支尾部生效的悬空调用追加合成 toolResult；
+ * - 合成结果文案：DANGLING_TOOL_RESULT_TEXT（中英各一，toolResult content 只带一条文本）。
+ */
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+export const DANGLING_TOOL_RESULT_TEXT = "（系统：上一次运行被强制终止（工具执行超时/模型流卡死），该工具调用没有返回结果。为避免对话记录损坏，已自动填入一条合成结果。请根据需要重新执行该工具或继续对话。）";
+export const DANGLING_TOOL_RESULT_TEXT_EN = "(System: the previous run was force-terminated (tool timeout / hung model stream) and this tool call never returned. A synthetic result was inserted automatically to keep the transcript valid. Re-run the tool or continue as needed.)";
+function toolCallsOfMessage(msg) {
+    if (typeof msg !== "object" || msg === null)
+        return [];
+    const m = msg;
+    if (m.role !== "assistant" || !Array.isArray(m.content))
+        return [];
+    if (m.stopReason === "error" || m.stopReason === "aborted")
+        return [];
+    const out = [];
+    for (const b of m.content) {
+        if (typeof b !== "object" || b === null || b.type !== "toolCall")
+            continue;
+        const id = typeof b.id === "string" ? b.id : "";
+        if (!id)
+            continue;
+        const name = typeof b.name === "string" && b.name ? b.name : "unknown";
+        out.push({ toolCallId: id, toolName: name });
+    }
+    return out;
+}
+function toolResultIdsOfMessage(msg) {
+    const ids = new Set();
+    if (typeof msg !== "object" || msg === null)
+        return ids;
+    const m = msg;
+    if (m.role === "toolResult" && typeof m.toolCallId === "string")
+        ids.add(m.toolCallId);
+    // 兼容：个别版本把结果放在 content 块里。
+    if (Array.isArray(m.content)) {
+        for (const b of m.content) {
+            if (typeof b !== "object" || b === null)
+                continue;
+            if ((b.type === "toolResult" || b.type === "tool_result") && typeof b.toolCallId === "string") {
+                ids.add(b.toolCallId);
+            }
+        }
+    }
+    return ids;
+}
+function messagesOfEntries(entries) {
+    return entries.map((e) => {
+        if (typeof e === "object" && e !== null && "message" in e) {
+            const msg = e.message;
+            if (typeof msg === "object" && msg !== null && "role" in msg)
+                return msg;
+        }
+        return e;
+    });
+}
+/**
+ * 找悬空 toolCall：出现过调用、但之后没有任何 toolResult 与之配对的。
+ * 输入既可以是 Message[]（内存 agent.state.messages），也可以是
+ * SessionManager entry[]（带 { message } 包装的落盘条目）——统一按顺序扫。
+ */
+export function findDanglingToolCalls(messagesOrEntries) {
+    const messages = messagesOfEntries(messagesOrEntries);
+    const calls = [];
+    const results = new Map();
+    messages.forEach((msg, index) => {
+        for (const c of toolCallsOfMessage(msg))
+            calls.push({ call: c, index });
+        for (const id of toolResultIdsOfMessage(msg)) {
+            let arr = results.get(id);
+            if (!arr) {
+                arr = [];
+                results.set(id, arr);
+            }
+            arr.push(index);
+        }
+    });
+    const out = [];
+    const seen = new Set();
+    for (const { call, index } of calls) {
+        const later = (results.get(call.toolCallId) ?? []).some((ri) => ri > index);
+        if (!later && !seen.has(call.toolCallId)) {
+            seen.add(call.toolCallId);
+            out.push(call);
+        }
+    }
+    return out;
+}
+/**
+ * 沿当前分支从 lastId 往前回溯，定位当前分支尾部生效 assistant 的 toolCallId 集合（issue #332）。
+ *
+ * 两个守卫条件：
+ * 1. 分支检查：严格沿 parentId 链回溯，老分支（不在当前分支路径上）的条目绝不纳入，
+ *    避免在当前分支尾部追加针对老分支调用的合成结果而制造孤儿 toolResult；
+ * 2. 上线检查：若遇到的 assistant 是 stopReason: "error" | "aborted"，
+ *    说明该 assistant 已被中断/报错，pi 在发送给模型前会直接跳过丢弃它（transformMessages），
+ *    其 toolCall 属于绝不上线的幽灵调用，必须跳过且绝不能为其补结果。
+ *
+ * 此外，若在回溯中遇到了 user 消息，说明当前尾部已经退出该回合（例如最新是 user 消息），
+ * 绝不能跨过 user 消息去为更早的 assistant 补 toolResult，应立即停止。
+ */
+export function tailAssistantToolCallIds(entries, lastId) {
+    if (!lastId)
+        return new Set();
+    const byId = new Map();
+    for (const e of entries) {
+        if (typeof e === "object" && e !== null && typeof e.id === "string") {
+            byId.set(e.id, e);
+        }
+    }
+    const seen = new Set();
+    let cursor = lastId;
+    while (cursor && !seen.has(cursor)) {
+        seen.add(cursor);
+        const entry = byId.get(cursor);
+        if (!entry || typeof entry !== "object")
+            break;
+        const msg = "message" in entry && typeof entry.message === "object"
+            ? entry.message
+            : null;
+        if (msg && typeof msg === "object" && "role" in msg) {
+            const m = msg;
+            if (m.role === "user") {
+                // 跨入更早的用户回合，尾部无正在等待结果的 assistant
+                break;
+            }
+            if (m.role === "assistant") {
+                if (m.stopReason !== "error" && m.stopReason !== "aborted") {
+                    return new Set(toolCallsOfMessage(m).map((c) => c.toolCallId));
+                }
+                // 尾部最新 assistant 处于 aborted/error 状态，幽灵调用不上线；且不可越过它去修更早回合
+                break;
+            }
+        }
+        cursor =
+            typeof entry.parentId === "string" ? entry.parentId : null;
+    }
+    return new Set();
+}
+/**
+ * 落盘修复：向会话文件尾追加合成 toolResult（仅针对当前分支尾部生效的悬空调用），
+ * parentId 链式接在当前尾行之后。append-only——历史字节不动，无需备份。
+ * 返回追加条数（0 = 健康，无需处理；-1 = 文件不可读/不可写）。
+ */
+export function healDanglingToolCallFile(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf8");
+    }
+    catch {
+        return -1;
+    }
+    const lines = raw.split("\n");
+    const entries = [];
+    let lastId = null;
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            entries.push(parsed);
+            if (typeof parsed === "object" && parsed !== null && typeof parsed.id === "string") {
+                lastId = parsed.id;
+            }
+        }
+        catch {
+            // 脏行：SDK 加载时同样跳过，这里忽略。
+        }
+    }
+    if (entries.length === 0 || !lastId)
+        return 0;
+    const tailIds = tailAssistantToolCallIds(entries, lastId);
+    if (tailIds.size === 0)
+        return 0;
+    const dangling = findDanglingToolCalls(entries).filter((d) => tailIds.has(d.toolCallId));
+    if (dangling.length === 0)
+        return 0;
+    try {
+        let parentId = lastId;
+        for (const d of dangling) {
+            const id = `synthetic-tool-result-${randomUUID().slice(0, 8)}`;
+            const entry = {
+                type: "message",
+                id,
+                parentId,
+                timestamp: new Date().toISOString(),
+                message: {
+                    role: "toolResult",
+                    toolCallId: d.toolCallId,
+                    toolName: d.toolName,
+                    content: [{ type: "text", text: `${DANGLING_TOOL_RESULT_TEXT}\n${DANGLING_TOOL_RESULT_TEXT_EN}` }],
+                    isError: true,
+                    timestamp: Date.now(),
+                },
+            };
+            const line = JSON.stringify(entry);
+            if (!existsSync(filePath))
+                return -1;
+            appendFileSync(filePath, `${line}\n`, "utf8");
+            parentId = id;
+        }
+        return dangling.length;
+    }
+    catch {
+        return -1;
+    }
+}

package/dist/server/delegate-task.js

@@ -16,7 +16,7 @@
  */
 import { Type } from "typebox";
 import { defineTool } from "@earendil-works/pi-coding-agent";
-import { bilingual, pick } from "./i18n.js";
+import { pick } from "./i18n.js";
 import { DELEGATE_TASK_TOOL_NAME } from "./tool-manager.js";
 import { subagentTitle } from "./subagents.js";
 /** 工具名（唯一值在 tool-manager.ts；本别名保留：前端派单卡片与旧导入沿用它）。 */
@@ -101,33 +101,35 @@ export function buildDelegationPrompt(input, lang = "en") {
 }
 const delegateSchema = Type.Object({
     agent: Type.String({
-        description: bilingual("Specialist template to delegate to (e.g. oracle, metis, momus, explore, librarian, sisyphus-junior, multimodal-looker, review). Must be an enabled template — use subagent_templates to see descriptions and pick the domain match.", "派单的目标 specialist 模板（如 oracle、metis、momus、explore、librarian、sisyphus-junior、multimodal-looker、review）。必须是启用的模板——先用 subagent_templates 看简介、按任务领域匹配。"),
+        description: "Specialist template to delegate to (e.g. oracle, metis, momus, explore, librarian, sisyphus-junior, multimodal-looker, review). " +
+            "Must be an enabled template — use subagent_templates to see descriptions and pick the domain match.",
     }),
     task: Type.String({
-        description: bilingual("Atomic, specific goal: ONE action per delegation (minimum 20 chars). Vague tasks are rejected.", "原子化具体目标：一次派单只做一件事（至少 20 字）。含糊的任务会被驳回。"),
+        description: "Atomic, specific goal: ONE action per delegation (minimum 20 chars). Vague tasks are rejected.",
     }),
     expected_outcome: Type.String({
-        description: bilingual("Concrete deliverables with done criteria: what does success look like (minimum 10 chars).", "具体交付物 + 完成标准：什么样算做完（至少 10 字）。"),
+        description: "Concrete deliverables with done criteria: what does success look like (minimum 10 chars).",
     }),
     required_tools: Type.String({
-        description: bilingual("Explicit tool whitelist for the subagent (prevents tool sprawl).", "子代理可用工具白名单（防工具乱用）。"),
+        description: "Explicit tool whitelist for the subagent (prevents tool sprawl).",
     }),
     must_do: Type.String({
-        description: bilingual("Exhaustive requirements — leave NOTHING implicit.", "必须做的要求——写尽，不要留隐含项。"),
+        description: "Exhaustive requirements — leave NOTHING implicit.",
     }),
     must_not_do: Type.String({
-        description: bilingual("Forbidden actions — anticipate and block rogue behavior.", "禁止事项——预判并堵住乱发挥。"),
+        description: "Forbidden actions — anticipate and block rogue behavior.",
     }),
     context: Type.String({
-        description: bilingual("File paths, existing patterns, constraints the subagent must know.", "子代理必须知道的文件路径、既有模式、约束。"),
+        description: "File paths, existing patterns, constraints the subagent must know.",
     }),
     model: Type.Optional(Type.String({
-        description: bilingual('Optional model "provider/id" for this delegation; omit = template model → panel default → follow the main conversation model.', "可选：本次派单的子代理模型（provider/id）；不传 = 模板模型 → 面板默认 → 跟随主对话模型。"),
+        description: 'Optional model "provider/id" for this delegation; ' +
+            "omit = template model → panel default → follow the main conversation model.",
     })),
     persist: Type.Optional(Type.Boolean({
-        description: bilingual("Optional: persist this conversation to disk as a regular session (saved in history, resumable). " +
-            "Default false (lightweight in-memory subagent). Use true for tasks that need long-term retention.", "可选：是否将该对话持久化落盘为普通对话（保存在历史会话中，可随时回顾与继续）。" +
-            "默认 false（轻量内存子代理）。需要长期留存的任务建议设为 true。"),
+        description: "Optional: persist this conversation to disk as a regular session (saved in history, resumable). " +
+            "Default false (lightweight in-memory subagent). " +
+            "Use true for tasks that need long-term retention.",
     })),
 });
 /** 结构化派单工具：校验六段 → 拼装标准 prompt → 走 host.spawnSubagent 真子代理。 */
@@ -140,23 +142,18 @@ export function makeDelegateTaskTool(host, lang) {
     return defineTool({
         name: DELEGATE_TOOL_NAME,
         label: "Delegate task",
-        description: bilingual("Delegate ONE well-defined task to a specialist subagent template with a structured six-section brief " +
-            "(TASK / EXPECTED OUTCOME / REQUIRED TOOLS / MUST DO / MUST NOT DO / CONTEXT). The brief is validated " +
-            "server-side: missing or vague sections are rejected with an error, so fill every section concretely. " +
-            "Prefer this over subagent_spawn when the work fits a specialist template. The delegation spawns a real " +
-            "subagent conversation (visible in the left running list); use subagent_wait_all / subagent_get_result to " +
-            "collect results, subagent_steer to redirect, subagent_stop to stop. For follow-ups continue the SAME " +
-            "subagent session instead of delegating again.", "把一个定义清楚的任务派给 specialist 子代理模板，派单文本是结构化六段 " +
-            "（TASK / EXPECTED OUTCOME / REQUIRED TOOLS / MUST DO / MUST NOT DO / CONTEXT）。六段在服务端校验：" +
-            "缺段或含糊直接报错打回，所以每段都要写实在。任务适合 specialist 模板时优先用它而不是 subagent_spawn。" +
-            "派单会启动真实子代理会话（左栏运行列表可见）；用 subagent_wait_all / subagent_get_result 收结果、" +
-            "subagent_steer 改向、subagent_stop 停止。追问要在同一子代理会话里继续，不要重复派单。"),
-        promptSnippet: bilingual("Delegate a well-defined task to a specialist template with a validated six-section brief", "把定义清楚的任务派给 specialist 模板，六段派单文本带服务端校验"),
+        description: "Delegate ONE well-defined task to a specialist subagent template via a structured six-section brief (TASK / EXPECTED OUTCOME / REQUIRED TOOLS / MUST DO / MUST NOT DO / CONTEXT). " +
+            "The brief is validated server-side — missing or vague sections are rejected, so fill every section concretely. " +
+            "Prefer over subagent_spawn when the work fits a specialist template. Spawns a real subagent conversation; " +
+            "collect with subagent_wait_all / subagent_get_result, redirect with subagent_steer, stop with subagent_stop. " +
+            "For follow-ups continue the SAME subagent session instead of delegating again.",
+        promptSnippet: "Delegate a well-defined task to a specialist template with a validated six-section brief",
         promptGuidelines: [
-            bilingual("Prefer delegate_task over subagent_spawn when the work matches a specialist template's domain", "任务落在 specialist 模板领域内时，优先用 delegate_task 而不是 subagent_spawn"),
-            bilingual("Before delegating, declare which template you chose and WHY its description matches the task", "派单前先声明选了哪个模板、它的简介与任务哪里匹配"),
-            bilingual("After delegation ALWAYS verify the result: does it work, does it follow codebase patterns, did it respect MUST DO / MUST NOT DO", "拿到派单结果必须验证：能跑吗、符合代码库模式吗、遵守 MUST DO / MUST NOT DO 了吗"),
-            bilingual("Never start implementing work that a pending delegated result was asked to decide", "已派出去待定的结论回来之前，不准先把相关的实现写了"),
+            "Prefer delegate_task over subagent_spawn when the work matches a specialist template's domain",
+            "Before delegating, declare which template you chose and WHY its description matches the task",
+            "After delegation ALWAYS verify the result: " +
+                "does it work, does it follow codebase patterns, did it respect MUST DO / MUST NOT DO",
+            "Never start implementing work that a pending delegated result was asked to decide",
         ],
         parameters: delegateSchema,
         execute: async (_id, params, _signal, _onUpdate, ctx) => {