pi-web-ui 0.95.0 → 0.96.1

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

@@ -1,5 +1,5 @@
 /**
- * 悬空 toolCall 检测与修复（issue #280）。
+ * 悬空 toolCall 检测与修复（issue #280、issue #332）。
  *
  * 背景：流式中模型卡死 → 工具看门狗 abort 无效 → forceResetConversation
  * dispose 在飞运行时并从磁盘重建。内存里未落盘的工具结果静默蒸发，
@@ -7,9 +7,20 @@
  * 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；
- * - healDanglingToolCallFile：落盘版，文件尾追加合成 toolResult（append-only，不改历史字节）；
+ * - tailAssistantToolCallIds：沿当前分支回溯，定位尾部会上线的 assistant 的 toolCallId 集合；
+ * - healDanglingToolCallFile：落盘版，仅针对当前分支尾部生效的悬空调用追加合成 toolResult；
  * - 合成结果文案：DANGLING_TOOL_RESULT_TEXT（中英各一，toolResult content 只带一条文本）。
  */
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
@@ -22,6 +33,8 @@ function toolCallsOfMessage(msg) {
     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")
@@ -96,7 +109,58 @@ export function findDanglingToolCalls(messagesOrEntries) {
     return out;
 }
 /**
- * 落盘修复：向会话文件尾追加合成 toolResult（每条悬空调用一条），
+ * 沿当前分支从 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 = 文件不可读/不可写）。
  */
@@ -125,9 +189,12 @@ export function healDanglingToolCallFile(filePath) {
             // 脏行：SDK 加载时同样跳过，这里忽略。
         }
     }
-    if (entries.length === 0)
+    if (entries.length === 0 || !lastId)
+        return 0;
+    const tailIds = tailAssistantToolCallIds(entries, lastId);
+    if (tailIds.size === 0)
         return 0;
