pi-web-ui 0.19.2 → 0.20.1

package/dist/server/agent-service.js

@@ -14,7 +14,7 @@ import { spawn } from "node:child_process";
 import { existsSync, readFileSync, statSync, writeFileSync, mkdirSync, watch, } from "node:fs";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, defineTool, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashTool, createLocalBashOperations, defineTool, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { serializeMessage, serializeStreamingMessage, } from "./serialize.js";
 import { loadCommands, saveCommandsFile, TerminalManager, } from "./terminals.js";
@@ -218,10 +218,122 @@ function decodeText(buf) {
         }
     }
 }
-/** Windows persona appendix: legacy Chinese files are often GBK/GB2312 — read
- *  them via the terminal with the right encoding, never paste mojibake into
- *  reasoning/answers. Appended to the SDK system prompt on win32 only. */
-const WINDOWS_GBK_PERSONA = `You are a coding agent running on Windows. Many legacy Chinese text files (.html/.txt/.md/.log, exported documents) are GBK/GB2312 encoded: the read tool decodes UTF-8 only and will show mojibake (乱码) for them. If a file's content looks garbled, read it through the terminal instead: in Git Bash use \`cat file | iconv -f GBK -t UTF-8\` (or \`iconv -f GBK -t UTF-8 file\`); in cmd use \`chcp 65001 && type file\`; in PowerShell use \`Get-Content -Encoding Default file\`. Never paste mojibake into your reasoning or answer — describe the decoded content instead.`;
+/** Windows persona appendix — appended to the SDK system prompt on win32 only.
+ *  Two failure modes it guards against: (1) the SDK bash tool has NO default
+ *  timeout, so a long-running command hangs the whole conversation forever;
+ *  (2) the in-app terminal is an interactive TTY where heredocs / interactive
+ *  programs wait for input that never comes. Legacy Chinese files are often
+ *  GBK/GB2312 — read them with the right encoding, never paste mojibake into
+ *  reasoning/answers. */
+const WINDOWS_PERSONA = `You are a coding agent running on Windows. The bash tool runs Git Bash (bash.exe), not PowerShell. Follow these rules to avoid hanging the session:
+
+
+
+- ALWAYS pass a timeout parameter to the bash tool (in seconds). There is NO default timeout — a command that never finishes (servers, watchers, infinite loops, slow downloads/installs) will hang the entire conversation indefinitely. Pick a generous timeout for long-running work, but never omit it.
+- NEVER run interactive or foreground long-running commands through the bash tool (vi, less, top, python -, node -, npm run dev, sleep 10000). For servers/daemons use background execution with output redirected to a log file, then poll the log; stop them when done.
+- In the interactive terminal (TTY) — which is Git Bash too, not PowerShell — NEVER use heredocs (<<'EOF' ... EOF) or here-strings, and NEVER start interactive programs (vi, less, python -, node -, npm init): they wait for keyboard input that never arrives and hang the terminal forever. Prefer writing a temp script file (e.g. .pi-tmp.sh) and running it non-interactively. ALWAYS pass a timeout to long-running commands (e.g. \`timeout 120 npm run dev\`).
+
+Many legacy Chinese text files (.html/.txt/.md/.log, exported documents) are GBK/GB2312 encoded: the read tool decodes UTF-8 only and will show mojibake (乱码) for them. If a file's content looks garbled, read it through the terminal instead: in Git Bash use \`cat file | iconv -f GBK -t UTF-8\` (or \`iconv -f GBK -t UTF-8 file\`); in cmd use \`chcp 65001 && type file\`; in PowerShell use \`Get-Content -Encoding Default file\`. Never paste mojibake into your reasoning or answer — describe the decoded content instead.`;
+/**
+ * Killable bash tool: wraps the SDK bash tool with operations that register
+ * their own AbortController into a client-level set. abortBash() aborts only
+ * those controllers → the command's process tree is killed while the agent
+ * run and the conversation continue (the tool returns an aborted error and
+ * the model moves on). Injected as a customTool overriding the builtin bash.
+ */
+function makeKillableBashTool(cwd, kills) {
+    const base = createLocalBashOperations();
+    const tool = createBashTool(cwd, {
+        operations: {
+            exec: async (command, c, opts) => {
+                const ac = new AbortController();
+                kills.add(ac);
+                try {
+                    const signals = [opts.signal, ac.signal].filter((s) => s !== undefined);
+                    return await base.exec(command, c, {
+                        ...opts,
+                        signal: signals.length > 1 ? AbortSignal.any(signals) : signals[0],
+                    });
+                }
+                finally {
+                    kills.delete(ac);
+                }
+            },
+        },
+    });
+    // AgentTool → ToolDefinition (same fields; customTools expects definitions).
+    return {
+        name: tool.name,
+        label: tool.label,
+        description: tool.description,
+        parameters: tool.parameters,
+        prepareArguments: tool.prepareArguments,
+        executionMode: tool.executionMode,
+        execute: (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate),
+    };
+}
+/**
+ * Snapshot currently LISTENING TCP ports → owning pid. Windows: netstat;
+ * POSIX: lsof. Used to detect servers the agent started in the background
+ * (the bash tool itself exits, leaving e.g. `npm run dev &` listening).
+ */
+async function snapshotListeningPorts() {
+    const m = new Map();
+    try {
+        const { execFile } = await import("node:child_process");
+        if (process.platform === "win32") {
+            const out = await new Promise((resolve, reject) => execFile("netstat", ["-ano", "-p", "tcp"], { windowsHide: true, timeout: 8000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            for (const line of out.split(/\r?\n/)) {
+                const p = line.trim().split(/\s+/);
+                // TCP 0.0.0.0:5173 0.0.0.0:0 LISTENING 12345
+                if (p.length >= 5 && p[0] === "TCP" && p[3] === "LISTENING") {
+                    const port = Number(p[1].split(":").pop());
+                    const pid = Number(p[4]);
+                    if (Number.isFinite(port) && Number.isFinite(pid))
+                        m.set(port, pid);
+                }
+            }
+        }
+        else {
+            const out = await new Promise((resolve, reject) => execFile("lsof", ["-iTCP", "-sTCP:LISTEN", "-P", "-n"], { timeout: 8000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            for (const line of out.split(/\r?\n/).slice(1)) {
+                const p = line.trim().split(/\s+/);
+                if (p.length >= 9) {
+                    // NAME column tail: "*:5173 (LISTEN)" or "[::1]:5173 (LISTEN)"
+                    const mm = (p[p.length - 1] ?? "").match(/(\d+)\)?\s*$/);
+                    const port = mm ? Number(mm[1]) : NaN;
+                    const pid = Number(p[1]);
+                    if (Number.isFinite(port) && Number.isFinite(pid))
+                        m.set(port, pid);
+                }
+            }
+        }
+    }
+    catch {
+        // best effort — snapshot failure just means no tracking this round
+    }
+    return m;
+}
+/** Kill a pid and its whole process tree (cross-platform). */
+function killPidTree(pid) {
+    try {
+        if (process.platform === "win32") {
+            void import("node:child_process").then(({ spawn }) => {
+                spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+                    stdio: "ignore",
+                    detached: true,
+                    windowsHide: true,
+                }).unref();
+            });
+        }
+        else {
+            process.kill(-pid, "SIGKILL");
+        }
+    }
+    catch {
+        // already dead
+    }
+}
 /**
  * Cheap per-message discriminator for the serialization cache key. Persisted
  * message content never changes, so this is stable across snapshots, while
@@ -709,6 +821,15 @@ class ClientStateStore {
         this.save();
     }
 }
+/** Hard cap on how long ONE tool call may run before the watchdog aborts the
+ *  session. The SDK bash tool has NO default timeout, so a command that never
+ *  finishes (servers, watchers, infinite loops) would otherwise hang the whole
+ *  conversation indefinitely. Override with the PI_WEB_TOOL_TIMEOUT_MS env var
+ *  (milliseconds). */
+const TOOL_WATCHDOG_TIMEOUT_MS = (() => {
+    const v = Number(process.env.PI_WEB_TOOL_TIMEOUT_MS);
+    return Number.isFinite(v) && v > 0 ? v : 20 * 60_000;
+})();
 /** Cap on simultaneously open conversations of ONE project (each keeps a full
  *  runtime alive; conversations of other projects keep their own lists). */
 const MAX_OPEN_CONVERSATIONS = 8;
@@ -808,6 +929,23 @@ export class ClientSession {
     static WIZARD_IDLE_TIMEOUT_MS = 5 * 60_000;
     /** Absolute deadline for the whole wizard session (model latency guard). */
     static WIZARD_MAX_TOTAL_MS = 20 * 60_000;
+    /** How long a hard abort waits for session.abort() to make the run idle
+     *  before force-resetting the conversation (model streams that ignore the
+     *  abort signal would otherwise leave the chat stuck forever). */
+    static HARD_ABORT_TIMEOUT_MS = 15_000;
+    /** Extra settle window after session.abort() returns: the run is only
+     *  considered stopped once its agent_end event arrives. If it doesn't
+     *  (model stream stuck before the run even started), force-reset. */
+    static HARD_ABORT_SETTLE_MS = 8_000;
+    /** Live AbortControllers of THIS client's running bash tool calls — aborting
+     *  them kills only the command (agent run and conversation continue). */
+    bashKills = new Set();
+    /** LISTENING-port snapshot taken when the current bash tool started — the
+     *  end-of-execution diff reveals servers the agent left running in the
+     *  background (e.g. `npm run dev &`). Keyed by port → pid. */
+    bashListenBefore = null;
+    /** Background servers the agent started (port → pid). 「中断」kills them. */
+    bgServers = new Map();
     /** The active conversation (all session operations target it). */
     get conv() {
         const conv = this.convs.get(this.activeId);
@@ -904,17 +1042,26 @@ export class ClientSession {
                 modelRuntime: this.sharedModelRuntime,
                 ...(process.platform === "win32"
                     ? {
-                        // Windows 上很多老中文文件（.html/.txt/.md/.log、导出文档）是
-                        // GBK/GB2312 编码，read 工具按 UTF-8 读会乱码——注入 persona 让模型
-                        // 改用终端按 GBK 读，且绝不把乱码贴进推理/回答。
+                        // Windows 专属 persona：bash 工具跑 Git Bash 且无默认超时、终端是
+                        // 交互式 TTY——注入约束避免 heredoc/交互/长驻命令挂死整个会话；
+                        // GBK 老中文文件让模型改用终端按正确编码读（iconv/chcp/Get-Content）。
                         resourceLoaderOptions: {
-                            systemPromptOverride: (base) => base ? `${base}\n\n${WINDOWS_GBK_PERSONA}` : WINDOWS_GBK_PERSONA,
+                            systemPromptOverride: (base) => base ? `${base}\n\n${WINDOWS_PERSONA}` : WINDOWS_PERSONA,
                         },
                     }
                     : {}),
             });
             return {
-                ...(await createAgentSessionFromServices({ services, sessionManager })),
+                ...(await createAgentSessionFromServices({
+                    services,
+                    sessionManager,
+                    // 可手动停止的 bash 工具：覆盖 SDK 内置 bash（customTools 按 name
+                    // 覆盖），执行时把自己的 AbortController 注册进客户端集合——
+                    // abortBash() 只杀这些命令，agent run 与对话继续。
+                    customTools: [
+                        makeKillableBashTool(effectiveCwd, this.bashKills),
+                    ],
+                })),
                 services,
                 diagnostics: services.diagnostics,
             };
@@ -943,6 +1090,7 @@ export class ClientSession {
             queueSteering: 0,
             queueFollowUp: 0,
             toolStartTimes: new Map(),
+            toolWatchdogs: new Map(),
         };
     }
     /** Add a socket to this client's broadcast set; flushes buffered startup notices. */
@@ -1013,6 +1161,44 @@ export class ClientSession {
                 this.webUi.refresh();
         }, WIDGET_REFRESH_MS);
     }
+    /** Arm the hang-guard for a tool call: if it is still running after
+     *  TOOL_WATCHDOG_TIMEOUT_MS, abort the session instead of letting the
+     *  conversation hang forever (the SDK bash tool has no default timeout). */
+    armToolWatchdog(conv, toolCallId) {
+        const t = setTimeout(() => {
+            conv.toolWatchdogs.delete(toolCallId);
+            // The tool finished before the deadline — nothing to do.
+            if (!conv.toolStartTimes.has(toolCallId))
+                return;
+            this.emit({
+                type: "notice",
+                level: "warning",
+                text: `工具执行超过 ${Math.round(TOOL_WATCHDOG_TIMEOUT_MS / 60_000)} 分钟，已自动终止（防止挂死）。可调整超时：环境变量 PI_WEB_TOOL_TIMEOUT_MS（毫秒）。`,
+            });
+            conv.toolStartTimes.delete(toolCallId);
+            // Abort the run (kills the process tree via the SDK's abort signal);
+            // agent_end will fire with stopReason "aborted" and existing logic
+            // clears any goal / review loop. interruptRun adds a force-reset
+            // fallback in case the model stream ignores the abort signal.
+            void this.interruptRun(conv, "工具执行超时");
+        }, TOOL_WATCHDOG_TIMEOUT_MS);
+        t.unref?.();
+        conv.toolWatchdogs.set(toolCallId, t);
+    }
+    /** Cancel a tool's watchdog — called when the tool finishes normally. */
+    clearToolWatchdog(conv, toolCallId) {
+        const t = conv.toolWatchdogs.get(toolCallId);
+        if (t) {
+            clearTimeout(t);
+            conv.toolWatchdogs.delete(toolCallId);
+        }
+    }
+    /** Cancel every watchdog of a conversation (removeConversation / dispose). */
+    clearAllToolWatchdogs(conv) {
+        for (const t of conv.toolWatchdogs.values())
+            clearTimeout(t);
+        conv.toolWatchdogs.clear();
+    }
     onEvent(conv, event) {
         switch (event.type) {
             case "bash_execution_update": {
@@ -1030,11 +1216,24 @@ export class ClientSession {
                 // Record the moment the tool actually starts so tool_status can
                 // report real execution time (vs. time spent waiting on the model).
                 conv.toolStartTimes.set(event.toolCallId, Date.now());
+                // Snapshot listeners before a bash run — the post-run diff catches
+                // servers the agent started in the background.
+                if (event.toolName === "bash") {
+                    void snapshotListeningPorts().then((m) => {
+                        this.bashListenBefore = m;
+                    });
+                }
+                this.armToolWatchdog(conv, event.toolCallId);
                 break;
             }
             case "tool_execution_end": {
                 const startedAt = conv.toolStartTimes.get(event.toolCallId);
                 conv.toolStartTimes.delete(event.toolCallId);
+                this.clearToolWatchdog(conv, event.toolCallId);
+                // Bash finished — wait briefly for background servers to bind their
+                // ports, then diff against the pre-run snapshot and record them.
+                if (event.toolName === "bash")
+                    void this.trackBackgroundServers();
                 const durationMs = startedAt !== undefined ? Date.now() - startedAt : undefined;
                 // The bash tool does not put its exit code in result.details — on
                 // failure it throws "Command exited with code N" and the agent
@@ -1366,6 +1565,8 @@ export class ClientSession {
      * the process is going to restart itself (so the notice can say so).
      */
     onUpdateReady = undefined;
+    /** Set by index.ts: called when /pi-web-ui:quit is invoked. */
+    onQuit = undefined;
     /** Ask the npm registry for the latest pi-web-ui version and report it. */
     async checkUpdate() {
         const current = ClientSession.currentAppVersion();
@@ -1839,19 +2040,22 @@ export class ClientSession {
      * (they never reach the server) but stay listed so the picker shows them.
      */
     static NATIVE_COMMANDS = [
-        { name: "new", description: "新建对话" },
-        { name: "model", description: "切换模型", argumentHint: "[名称]" },
-        { name: "compact", description: "压缩上下文", argumentHint: "[说明]" },
-        { name: "cwd", description: "切换工作目录", argumentHint: "<路径>" },
+        { name: "new", description: "新建对话", descriptionEn: "New chat" },
+        { name: "model", description: "切换模型", descriptionEn: "Switch model", argumentHint: "[名称]", argumentHintEn: "[name]" },
+        { name: "compact", description: "压缩上下文", descriptionEn: "Compact context", argumentHint: "[说明]", argumentHintEn: "[instructions]" },
+        { name: "cwd", description: "切换工作目录", descriptionEn: "Switch workspace", argumentHint: "<路径>", argumentHintEn: "<path>" },
         {
             name: "thinking",
             description: "设置思考强度",
-            argumentHint: "<off|low|medium|high>",
+            descriptionEn: "Set thinking level",
+            argumentHint: "<off|low|medium|high|xhigh|max>",
+            argumentHintEn: "<off|low|medium|high|xhigh|max>",
         },
-        { name: "resume", description: "刷新会话列表" },
-        { name: "reload", description: "重新加载扩展、技能与模板" },
-        { name: "help", description: "显示全部命令" },
-        { name: "copy", description: "复制上一条助手回复" },
+        { name: "resume", description: "刷新会话列表", descriptionEn: "Refresh session list" },
+        { name: "reload", description: "重新加载扩展、技能与模板", descriptionEn: "Reload extensions, skills & templates" },
+        { name: "help", description: "显示全部命令", descriptionEn: "Show all commands" },
+        { name: "copy", description: "复制上一条助手回复", descriptionEn: "Copy last assistant reply" },
+        { name: "pi-web-ui:quit", description: "退出服务", descriptionEn: "Quit server (supervisor will restart)" },
     ];
     /** Parse a prompt into "/command args" — returns null when it isn't one. */
     parseSlash(text) {
@@ -1991,6 +2195,20 @@ export class ClientSession {
                     });
                 }
                 return true;
+            case "pi-web-ui:quit": {
+                this.emit({
+                    type: "notice",
+                    level: "info",
+                    text: "正在退出 pi-web-ui… supervisor 将自动重启服务",
+                });
+                setTimeout(() => {
+                    const didSchedule = this.onQuit?.() ?? false;
+                    if (!didSchedule) {
+                        setTimeout(() => process.exit(0), 100);
+                    }
+                }, 300);
+                return true;
+            }
             case "help":
             case "copy":
                 // Client-side UI actions — the client handles them before sending;
@@ -2509,9 +2727,123 @@ export class ClientSession {
         }
         return out;
     }
+    /**
+     * Hard-abort the running agent (Stop button / global 中断). Tries
+     * session.abort() first; if the run is not idle within
+     * HARD_ABORT_TIMEOUT_MS (model stream ignoring the abort signal), the
+     * conversation's runtime is force-disposed and recreated from the last
+     * persisted session so the chat ALWAYS comes back usable — never stuck
+     * overnight. The notice fires only on the forced-reset path.
+     */
     async abort() {
+        await this.interruptRun(this.conv, "已停止");
+        // 中断同时清理 AI 在后台启动的服务（npm run dev & 等）——避免用户
+        // 测试时发现端口被占用而不知道是什么进程。
+        const killed = await this.killBackgroundServers();
+        if (killed.length > 0) {
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: `已停止 AI 后台服务：端口 ${killed.join("、")}（进程已结束）`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /** After a bash tool run, wait briefly for background servers to bind,
+     *  then diff the listening-port snapshot against the pre-run one and
+     *  remember anything new — those are servers the agent left running. */
+    async trackBackgroundServers() {
+        const before = this.bashListenBefore;
+        this.bashListenBefore = null;
+        if (!before)
+            return;
+        await new Promise((r) => setTimeout(r, 1500));
+        const after = await snapshotListeningPorts();
+        for (const [port, pid] of after) {
+            if (!before.has(port) && !this.bgServers.has(port)) {
+                this.bgServers.set(port, { pid, since: Date.now() });
+                this.emit({
+                    type: "notice",
+                    level: "info",
+                    text: `检测到 AI 启动的后台服务：端口 ${port}（pid ${pid}）——点顶栏「中断」可停止`,
+                });
+            }
+        }
+    }
+    /** Kill every background server the agent started; returns the freed ports. */
+    async killBackgroundServers() {
+        if (this.bgServers.size === 0)
+            return [];
+        const killed = [];
+        for (const [port, { pid }] of [...this.bgServers]) {
+            killPidTree(pid);
+            killed.push(String(port));
+        }
+        this.bgServers.clear();
+        return killed;
+    }
+    /** Kill only the running bash command(s) — the agent run itself continues
+     *  (the bash tool returns an aborted error and the model moves on). Uses
+     *  the per-client AbortController set registered by
+     *  makeKillableBashTool. */
+    async abortBash() {
+        if (this.bashKills.size === 0) {
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: "当前没有正在运行的 bash 命令",
+            });
+            this.flushSnapshot();
+            return;
+        }
+        for (const ac of [...this.bashKills])
+            ac.abort();
+        this.emit({
+            type: "notice",
+            level: "info",
+            text: "已停止 bash 命令（对话继续）",
+        });
+        // 让 AI 明确知道是用户手动停止：sendUserMessage 触发下一轮，agent
+        // 会看到「命令被用户中止」而不是普通失败，并据此继续（不会困惑于
+        // 为什么命令失败了）。
+        try {
+            await this.conv.runtime.session.sendUserMessage("（系统：用户手动停止了刚才的 bash 命令——命令被中止，终止前已输出的内容在对应工具结果里。请据此继续，不要重跑被中止的命令，除非确实必要。）");
+        }
+        catch {
+            // best effort — 消息注入失败不影响命令已停止的事实
+        }
+        this.flushSnapshot();
+    }
+    /** Interrupt a run: abort, with a force-reset fallback on timeout. */
+    async interruptRun(conv, reason) {
+        // The run is only truly stopped when its agent_end event arrives:
+        // session.abort() can return without stopping anything when the run is
+        // stuck before the agent even started (e.g. a model stream that never
+        // begins), so we watch for agent_end and force-reset when it never
+        // comes — abort 卡住（超时）或空转（结算窗口）两条路都覆盖。
+        let ended = false;
+        let forced = false;
+        const off = conv.session.subscribe((e) => {
+            if (e.type === "agent_end") {
+                ended = true;
+            }
+        });
+        const force = () => {
+            if (forced)
+                return;
+            forced = true;
+            void this.forceResetConversation(conv, `${reason}：运行未终止，已强制重置当前对话`);
+        };
+        // 1) abort itself hangs (model stream ignores the signal) → hard kill.
+        const abortTimer = setTimeout(() => {
+            if (!ended)
+                force();
+        }, ClientSession.HARD_ABORT_TIMEOUT_MS);
+        abortTimer.unref?.();
+        // 2) abort itself (Stop semantics: kills the process tree, emits
+        //    agent_end with stopReason "aborted" on the normal path).
         try {
-            await this.session.abort();
+            await conv.runtime.session.abort();
         }
         catch (err) {
             this.emit({
@@ -2520,7 +2852,46 @@ export class ClientSession {
                 text: `中止失败：${err.message}`,
             });
         }
-        this.flushSnapshot();
+        // 3) abort returned but no agent_end within the settle window → the
+        //    run was stuck before it started; force-reset to recover.
+        if (!ended) {
+            await new Promise((r) => setTimeout(r, ClientSession.HARD_ABORT_SETTLE_MS));
+        }
+        clearTimeout(abortTimer);
+        off();
+        if (!ended)
+            force();
+    }
+    /** Force-reset a conversation: dispose the stuck runtime (kills the hung
+     *  model stream / child processes) and rebuild it from the most recent
+     *  persisted session. The conversation record itself is kept (same id,
+     *  same cwd, same serialization caches), so the UI stays attached. */
+    async forceResetConversation(conv, reason) {
+        try {
+            conv.unsubscribe?.();
+            conv.unsubscribe = undefined;
+            this.clearAllToolWatchdogs(conv);
+            conv.toolStartTimes.clear();
+            await conv.runtime.dispose();
+            const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(), {
+                cwd: conv.cwd,
+                agentDir: this.agentDir,
+                sessionManager: SessionManager.continueRecent(conv.cwd),
+            });
+            conv.runtime = runtime;
+            conv.session = runtime.session;
+            this.emit({ type: "notice", level: "warning", text: reason });
+            await this.bindSession();
+            this.emitConversations();
+            void this.pushSlashCommands();
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `强制中断失败：${err.message}`,
+            });
+        }
     }
     async newChat() {
         // Reuse an already-open blank conversation instead of piling up new ones
@@ -2620,6 +2991,7 @@ export class ClientSession {
         if (!conv || id === this.activeId)
             return;
         this.convs.delete(id);
+        this.clearAllToolWatchdogs(conv);
         conv.unsubscribe?.();
         conv.unsubscribe = undefined;
         void conv.runtime.dispose().catch(() => { });
@@ -3975,6 +4347,7 @@ export class ClientSession {
         this.unwatchDir();
         this.webUi.dispose();
         for (const conv of this.convs.values()) {
+            this.clearAllToolWatchdogs(conv);
             conv.unsubscribe?.();
             try {
                 await conv.runtime.dispose();
@@ -3995,6 +4368,8 @@ export class AgentService {
      * self-update; returns whether the process will restart itself.
      */
     onUpdateReady = undefined;
+    /** Set by index.ts: called when /pi-web-ui:quit is invoked. */
+    onQuit = undefined;
     constructor(cwd, stateFile) {
         this.cwd = cwd;
         this.stateStore = new ClientStateStore(stateFile);
@@ -4040,8 +4415,9 @@ export class AgentService {
             }
         }
         cs.attachSink(send);
-        // Forward the update hook (set once by index.ts) to every session.
+        // Forward hooks (set once by index.ts) to every session.
         cs.onUpdateReady = this.onUpdateReady;
+        cs.onQuit = this.onQuit;
         return cs;
     }
     /** Remove a socket from a client's broadcast set (called on socket close). */

package/dist/server/ensure-bash.js

@@ -0,0 +1,80 @@
+/**
+ * Lightweight bash fallback for Windows.
+ *
+ * When neither Git Bash nor a bash on PATH exists, download busybox-w32
+ * (single self-contained ~1.5MB exe, no installer) into <home>/.pi-web/bin/
+ * and expose it as bash.exe — busybox dispatches on argv[0], so `bash.exe`
+ * runs its bash (ash) applet. The terminal panel (terminals.ts) and the SDK
+ * bash tool (via PATH) then both resolve to it, so the agent never silently
+ * falls back to cmd/PowerShell syntax on a bare Windows box.
+ *
+ * Download is fire-and-forget at server start and never throws: on failure
+ * the terminal simply falls back to $COMSPEC (cmd.exe) as before.
+ */
+import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Official busybox-w32 64-bit Unicode build (Win10 1903+ / Win11). */
+const BUSYBOX_URL = "https://frippery.org/files/busybox/busybox64u.exe";
+/** busybox.exe is ~660KB; anything far smaller is an error page, not a binary. */
+const MIN_SIZE = 500_000;
+/** Download cap — a stalled connection must not block startup forever. */
+const DOWNLOAD_TIMEOUT_MS = 60_000;
+/** Directory holding the busybox fallback (shared with terminals.ts / PATH). */
+export function windowsBashDir() {
+    return join(homedir(), ".pi-web", "bin");
+}
+/** bash.exe (busybox bash applet) used by the terminal and the SDK bash tool. */
+export function windowsBashPath() {
+    return join(windowsBashDir(), "bash.exe");
+}
+/** True when a standard Git Bash install exists (SDK's preferred shell). */
+export function hasGitBash() {
+    const pf = process.env.ProgramFiles;
+    const pf86 = process.env["ProgramFiles(x86)"];
+    for (const cand of [
+        pf ? join(pf, "Git", "bin", "bash.exe") : "",
+        pf86 ? join(pf86, "Git", "bin", "bash.exe") : "",
+    ]) {
+        if (cand && existsSync(cand))
+            return true;
+    }
+    return false;
+}
+/**
+ * Ensure a bash.exe exists on Windows. No-op when Git Bash is already
+ * installed (it is strictly preferred) or the fallback is already present.
+ * Never throws — failures degrade silently to the previous behaviour.
+ *
+ * @returns the bash.exe path when ready, null otherwise.
+ */
+export async function ensureWindowsBash() {
+    if (process.platform !== "win32")
+        return null;
+    const target = windowsBashPath();
+    if (existsSync(target))
+        return target;
+    if (hasGitBash())
+        return null; // Git Bash preferred — nothing to install.
+    const dir = windowsBashDir();
+    mkdirSync(dir, { recursive: true });
+    const tmp = join(dir, `busybox-${process.pid}.tmp`);
+    try {
+        const res = await fetch(BUSYBOX_URL, {
+            signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        const buf = Buffer.from(await res.arrayBuffer());
+        if (buf.length < MIN_SIZE)
+            return null; // error/HTML page, not the exe.
+        writeFileSync(tmp, buf);
+        renameSync(tmp, join(dir, "busybox.exe"));
+        copyFileSync(join(dir, "busybox.exe"), target);
+        return target;
+    }
+    catch {
+        rmSync(tmp, { force: true });
+        return null;
+    }
+}