-    const dangling = findDanglingToolCalls(entries);
+    const dangling = findDanglingToolCalls(entries).filter((d) => tailIds.has(d.toolCallId));
     if (dangling.length === 0)
         return 0;
     try {

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) => {

package/dist/server/dsh/dsh-agent-service.js

@@ -29,7 +29,7 @@ import { basename, dirname, join, resolve, sep } from "node:path";
 import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { BgServerTracker } from "../bg-servers.js";
-import { ClientStateStore, DEFAULT_RETRY_MAX_ATTEMPTS, normalizeToolWatchdogTimeoutMs } from "../client-state.js";
+import { ClientStateStore, DEFAULT_RETRY_MAX_ATTEMPTS, normalizePathKey, normalizeToolWatchdogTimeoutMs, } from "../client-state.js";
 import { normalizeUiLayout } from "../client-state.js";
 import { FilesService, workspacePath, desktopDirWire } from "../files-service.js";
 import { QuiesceRejectedError } from "../agent-service.js";
@@ -368,6 +368,7 @@ export class DshClientSession {
             // 直播帧能力跟着运行时进程走：重启后重新探测（换运行时版本也能回落到持久 assistant/chunk）。
             conv.liveChunks = false;
         }
+        this.emitConversations();
         const now = Date.now();
         if (now - this.runtimeRestart.windowStart > DshClientSession.RUNTIME_RESTART_WINDOW_MS) {
             this.runtimeRestart.windowStart = now;
@@ -1135,6 +1136,7 @@ export class DshClientSession {
             conv.streaming = null;
             this.refreshConversationTitle(conv);
             this.scheduleSessionsRefresh();
+            this.emitConversations();
         }
         this.flushSnapshot();
     }
@@ -1416,8 +1418,10 @@ export class DshClientSession {
         if (active.messages.length === 0 && active.terminals.list().length === 0) {
             if (preset)
                 await this.selectAgentPreset(preset);
-            else
+            else {
+                this.pushSettings();
                 this.flushSnapshot();
+            }
             return true;
         }
         for (const conv of this.convs.values()) {
@@ -1451,6 +1455,7 @@ export class DshClientSession {
         this.emitConversations();
         this.emitGoalStatus();
         this.pushTerminals();
+        this.pushSettings();
         this.flushSnapshot();
         void this.refreshActivePermission().catch(() => { });
         return true;
@@ -1485,6 +1490,7 @@ export class DshClientSession {
         this.emitConversations();
         this.emitGoalStatus();
         this.pushTerminals();
+        this.pushSettings();
         this.flushSnapshot(true);
         // 切会话带上权限值（cwd 变化走运行时重启，onStarted 会重拉）。
         void this.refreshActivePermission().catch(() => { });
@@ -1865,6 +1871,7 @@ export class DshClientSession {
         const conv = this.conv;
         conv.isStreaming = false;
         conv.streaming = null;
+        this.emitConversations();
         // 手动停止 → 清当前会话的 DSH 原生目标（半成品运行不该继续被轮次驱动）。
         // 旧进程还活着，先 goal/clear 落盘，再重启运行时。
         if (conv.dsGoal || conv.goal.goal) {
@@ -2214,6 +2221,7 @@ export class DshClientSession {
             this.activeId = conv.id;
             this.emitConversations();
             this.pushTerminals();
+            this.pushSettings();
             this.flushSnapshot(true);
         }
         catch (err) {
@@ -2286,9 +2294,10 @@ export class DshClientSession {
     // -----------------------------------------------------------------------
     async pushProjects() {
         const saved = this.stateStore.get(this.clientId);
+        const removedKeys = new Set(this.stateStore.getRemovedProjects(this.clientId).map(normalizePathKey));
         const projects = new Map();
         for (const p of saved.projects ?? []) {
-            if (!(saved.removedProjects ?? []).includes(p.path)) {
+            if (!removedKeys.has(normalizePathKey(p.path))) {
                 projects.set(p.path, p.lastUsed);
             }
         }
@@ -2300,7 +2309,7 @@ export class DshClientSession {
             for (const e of entries) {
                 if (e.isDirectory()) {
                     const cwd = this.decodeProjectKey(e.name);
-                    if (cwd && !projects.has(cwd))
+                    if (cwd && !projects.has(cwd) && !removedKeys.has(normalizePathKey(cwd)))
                         cwdProjects.add(cwd);
                 }
             }
@@ -2310,7 +2319,9 @@ export class DshClientSession {
         }
         for (const cwd of cwdProjects)
             projects.set(cwd, Date.now());
-        projects.set(this.cwd, Date.now());
+        if (!removedKeys.has(normalizePathKey(this.cwd))) {
+            projects.set(this.cwd, Date.now());
+        }
         const list = [...projects.entries()]
             .map(([path, lastUsed]) => ({ path, lastUsed }))
             .sort((a, b) => b.lastUsed - a.lastUsed)
@@ -2888,6 +2899,7 @@ export class DshClientSession {
             }
             conv.agentPreset = res.preset ?? target;
             this.emitConversations();
+            this.pushSettings();
             this.flushSnapshot();
         }
         catch (err) {
@@ -3447,7 +3459,7 @@ export class DshClientSession {
             `# User's raw requirement`,
             draft,
             ``,
-            `Use the ask_user_question tool to ask the user focused questions to pin down the essential, ambiguous details. Ask ONE question at a time, usually 2 to 4 questions total: what exactly to build/do, scope boundaries (what NOT to do), acceptance criteria / done-definition, and any constraints (style, performance, environment). Prefer multiple-choice questions (options) when you can offer clear choices.`,
+            `Use the ask_user_question tool to ask the user focused questions to pin down the essential, ambiguous details. Ask ONE question at a time, strictly 1 to 3 questions total: what exactly to build/do, scope boundaries (what NOT to do), acceptance criteria / done-definition, and any constraints (style, performance, environment). Prefer 2 to 4 mutually exclusive options with the recommended choice placed FIRST, and explain the tradeoff in description.`,
             `Once you have enough to write an unambiguous, reviewable goal, STOP asking and reply with EXACTLY this format and nothing else (no preamble, no bullets):`,
             `GOAL: <one concrete, verifiable sentence describing the deliverable and its acceptance criteria>`,
             `Do NOT call create_goal or update_goal — just output the GOAL: line. If the user cancels or stops answering, still produce a sensible best-effort GOAL from what you already know.`,
@@ -4068,6 +4080,7 @@ export class DshClientSession {
             // 文件树跟随新项目（服务端原生 watcher 自动重挂）。
             void this.listFiles(undefined);
             this.pushTerminals();
+            this.pushSettings();
             this.flushSnapshot(true);
         }
         catch (err) {

package/dist/server/edit-soft-tool.js

@@ -26,24 +26,26 @@ import { homedir } from "node:os";
 import { isAbsolute, join, resolve as nodeResolve } from "node:path";
 import { Type } from "typebox";
 import { defineTool, generateDiffString, generateUnifiedPatch, withFileMutationQueue, } from "@earendil-works/pi-coding-agent";
-import { bilingual, pick } from "./i18n.js";
+import { pick } from "./i18n.js";
 import { EDIT_SOFT_TOOL_NAME } from "./tool-manager.js";
 /** 独立宽松编辑工具名（唯一登记见 tool-manager.ts；此处别名保兼容）。 */
 export const SOFT_EDIT_TOOL_NAME = EDIT_SOFT_TOOL_NAME;
 const replaceEditSchema = Type.Object({
     oldText: Type.String({
-        description: bilingual("Text to replace. Loose matching: the content of each non-empty line (trimmed of leading/trailing whitespace) must match the corresponding file lines; leading-indentation (spaces/tabs) differences are ignored. Prefer whole lines/blocks.", "要替换的文本。宽松匹配：每个非空行的内容（去掉首尾空白）需与文件中对应行一致；行首缩进（空格/制表符）的差异会被忽略。建议按整行/整块提供。"),
+        description: "Text to replace. Loose matching: the content of each non-empty line (trimmed of leading/trailing whitespace) must match the corresponding file lines; " +
+            "leading-indentation (spaces/tabs) differences are ignored. Prefer whole lines/blocks.",
     }),
     newText: Type.String({
-        description: bilingual("Replacement text (written verbatim; the indentation you provide is final).", "替换后的文本（原样写入，缩进即最终缩进）。"),
+        description: "Replacement text (written verbatim; the indentation you provide is final).",
     }),
 }, {});
 const editSoftSchema = Type.Object({
     path: Type.String({
-        description: bilingual("Path of the file to edit (relative or absolute).", "要编辑的文件路径（相对或绝对）"),
+        description: "Path of the file to edit (relative or absolute).",
     }),
     edits: Type.Array(replaceEditSchema, {
-        description: bilingual("One or more targeted replacements. Each edit matches against the original file (not incrementally); do not include overlapping/nested edits; merge edits touching the same block or nearby lines into one.", "一个或多个定向替换。每个 edit 相对原文件匹配（非增量）；不要包含重叠/嵌套的 edit；同一块或相邻行请合并成一个 edit。"),
+        description: "One or more targeted replacements. Each edit matches against the original file (not incrementally); " +
+            "do not include overlapping/nested edits; merge edits touching the same block or nearby lines into one.",
     }),
 }, {});
 function isSingleEditInput(value) {
@@ -302,13 +304,14 @@ export function makeEditSoftTool(fallbackCwd, getLang) {
     return defineTool({
         name: SOFT_EDIT_TOOL_NAME,
         label: "Edit (indentation-insensitive)",
-        description: bilingual("Edit a single file using text replacement that is tolerant of indentation. Every edits[].oldText is matched to the file by line content: leading whitespace (spaces/tabs) differences between your oldText and the file are ignored, so an edit does not fail just because the indentation differs. Use this when the built-in edit tool rejects your oldText due to a whitespace mismatch (common in JS/JSON/etc.). Prefer whole-line/whole-block oldText. newText is written exactly as provided.", "用对缩进不敏感的文本替换编辑单个文件。每个 edits[].oldText 按行内容与文件匹配：oldText 与文件之间的行首空白（空格/制表符）差异会被忽略，因此不会仅因缩进不同而失败。当内置 edit 工具因空白不匹配拒绝你的 oldText 时使用本工具（常见于 JS/JSON 等）。oldText 尽量按整行/整块提供。newText 按原样写入。"),
-        promptSnippet: bilingual("edit a file tolerating indentation differences (whitespace-insensitive match)", "编辑文件，容忍缩进差异（空白不敏感匹配）"),
+        description: "Edit a single file with text replacement tolerant of indentation: oldText is matched by line content, ignoring leading-whitespace differences, so edits don't fail on indentation mismatch. " +
+            "Use when the built-in edit rejects oldText due to whitespace (common in JS/JSON). Prefer whole-line/whole-block oldText; newText is written exactly as provided.",
+        promptSnippet: "edit a file tolerating indentation differences (whitespace-insensitive match)",
         promptGuidelines: [
-            bilingual("Use edit_soft when edit fails because the oldText indentation/spacing differs from the file", "当 edit 因 oldText 缩进/空白与文件不一致而失败时，使用 edit_soft"),
-            bilingual("Each edits[].oldText is matched to whole lines by trimmed content; leading whitespace is ignored", "每个 edits[].oldText 按去首尾空白后的内容匹配到整行；行首空白会被忽略"),
-            bilingual("newText is written verbatim — the indentation you provide is the final indentation in the file", "newText 按原样写入——你提供的缩进就是文件中的最终缩进"),
-            bilingual("Keep edits[].oldText as small as possible while still being unique; merge nearby changes into one edit", "edits[].oldText 在保持唯一的前提下尽量小；相邻改动合并为一个 edit"),
+            "Use edit_soft when edit fails because the oldText indentation/spacing differs from the file",
+            "Each edits[].oldText is matched to whole lines by trimmed content; leading whitespace is ignored",
+            "newText is written verbatim — the indentation you provide is the final indentation in the file",
+            "Keep edits[].oldText as small as possible while still being unique; " + "merge nearby changes into one edit",
         ],
         parameters: editSoftSchema,
         prepareArguments: prepareSoftEditArguments,