pi-web-ui 0.92.0 → 0.94.0

package/dist/server/agent-service.js

@@ -35,7 +35,7 @@ import { MarkerService } from "./marker-service.js";
 import { SlashCommandsService, parseSlash } from "./slash-commands.js";
 import { ModelAdminService } from "./model-admin.js";
 import { FilesService, MACHINE_ROOT, desktopDirWire, workspacePath } from "./files-service.js";
-import { isExtensionDisabled, isExtensionEnabled, normalizeDisabledPluginTools, normalizeRetryMaxAttempts, normalizeSkillList, ClientStateStore, } from "./client-state.js";
+import { DEFAULT_TOOL_WATCHDOG_TIMEOUT_MS, effectiveToolWatchdogMs, isExtensionDisabled, isExtensionEnabled, normalizeDisabledPluginTools, normalizeRetryMaxAttempts, normalizeSkillList, ClientStateStore, } from "./client-state.js";
 import { bilingual, pick, resolveServerLang } from "./i18n.js";
 import { SubagentTemplatesStore, pickTemplatePrompt } from "./subagent-templates.js";
 import { ComposerDraftsStore } from "./composer-drafts.js";
@@ -49,6 +49,8 @@ import { makeEditSoftTool } from "./edit-soft-tool.js";
 import { makeReadDirTool } from "./read-tool.js";
 // 展示文件给用户（present_files）：图片/视频内联、文本开预览弹窗、本地打开按钮。
 import { makePresentFilesTool } from "./present-files-tool.js";
+// 工具定义说明的归一化（工具卡右键 → 「显示工具详细信息」，见 getToolInfo）。
+import { normalizeToolInfo } from "./tool-info.js";
 import { collectSubagentDescendantIds, makeSubagentTools, subagentTitle, withSubagentOwner, } from "./subagents.js";
 import { makeDelegateTaskTool } from "./delegate-task.js";
 import { makeConversationReadTool, parseTranscriptLines, toTranscriptInput, } from "./conversation-read-tool.js";
@@ -80,6 +82,13 @@ const DESKTOP_WIRE = desktopDirWire(HOME_WIRE);
 const STREAMING_SNAPSHOT_INTERVAL_MS = 2000;
 /** Deltas newer than this keep the streaming (low-frequency) snapshot cadence. */
 const DELTA_ACTIVE_WINDOW_MS = 1500;
+/**
+ * `session.getSessionStats()` 会遍历整份转写，而 `message_delta` 曾经**每一帧**都调它
+ * （只为了填 usage）。实测 6000 条转写 × 6002 帧时这一条链占了流式阶段 **27.6%** 的 CPU
+ * （2123ms），而一个「最多旧 250ms」的读数对进度条/上下文指示器来说与实时值无法区分。
+ * 加这层短缓存后实测流式 CPU 4.859s → 1.328s（3.7×），快照字节数完全不变（issue #259）。
+ */
+const STATS_CACHE_MS = 250;
 const WIDGET_REFRESH_MS = 2000;
 /** SCM「AI 生成提交信息」的单次补全超时——慢供应商不该让按钮转圈到天荒地老。 */
 const SCM_COMMITMSG_TIMEOUT_MS = 60_000;
@@ -92,9 +101,13 @@ const STALL_NOTIFY_MS = (() => {
     const v = Number(process.env.PI_WEB_STALL_NOTIFY_MS);
     return Number.isFinite(v) && v >= 0 ? v : 180_000;
 })();
-/** Serialization-cache cap per conversation (see serializeCached): cached
- *  UiMessage objects are pure-function results, so eviction only costs a
- *  recompute on next access. Bounds memory for marathon sessions. */
+/** Serialization-cache soft cap per conversation (see serializeCachedFor /
+ *  pruneMessageCache). Cached UiMessage objects are pure-function results, so a
+ *  miss only costs a recompute — but a miss on a message that is STILL in the
+ *  transcript is not free: it hands back a fresh object identity, which fails
+ *  emitSnapshotNow's identity walk and degrades every checkpoint to a full
+ *  snapshot (issue #259). Eviction is therefore by "no longer in the
+ *  transcript", never FIFO; this constant only says when that sweep runs. */
 const UI_MESSAGE_CACHE_CAP = 4096;
 /** Preview panel cap: only the first 512KB of a file is ever read/sent. */
 /** Thrown when the service is quiesced (draining) and the request is NEW work
@@ -224,7 +237,14 @@ export function makeAdaptiveBashTool(killable, terminalBacked, useTerminal) {
             "Setting ON → runs in a visible terminal. persist=true keeps that terminal alive ('ai-bash': shell state such as cd/venv/ssh retained across calls, silent commands move to the background and notify when done); persist=false (default in terminal mode) creates a one-shot terminal that exits when the command finishes while its output stays for review.\n" +
             "Run the bare command — do NOT pipe through head/tail/more/less (use the head/tail parameters to trim the returned output instead; piping also hides live progress in the visible terminal). For interactive commands (REPLs, prompts, installers asking y/n) set persist=true (terminal mode) and drive them with terminal_input / terminal_key.",
         promptSnippet: "run shell commands",
-        execute: (id, params, signal, onUpdate, ctx) => (useTerminal() ? terminalBacked : killable).execute(id, params, signal, onUpdate, ctx),
+        execute: (id, params, signal, onUpdate, ctx) => {
+            const p = params;
+            // Windows 下 ConPTY 架构限制（MSYS2 全局控制台上限 128，且高频创建销毁容易句柄耗尽/卡顿）：
+            // 一次性命令（persist !== true）走原生 spawn（基于 pipe，无需分配控制台，速度快 60 倍且免死锁，issue #269）；
+            // 只有明确需要持久交互（persist === true）才进可见终端 ai-bash。
+            const shouldUseTerminal = useTerminal() && (process.platform !== "win32" || p?.persist === true);
+            return (shouldUseTerminal ? terminalBacked : killable).execute(id, params, signal, onUpdate, ctx);
+        },
     };
 }
 /**
@@ -323,6 +343,10 @@ ownerId) {
         },
     };
 }
+/** 判定是否应当即时向前端推送问卷弹窗（只推给当前前台会话，未指定会话按全局放行）。 */
+export function shouldPopQuestion(conversationId, activeId) {
+    return conversationId === undefined || conversationId === activeId;
+}
 // ---------------------------------------------------------------------------
 // 浏览器页面工具（标准 pi 引擎的 browser_page customTool）
 //
@@ -650,15 +674,6 @@ function previewToolResult(result) {
         return "[unserializable result]";
     }
 }
-/** 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 NON-subagent conversations of ONE project (each keeps a full
  *  runtime alive; conversations of other projects keep their own lists).
  *  子代理不计入：子代理是 inMemory 后台任务，不参与此上限，既不占位也不被此上限拦截。 */
@@ -797,14 +812,26 @@ function collectSessionAnchors(filePath, q, cap = 10) {
 export function piSessionsRoot() {
     return process.env.PI_CODING_AGENT_SESSION_DIR || undefined;
 }
-/** Guardrail: only transcripts under the shared sessions root
- *  (<agentDir>/sessions/) may be opened/deleted/renamed — never arbitrary files.
+/** Guardrail: only transcripts under a sessions root may be opened/deleted/renamed
+ *  — never arbitrary files. Two roots count as “a sessions root”, and they must stay
+ *  the **same two** the history list reads from (`loadSessionInfos` →
+ *  `SessionManager.list(cwd, piSessionsRoot())`):
+ *
+ *   1. `<agentDir>/sessions/`（SDK 默认的每-cwd 子目录布局）
+ *   2. `PI_CODING_AGENT_SESSION_DIR`（扁平「额外会话根」，设了就以它为准扫盘）
+ *
+ *  只认第 1 条会让设了该变量的用户「历史列得出来、却点不开/删不掉/改不了名」
+ *  （列表与打开两边口径不一致）。守卫的意图是「不许开任意文件」，不是「只许开
+ *  默认目录下的文件」，所以放宽到两个根仍然成立。
  *  Shared by deleteSession/renameSession/switchSession so the open path cannot
  *  escape the confinement the write paths already enforce. */
 export function isInsideSessionsDir(agentDir, targetPath) {
     const abs = resolve(targetPath);
-    const sessionsRoot = resolve(agentDir, "sessions");
-    return abs.startsWith(sessionsRoot + sep);
+    const roots = [resolve(agentDir, "sessions")];
+    const extra = piSessionsRoot();
+    if (extra)
+        roots.push(resolve(extra));
+    return roots.some((root) => abs.startsWith(root + sep));
 }
 /** 会话当前模型的 "provider/id"（无模型时 null；软上限按模型覆盖用，issue #229）。 */
 function modelKeyOf(session) {
@@ -1044,13 +1071,22 @@ export class ClientSession {
      *  `model`（可选）："provider/id"，显式指定子代理模型。不传时由调用方决定是否
      *  回退到模板模型 / 设置面板默认模型；null = 跟随主对话当前模型（默认行为，
      *  runtime 重建时会继承共享 ModelRuntime 的当前默认）。 */
-    async spawnSubagentConversation(prompt, type, cwd, apply, model, parentId) {
+    async spawnSubagentConversation(prompt, type, cwd, apply, model, parentId, persist) {
         // 数量上限先行：每个子代理都是完整 runtime + TerminalManager，无上限时一次
-        // 并行派发几十个会把服务进程拖垮。抛错由 subagent_spawn / delegate_task 转成
-        // 返回文本，AI 读到后可改串行 / 等待收口后重试，而不是看到工具异常。
-        const liveSubagents = [...this.convs.values()].filter((c) => c.isSubagent).length;
-        if (liveSubagents >= MAX_SUBAGENTS) {
-            throw new Error(pick(this.getLang(), `子代理数量已达上限（${MAX_SUBAGENTS} 个），请先用 subagent_wait_all 等一部分完成、或用 subagent_stop 停掉不需要的再派发`, `Subagent limit reached (${MAX_SUBAGENTS} live). Wait for some with subagent_wait_all or stop unneeded ones with subagent_stop before spawning more`, "agent.subagent.limit.reached", { limit: MAX_SUBAGENTS }));
+        // 并行派发几十个会把服务进程拖垮。持久化普通对话则受项目会话上限限制。
+        if (persist) {
+            const baseCwdForLimit = parentId ? (this.convs.get(parentId)?.cwd ?? this.cwd) : this.cwd;
+            const resolvedCwdForLimit = cwd ? resolve(baseCwdForLimit, cwd) : baseCwdForLimit;
+            const openInProject = [...this.convs.values()].filter((c) => c.cwd === resolvedCwdForLimit && !c.isSubagent).length;
+            if (openInProject >= MAX_OPEN_CONVERSATIONS) {
+                throw new Error(pick(this.getLang(), `目标项目运行的普通对话已达上限（${MAX_OPEN_CONVERSATIONS} 个），无法创建持久化对话。请先关闭不需要的对话，或以轻量子代理（persist=false）方式运行`, `The project already has max open regular conversations (${MAX_OPEN_CONVERSATIONS}). Please close some or run as a lightweight subagent (persist=false)`, "agent.conv.limit.reached", { limit: MAX_OPEN_CONVERSATIONS }));
+            }
+        }
+        else {
+            const liveSubagents = [...this.convs.values()].filter((c) => c.isSubagent).length;
+            if (liveSubagents >= MAX_SUBAGENTS) {
+                throw new Error(pick(this.getLang(), `子代理数量已达上限（${MAX_SUBAGENTS} 个），请先用 subagent_wait_all 等一部分完成、或用 subagent_stop 停掉不需要的再派发`, `Subagent limit reached (${MAX_SUBAGENTS} live). Wait for some with subagent_wait_all or stop unneeded ones with subagent_stop before spawning more`, "agent.subagent.limit.reached", { limit: MAX_SUBAGENTS }));
+            }
         }
         // 真正的派发者（withSubagentOwner 按 runtime 归属填入）：cwd 基准 / 跟随模型 /
         // 跟随思考强度一律读它，而不是派发瞬间的 active——后台对话产出时用户可能正
@@ -1060,15 +1096,16 @@ export class ClientSession {
         const baseCwd = spawner?.cwd ?? this.cwd;
         // 相对 cwd 按派发者所在目录解析：直接透传会相对 server 进程 cwd 落到别处。
         const resolvedCwd = cwd ? resolve(baseCwd, cwd) : baseCwd;
-        const conversationId = `sa-${randomUUID().slice(0, 8)}`;
+        const conversationId = persist ? `conv-${randomUUID().slice(0, 8)}` : `sa-${randomUUID().slice(0, 8)}`;
         const terminals = this.makeTerminalManager(conversationId, resolvedCwd);
+        const sessionManager = persist ? SessionManager.create(resolvedCwd) : SessionManager.inMemory(resolvedCwd);
         const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(terminals, apply, conversationId), {
             cwd: resolvedCwd,
             agentDir: this.agentDir,
-            sessionManager: SessionManager.inMemory(resolvedCwd),
+            sessionManager,
         });
         const conv = this.makeConversation(runtime, conversationId, terminals);
-        conv.isSubagent = true;
+        conv.isSubagent = !persist;
         // 父对话 = 真正派发它的会话（按会话归属的 host 包装填入）。直接用 active
         // 会错：后台对话运行时用户可能正看着别的项目对话，孩子会被记到无关
         // 对话名下、沉到别的项目组底部（issue #95）。缺省才回退到 active。
@@ -1174,18 +1211,28 @@ export class ClientSession {
                 textEn: `Subagent ${conversationId} failed to start: ${err instanceof Error ? err.message : String(err)}`,
             });
         });
+        if (persist) {
+            this.pushProjects().catch(() => { });
+        }
         this.emitConversations();
         return conv.id;
     }
     getSubagentSnapshot(convId) {
         const conv = this.convs.get(convId);
-        if (!conv?.isSubagent || !conv.session)
+        if (!conv?.session)
             return undefined;
         return this.toSubagentSnapshot(conv);
     }
-    listSubagentSnapshots() {
+    listSubagentSnapshots(scope) {
         return [...this.convs.values()]
-            .filter((c) => c.isSubagent)
+            .filter((c) => {
+            const isPersisted = !c.isSubagent;
+            if (scope === "subagent")
+                return c.isSubagent;
+            if (scope === "persistent")
+                return isPersisted;
+            return c.isSubagent || Boolean(c.parentId) || Boolean(c.subagentPrompt);
+        })
             .sort((a, b) => a.createdAt - b.createdAt)
             .map((c) => this.toSubagentSnapshot(c));
     }
@@ -1203,6 +1250,8 @@ export class ClientSession {
             // session being replaced — report defaults
         }
         const fullPrompt = conv.subagentPrompt ?? "";
+        const sm = conv.session.sessionManager;
+        const isPersisted = !conv.isSubagent || (typeof sm?.isPersisted === "function" && sm.isPersisted());
         return {
             convId: conv.id,
             type: conv.subagentType ?? "general",
@@ -1218,6 +1267,7 @@ export class ClientSession {
             model: conv.session.model?.id,
             output: conv.session.getLastAssistantText() ?? "",
             parentId: conv.parentId,
+            persisted: isPersisted,
         };
     }
     /** 子代理最近一次运行的结局：最后一条 assistant 消息的 errorMessage / stopReason。
@@ -1414,17 +1464,17 @@ export class ClientSession {
      * 切换查看 / 输入补充（steer）/ 中止（abort）/ 移出全部复用现有对话机制。
      */
     subagentHost = {
-        spawnSubagent: (prompt, type, cwd, templateName, model, parentId) => {
+        spawnSubagent: (prompt, type, cwd, templateName, model, parentId, persist) => {
             // 模板：存在且启用时应用；传了名字但不可用 → 抛错让工具转给 AI。
             const tpl = templateName ? this.subagentTemplates.get(templateName) : undefined;
             if (templateName && (!tpl || !tpl.enabled)) {
                 throw new Error(pick(this.getLang(), `子代理模板不可用：${templateName}（不存在或已停用）`, `Subagent template unavailable: ${templateName} (missing or disabled)`, "agent.subagent.template.unavailable", { templateName: templateName }));
             }
             // 模型优先级：显式 model 参数 > 模板自带模型 > 设置面板默认模型；都不给 = 跟随主对话。
-            return this.spawnSubagentConversation(prompt, type, cwd, tpl, model, parentId);
+            return this.spawnSubagentConversation(prompt, type, cwd, tpl, model, parentId, persist);
         },
         getSubagent: (convId) => this.getSubagentSnapshot(convId),
-        listSubagents: () => this.listSubagentSnapshots(),
+        listSubagents: (scope) => this.listSubagentSnapshots(scope),
         steerSubagent: async (convId, message) => {
             const conv = this.convs.get(convId);
             if (!conv?.session)
@@ -1437,6 +1487,7 @@ export class ClientSession {
                 await this.interruptRun(conv, pick(this.getLang(), "用户停止子代理", "User stopped the subagent", "agent.subagent.stop.user"));
             }
         },
+        getWatchdogTimeoutMs: () => this.getBaseToolWatchdogTimeoutMs(),
         // issue #91：子代理工具返回按客户端 UI 语言出中英（英文默认）。
         lang: () => this.getLang(),
         // 只向 AI 暴露 enabled 的模板（停用的对 AI 不可见）。
@@ -1649,6 +1700,9 @@ export class ClientSession {
     /** Timestamp of the most recent message_delta push — while fresh, snapshots
      *  use the slower STREAMING_SNAPSHOT_INTERVAL_MS cadence. */
     lastDeltaAt = 0;
+    /** Short-lived `getSessionStats()` memo — see STATS_CACHE_MS. Keyed by the
+     *  session instance so a conversation switch never serves the previous one. */
+    sessionStatsCache = null;
     sessionsTimer = null;
     version = 0;
     /** Snapshot revision counter (see emitSnapshotNow / protocol snapshot_delta). */
@@ -1852,16 +1906,41 @@ export class ClientSession {
                 });
             }
         }
-        // issue #145：因别处正在跑而跳过恢复 —— 首帧即被告之（pendingNotices 随 attachSink 下发）。
+        // issue #145：因别处仍持有而跳过恢复 —— 首帧即被告之（pendingNotices 随 attachSink 下发）。
+        // 跑着/空闲都拦：直接恢复会造出第二个写者（两边轮流发送分叉历史）。
         if (opts?.blank && opts?.blankTitle) {
-            cs.pendingNotices.push({
-                type: "notice",
-                level: "info",
-                text: `该项目最近的对话「${opts.blankTitle}」正在另一处运行，为你停在了新对话 —— 直接打开会造出第二个写者。左栏「运行的对话」里能看到它（标着“另一处”），等它跑完再打开。`,
-                textEn: `The most recent conversation ("${opts.blankTitle}") is running in another window, so you landed on a new chat instead — opening it here would create a second writer. It is listed under Running chats (tagged "Elsewhere"); open it after it finishes.`,
-            });
+            cs.pendingNotices.push(opts.idleHeld
+                ? {
+                    type: "notice",
+                    level: "info",
+                    text: `该项目最近的对话「${opts.blankTitle}」在另一处开着（当前空闲），为你停在了空白新对话 —— 可在左栏「运行的对话」里把它过户过来继续看，或从历史对话里打开（只留一处发送消息，否则历史分叉）。`,
+                    textEn: `The most recent conversation ("${opts.blankTitle}") is still open in another window (currently idle), so you landed on a blank chat instead — take it over from Running chats (tagged "Elsewhere") or reopen it from History (send new messages from only one place, or the history will fork).`,
+                }
+                : {
+                    type: "notice",
+                    level: "info",
+                    text: `该项目最近的对话「${opts.blankTitle}」正在另一处运行，为你停在了新对话 —— 直接打开会造出第二个写者。左栏「运行的对话」里能看到它（标着“另一处”），等它跑完再打开。`,
+                    textEn: `The most recent conversation ("${opts.blankTitle}") is running in another window, so you landed on a new chat instead — opening it here would create a second writer. It is listed under Running chats (tagged "Elsewhere"); open it after it finishes.`,
+                });
         }
         await cs.bindSession();
+        // 同步全局默认模型至 SDK settingsManager（若 settings.json 尚未写入），防底层 session 创建时 findInitialModel 兜底回退硬编码模型
+        const globalDefault = stateStore.getDefaultModel();
+        if (globalDefault) {
+            const slash = globalDefault.indexOf("/");
+            if (slash > 0 && slash < globalDefault.length - 1) {
+                const p = globalDefault.slice(0, slash);
+                const id = globalDefault.slice(slash + 1);
+                try {
+                    if (!cs.session.settingsManager.getDefaultModel()) {
+                        cs.session.settingsManager.setDefaultModelAndProvider(p, id);
+                    }
+                }
+                catch {
+                    /* 会话未就绪时忽略 */
+                }
+            }
+        }
         await cs.restoreProjectProviderKeysForCwd(cwd);
         await cs.restoreProjectModelForCwd(cwd);
         return cs;
@@ -1875,7 +1954,7 @@ export class ClientSession {
      * 应用（prompt replace/append + 白名单），其余（终端接管、Windows persona
      * 等）仍跟随主会话设置。undefined = 按主会话设置（普通对话/不选模板的子代理）。
      */
-    makeRuntimeFactory(terminals, apply, ownerId) {
+    makeRuntimeFactory(terminals, apply, ownerId, initialModel) {
         return async ({ cwd: effectiveCwd, sessionManager }) => {
             const services = await createAgentSessionServices({
                 cwd: effectiveCwd,
@@ -2015,9 +2094,38 @@ export class ClientSession {
             // anchor 在拿到 created.session 后回填（SDK 的 runtime.session 就是它）。
             const bridgeAnchor = {};
             const bridge = this.bridgeTarget(bridgeAnchor, ownerId);
+            // 为全新会话（0 条消息的空白对话/新对话）提前解析目标模型并注入，
+            // 避免 SDK findInitialModel 在无 model 时回退到内置硬编码默认（如 deepseek-v4-pro）：
+            let sessionModel = initialModel;
+            if (!sessionModel) {
+                const isBlank = sessionManager.buildSessionContext().messages.length === 0;
+                if (isBlank) {
+                    const savedModelId = this.stateStore.getProjectModel(this.clientId, effectiveCwd) ?? this.stateStore.getDefaultModel();
+                    if (savedModelId) {
+                        const slash = savedModelId.indexOf("/");
+                        if (slash > 0 && slash < savedModelId.length - 1) {
+                            const p = savedModelId.slice(0, slash);
+                            const id = savedModelId.slice(slash + 1);
+                            const found = services.modelRuntime.getModel(p, id);
+                            if (found) {
+                                try {
+                                    await this.restoreKeyForModel(savedModelId, effectiveCwd);
+                                    if (services.modelRuntime.hasConfiguredAuth(p)) {
+                                        sessionModel = found;
+                                    }
+                                }
+                                catch {
+                                    /* 密钥恢复失败则由 SDK 自行解析 */
+                                }
+                            }
+                        }
+                    }
+                }
+            }
             const created = await createAgentSessionFromServices({
                 services,
                 sessionManager,
+                model: sessionModel,
                 // 覆盖 SDK 内置 bash（customTools 按 name 覆盖）。双实现分流：
                 // 「默认 bash 覆盖」开关（terminalBash）关 → 原生 SDK bash（纯进程、不开终端）；
                 // 开 → 终端接管 bash（persist 决定一次性/持久，可静默自动转后台）。
@@ -2091,8 +2199,8 @@ export class ClientSession {
                             ...(c.note ? { note: c.note } : {}),
                         })),
                     }),
-                    // 文件认领（claim_files）：常驻注册、不进工具目录（见 claimToolHost
-                    // 注释）。ownerId 语义同 subagent/skill（本 runtime 所属会话）。
+                    // 文件认领（claim_files）：开关走统一工具 tab（ActiveSet 门控）。
+                    // ownerId 语义同 subagent/skill（本 runtime 所属会话）。
                     // DSH 引擎无 customTool 注册面，不接（提醒里照样能看到认领）。
                     makeClaimFilesTool(this.claimToolHost(ownerId), () => this.getLang()),
                     // 展示文件给用户（present_files，issue #231）：模型给路径清单，服务端
@@ -2371,25 +2479,48 @@ export class ClientSession {
             }
         }, 30_000);
     }
+    /** 当前生效的基础工具看门狗超时（毫秒）。0 = 禁用看门狗。
+     *  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. 优先取设置面板「工具」页的
+     *  ClientSettings.toolWatchdogTimeoutMs（逐 run 实时读取，无需 reload）；
+     *  未设时回落 PI_WEB_TOOL_TIMEOUT_MS 环境变量，再回落默认 20 分钟。 */
+    getBaseToolWatchdogTimeoutMs() {
+        const fromSettings = this.settingsSvc.current.toolWatchdogTimeoutMs;
+        if (typeof fromSettings === "number" && Number.isFinite(fromSettings) && fromSettings >= 0) {
+            return fromSettings;
+        }
+        return DEFAULT_TOOL_WATCHDOG_TIMEOUT_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) {
-        this.rearmToolWatchdog(conv, toolCallId, TOOL_WATCHDOG_TIMEOUT_MS);
+     *  conversation hang forever (the SDK bash tool has no default timeout).
+     *  若工具调用显式指定了更长超时（如 bash args.timeout），看门狗自动顺延。 */
+    armToolWatchdog(conv, toolCallId, toolName, args) {
+        const timeoutMs = effectiveToolWatchdogMs(this.getBaseToolWatchdogTimeoutMs(), toolName, args);
+        // 0 = 用户显式禁用看门狗（设置面板填 0）。
+        if (timeoutMs <= 0)
+            return;
+        this.rearmToolWatchdog(conv, toolCallId, timeoutMs, timeoutMs);
     }
     /** （重）布工具挂死看门狗：delayMs 后仍在跑则 abort 整轮。过户时用剩余时间重布
      *  （已逾期的立即触发，语义不变）. */
-    rearmToolWatchdog(conv, toolCallId, delayMs) {
+    rearmToolWatchdog(conv, toolCallId, delayMs, totalTimeoutMs) {
+        const totalMs = totalTimeoutMs ?? delayMs;
         const t = setTimeout(() => {
             conv.toolWatchdogs.delete(toolCallId);
             // The tool finished before the deadline — nothing to do.
             if (!conv.toolStartTimes.has(toolCallId))
                 return;
+            const durationMin = Math.round(totalMs / 60_000);
+            const durationDescZh = durationMin >= 1 ? `${durationMin} 分钟` : `${Math.round(totalMs / 1000)} 秒`;
+            const durationDescEn = durationMin >= 1 ? `${durationMin} min` : `${Math.round(totalMs / 1000)}s`;
             this.emit({
                 type: "notice",
                 level: "warning",
-                text: `工具执行超过 ${Math.round(TOOL_WATCHDOG_TIMEOUT_MS / 60_000)} 分钟，已自动终止（防止挂死）。可调整超时：环境变量 PI_WEB_TOOL_TIMEOUT_MS（毫秒）。`,
-                textEn: `Tool ran over ${Math.round(TOOL_WATCHDOG_TIMEOUT_MS / 60_000)} min and was auto-terminated (hang guard). Tune via PI_WEB_TOOL_TIMEOUT_MS (ms).`,
+                text: `工具执行超过 ${durationDescZh}，已自动终止（防止挂死）。可调整超时：设置面板「工具」或环境变量 PI_WEB_TOOL_TIMEOUT_MS。`,
+                textEn: `Tool ran over ${durationDescEn} and was auto-terminated (hang guard). Tune via Settings -> Tools or PI_WEB_TOOL_TIMEOUT_MS env var.`,
             });
             conv.toolStartTimes.delete(toolCallId);
             // Abort the run (kills the process tree via the SDK's abort signal);
@@ -2470,9 +2601,12 @@ export class ClientSession {
             catch {
                 /* 尽力而为 */
             }
+            const curModel = target.session.model;
+            const modelId = curModel ? `${curModel.provider}/${curModel.id}` : undefined;
             return {
                 conversationId: target.id,
                 title: target.title,
+                model: modelId,
                 at: target.lastActiveAt,
                 isStreaming: target.session.isStreaming,
                 messages: this.messagesOf(target),
@@ -2785,7 +2919,7 @@ export class ClientSession {
                 // （默认 20 分钟会把还在思考的用户连对话一起剁掉）。它的收场自有路子：
                 // 用户回答/取消、会话 dispose（cancelPendingQuestions），不限时。
                 if (event.toolName !== ASK_USER_QUESTION_TOOL_NAME) {
-                    this.armToolWatchdog(conv, event.toolCallId);
+                    this.armToolWatchdog(conv, event.toolCallId, event.toolName, event.args);
                 }
                 // 插件扩展点：工具开始执行（异常由 emitToolEvent 隔离）。
                 this.onToolEvent?.({
@@ -2900,7 +3034,9 @@ export class ClientSession {
                 conv.compactionState = { reason: event.reason, startedAt: Date.now() };
                 conv.lastCompactionTokens = null;
                 this.markCompactionPending(conv);
-                this.flushSnapshot();
+                // 进度条只有激活对话看得到（后台对话的快照没有接收方，见 onEvent 末尾）。
+                if (conv.id === this.conv.id)
+                    this.flushSnapshot();
                 break;
             }
             case "compaction_end": {
@@ -3148,7 +3284,7 @@ export class ClientSession {
                     messageId: `stream-${m?.timestamp ?? 0}`,
                     usage: (() => {
                         try {
-                            const t = this.session.getSessionStats().tokens;
+                            const t = this.sessionStats().tokens;
                             return t ? { input: t.input, output: t.output, total: t.total } : null;
                         }
                         catch {
@@ -3172,6 +3308,16 @@ export class ClientSession {
         // Snapshot checkpoint policy: deltas carry live rendering during streaming;
         // full snapshots are reconciliation checkpoints taken immediately at
         // run/tool boundaries and on a slow timer otherwise.
+        //
+        // 只服务**激活对话**（口径同上面的 message_update）：flushSnapshot /
+        // scheduleSnapshot 推的都是 this.conv 的整份状态，而这里的事件可能来自后台
+        // 对话——运行中的子代理每次 tool_execution_end / agent_end 都会走到这一点。
+        // 不按 conv.id 分流 = 子代理的每一次工具调用都替激活对话做一次快照：issue
+        // #259 实测 8 子代理 × 5 次 bash → 8 条全量快照共 39.5MB，而激活对话一个
+        // 字节都没变。后台对话的内容在切过去时取（switch_session / get_state 强制
+        // 全量），它在左栏的运行态由 emitConversations 走另一条通道。
+        if (conv.id !== this.conv.id)
+            return;
         if (event.type === "agent_end" ||
             event.type === "tool_execution_end" ||
             event.type === "compaction_end" ||
@@ -3215,8 +3361,11 @@ export class ClientSession {
     serializeCached(m) {
         return this.serializeCachedFor(this.conv, m);
     }
-    /** serializeCached 的按对话版本（插件快照读非活跃对话用；缓存仍按对话隔离）。 */
-    serializeCachedFor(conv, m) {
+    /** 稳定缓存键 + 该消息的序号种子 n（见 serializeCachedFor）。
+     *
+     *  messagesOf 一次扫描里同时要 key（建 live 集合）与 n（算 user seq），所以
+     *  两者一起返回、只算一次；单独调用的路径不传 key，按需现算。 */
+    uiMessageKey(conv, m) {
         // toolResult messages are keyed by toolCallId; everything else by
         // role+timestamp. A single prompt can emit several same-role messages
         // within the SAME millisecond (multiple attachment asides), so the
@@ -3229,8 +3378,13 @@ export class ClientSession {
             n = conv.nextMsgId++;
             conv.msgIds.set(key, n);
         }
-        const cacheKey = `${key}#${n}`;
-        const cached = conv.uiMessageCache.get(cacheKey);
+        return { cacheKey: `${key}#${n}`, n };
+    }
+    /** serializeCached 的按对话版本（插件快照读非活跃对话用；缓存仍按对话隔离）。
+     *  key 可由 messagesOf 预计算传入（同一次扫描里它已经算过一遍）。 */
+    serializeCachedFor(conv, m, key) {
+        const k = key ?? this.uiMessageKey(conv, m);
+        const cached = conv.uiMessageCache.get(k.cacheKey);
         if (cached)
             return cached;
         // User-message id suffix is a 1-based count of user messages sharing
@@ -3238,28 +3392,17 @@ export class ClientSession {
         // a global per-conversation counter across ALL roles, so it can't be
         // reused as the seq — otherwise editing anything but the first question
         // fails to resolve ("找不到要编辑的消息").
-        let seq = n;
+        let seq = k.n;
         if (m.role === "user") {
             const ts = m.timestamp ?? 0;
             seq = (conv.userSeqByTs.get(ts) ?? 0) + 1;
             conv.userSeqByTs.set(ts, seq);
         }
         const msg = serializeMessage(m, seq);
-        if (msg) {
-            conv.uiMessageCache.set(cacheKey, msg);
-            // Bound the cache (marathon sessions otherwise grow without limit;
-            // single messages can reach TEXT_CAP = 200K chars). Map iteration is
-            // insertion order, so dropping from the front evicts the oldest —
-            // recent messages (the ones every snapshot touches) always survive.
-            // Safe: a miss just recomputes an identical object on next access.
-            let excess = conv.uiMessageCache.size - UI_MESSAGE_CACHE_CAP;
-            while (excess-- > 0) {
-                const oldest = conv.uiMessageCache.keys().next().value;
-                if (oldest === undefined)
-                    break;
-                conv.uiMessageCache.delete(oldest);
-            }
-        }
+        // 上界在 messagesOf 的 pruneMessageCache 里按 live 集合处理：见那里的注释
+        // （FIFO 淘汰仍在转写里的条目会让每次快照都退化成全量，issue #259）。
+        if (msg)
+            conv.uiMessageCache.set(k.cacheKey, msg);
         return msg;
     }
     /** Current messages array (with the existing sig-reuse optimization).
@@ -3270,13 +3413,21 @@ export class ClientSession {
     }
     /** currentMessages 的按对话版本（插件快照读非活跃对话用）。 */
     messagesOf(conv) {
+        // 一次扫描同时收齐「当前转写里的全部缓存键」（live 集合，供
+        // pruneMessageCache 精确回收死条目）与各自的序列化结果。
+        const live = new Set();
         let rawMessages = conv.session.agent.state.messages
-            .map((m) => this.serializeCachedFor(conv, m))
+            .map((m) => {
+            const k = this.uiMessageKey(conv, m);
+            live.add(k.cacheKey);
+            return this.serializeCachedFor(conv, m, k);
+        })
             .filter((m) => m !== null);
         // 自动重试等待期：SDK 暂留在 state 末尾的 error 气泡只是中间态（随后被
         // 摘掉重跑），不进快照——成功则用户永远看不到，耗尽才标红。否则 agent_end
         // 的立即 flush 会先画红、摘掉后又消失（红色一闪而过）。
         rawMessages = stripTransientRetryErrors(rawMessages, !!conv.retryState);
+        this.pruneMessageCache(conv, live);
         // Reuse the previous array when nothing changed: the element objects are
         // cached (reference-stable) anyway, and a stable array reference lets the
         // frontend memoize derived maps instead of rebuilding them every 60ms.
@@ -3286,6 +3437,27 @@ export class ClientSession {
         conv.lastMessagesArray = rawMessages;
         return messages;
     }
+    /** 序列化缓存上界：**先按「还在转写里」淘汰，绝不为省内存淘汰仍在转写里的条目**。
+     *
+     *  为什么不能 FIFO 淘汰（issue #259 实测的机理）：缓存上限一旦低于转写长度，
+     *  每次快照扫描前缀条目全部 miss → 重新序列化出**新对象**，emitSnapshotNow 的
+     *  identity walk 在 i=0 就失配 ⇒ 每个 checkpoint 都退化成整份全量快照，且每次
+     *  都要重算整份转写（颠簸，成本随转写线性甚至更差）。实测 6000 条转写的激活
+     *  对话 + 8 子代理 × 5 次 bash：40 次工具调用换来 8 条全量快照共 39.5MB，
+     *  `snapshot_delta` 一条都没有。
+     *
+     *  按 live 集合淘汰后：仍在转写里的消息对象恒定（identity walk 命中，增量通路
+     *  恢复），被回收的只有 fork / 压缩 / 换会话留下的死条目 —— 内存上界仍等于
+     *  「当前转写」本身（这份数组本来就要常驻），不再随历史累积。 */
+    pruneMessageCache(conv, live) {
+        const cache = conv.uiMessageCache;
+        // 只有「超上限」且「确实有死条目」时才扫一遍；转写单调增长时这里是零成本。
+        if (cache.size <= UI_MESSAGE_CACHE_CAP || cache.size <= live.size)
+            return;
+        for (const key of cache.keys())
+            if (!live.has(key))
+                cache.delete(key);
+    }
     /** Build every UiState field EXCEPT messages (the expensive part). */
     buildLightState(rev, withDraft = false) {
         const conv = this.conv;
@@ -3298,7 +3470,7 @@ export class ClientSession {
             contextUsage: { tokens: null, contextWindow: 0, percent: null },
         };
         try {
-            const s = this.session.getSessionStats();
+            const s = this.sessionStats();
             stats = {
                 totalMessages: s.totalMessages,
                 tokens: s.tokens,
@@ -3490,11 +3662,18 @@ export class ClientSession {
             this.pendingQuestions.set(id, { resolve, questions, conversationId });
             // 运行列表的「?」角标靠 conversations 推送（问卷登记/解决不经过快照通道）。
             this.emitConversations();
-            this.emit({
-                type: "question_pending",
-                id,
-                questions,
-            });
+            // 只向目标会话的当前激活端推送弹窗，避免后台问卷污染当前前台会话。
+            if (shouldPopQuestion(conversationId, this.activeId)) {
+                const conv = conversationId ? this.convs.get(conversationId) : this.conv;
+                const conversationTitle = conv?.title;
+                this.emit({
+                    type: "question_pending",
+                    id,
+                    questions,
+                    ...(conversationId !== undefined ? { conversationId } : {}),
+                    ...(conversationTitle ? { conversationTitle } : {}),
+                });
+            }
         });
     }
     /** 前端回答模型提问（question_answer → 恢复 askUser 的 Promise）。id 需匹配
@@ -3519,7 +3698,14 @@ export class ClientSession {
         for (const [id, p] of this.pendingQuestions) {
             if (p.conversationId !== undefined && p.conversationId !== this.activeId)
                 continue;
-            return { id, questions: p.questions };
+            const conv = p.conversationId !== undefined ? this.convs.get(p.conversationId) : this.conv;
+            const conversationTitle = conv?.title;
+            return {
+                id,
+                questions: p.questions,
+                ...(p.conversationId !== undefined ? { conversationId: p.conversationId } : {}),
+                ...(conversationTitle ? { conversationTitle } : {}),
+            };
         }
         return null;
     }
@@ -3540,14 +3726,34 @@ export class ClientSession {
     /** 取某对话的等答复问卷原文（跨页作答的 peek 用；只读，不改变状态）。 */
     peekPendingQuestion(convId) {
         for (const [id, p] of this.pendingQuestions) {
-            if (p.conversationId === convId)
-                return { id, questions: p.questions };
+            if (p.conversationId === convId) {
+                const conv = this.convs.get(convId);
+                return { id, questions: p.questions, conversationTitle: conv?.title };
+            }
+        }
+        return undefined;
+    }
+    /** 取某对话的等答复问卷简要信息（用于会话列表与横幅展示）。 */
+    getPendingQuestionForConv(convId) {
+        for (const [id, p] of this.pendingQuestions) {
+            if (p.conversationId === undefined || p.conversationId === convId) {
+                const q0 = p.questions[0];
+                const title = q0?.header?.trim() || q0?.question?.trim() || undefined;
+                return { id, title };
+            }
         }
         return undefined;
     }
     /** 跨页作答：把别处问卷的原文推给本页弹框（回答经 answerElsewhereQuestion 回去）。 */
     pushElsewhereQuestion(owner, convId, q) {
-        this.emit({ type: "elsewhere_question", owner, convId, id: q.id, questions: q.questions });
+        this.emit({
+            type: "elsewhere_question",
+            owner,
+            convId,
+            id: q.id,
+            questions: q.questions,
+            ...(q.conversationTitle ? { conversationTitle: q.conversationTitle } : {}),
+        });
     }
     /** 关闭所有挂起提问（dispose 时清理）：以「取消」解析，避免模型挂死。 */
     cancelPendingQuestions() {
@@ -3964,6 +4170,22 @@ export class ClientSession {
         }
         this.emitSnapshotNow(forceFull);
     }
+    /**
+     * Cached `session.getSessionStats()` — the SDK computes it by walking the whole
+     * transcript, and the message_delta path used to call it per streaming frame
+     * (measured: 27.6% of streaming CPU at 6000 messages, see STATS_CACHE_MS).
+     * Callers that need the authoritative value can still call the session
+     * directly; every cache hit here is at most STATS_CACHE_MS stale.
+     */
+    sessionStats() {
+        const now = Date.now();
+        const hit = this.sessionStatsCache;
+        if (hit && hit.session === this.session && now - hit.at < STATS_CACHE_MS)
+            return hit.value;
+        const value = this.session.getSessionStats();
+        this.sessionStatsCache = { at: now, session: this.session, value };
+        return value;
+    }
     scheduleSnapshot() {
         if (this.snapshotTimer || this.disposed)
             return;
@@ -4037,6 +4259,29 @@ export class ClientSession {
     pushSlashCommands() {
         return this.slash.push();
     }
+    /**
+     * 取一条工具的**定义说明**（工具卡右键 → 「显示工具详细信息」）→ `tool_info`。
+     *
+     * 定义从活动会话现取（`getAllTools` 是目录全集，含被禁用的工具），
+     * `getActiveToolNames` 只用来标记「当前是否启用」—— 禁用名单里的工具仍在目录里，
+     * 用户点开看定义是合理的，只是模型看不到它。
+     *
+     * 失败（会话未就绪 / 引擎抛错）一律回 `found: false`：这是只读的展示请求，
+     * 不该因为拿不到定义就在 UI 上报警。
+     */
+    getToolInfo(name) {
+        let raw;
+        try {
+            const defs = this.session.getAllTools();
+            const found = defs.find((d) => d.name === name);
+            if (found)
+                raw = { ...found, active: this.session.getActiveToolNames().includes(name) };
+        }
+        catch {
+            // Session not ready (or the engine threw) — fall through to found:false.
+        }
+        this.emit({ type: "tool_info", ...normalizeToolInfo(name, raw) });
+    }
     /** 模型/服务商配置管理 —— 自包含模块，见 model-admin.ts。 */
     modelAdmin;
     /** Persist an api-key credential for a provider (auth.json). */
@@ -4246,8 +4491,20 @@ export class ClientSession {
             const curId = cur ? `${cur.provider}/${cur.id}` : null;
             // Restore the model's provider key first so setModel's auth check passes.
             await this.restoreKeyForModel(savedModel, cwd);
-            if (curId === savedModel)
+            if (curId === savedModel) {
+                // 即使模型已是目标模型，也确保恢复其专属思考强度或全局默认思考强度
+                const sm = this.session.settingsManager;
+                const targetThinking = sm.getModelThinkingLevel(model.provider, model.id) ?? sm.getDefaultThinkingLevel();
+                if (targetThinking && this.session.thinkingLevel !== targetThinking) {
+                    try {
+                        this.session.setThinkingLevel(targetThinking);
+                    }
+                    catch {
+                        /* 模型可能不支持该强度 */
+                    }
+                }
                 return;
+            }
             await this.session.setModel(model);
         }
         catch {
@@ -4571,21 +4828,39 @@ export class ClientSession {
         }
         return out;
     }
-    /** issue #145：本实例所有正在跑的对话摘要（elsewhere 列表的本机一半 +
-     *  手动过户的目标定位：convId + 是否有等答复问卷）。 */
+    /** issue #145：本实例别处可见的对话摘要（elsewhere 列表的本机一半 +
+     *  手动过户的目标定位：convId + 是否有等答复问卷）。
+     *
+     *  口径 = 运行中 + 已结束但本会话仍持有的可见对话（shownInRunningList：
+     *  listed 或当前有内容的对话；空白新对话不入列）。只推 running 时，对话
+     *  一结束 elsewhere 行就消失，另一处想过户查看只能趁运行中动手 —— 跑完
+     *  即失联。空闲行带 isStreaming:false + sessionFile，照样可过户（搬 runtime
+     *  本体，单 writer 不变；takeoverBriefs 本来就含空闲对话）。子代理不单列
+     *  （随主对话一起搬）。 */
     streamingSummariesAll() {
         const out = [];
         for (const conv of this.convs.values()) {
             if (conv.isSubagent)
                 continue;
-            if (!this.conversationStreaming(conv))
+            const streaming = this.conversationStreaming(conv);
+            if (!streaming && !this.shownInRunningList(conv))
                 continue;
+            const pq = this.getPendingQuestionForConv(conv.id);
+            let sessionFile;
+            try {
+                sessionFile = conv.session.sessionFile ?? undefined;
+            }
+            catch {
+                sessionFile = undefined;
+            }
             out.push({
                 title: conv.title,
                 cwd: conv.cwd,
-                isStreaming: true,
+                isStreaming: streaming,
                 convId: conv.id,
-                hasQuestion: this.isWaitingOnUser(conv.id),
+                hasQuestion: !!pq,
+                ...(pq?.title ? { questionTitle: pq.title } : {}),
+                ...(sessionFile ? { sessionFile } : {}),
             });
         }
         return out;
@@ -5347,11 +5622,12 @@ export class ClientSession {
         // Carry the model chosen in the active chat over to the new chat so it
         // doesn't silently revert to the ModelRuntime default model.
         const prevModel = this.conv.session.agent.state.model ?? null;
+        const prevThinking = this.conv.session.thinkingLevel ?? null;
         let ready = false;
         try {
             const conversationId = this.nextConversationId();
             const terminals = this.makeTerminalManager(conversationId, this.cwd);
-            const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(terminals, undefined, conversationId), {
+            const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(terminals, undefined, conversationId, prevModel ?? undefined), {
                 cwd: this.cwd,
                 agentDir: this.agentDir,
                 sessionManager: SessionManager.create(this.cwd),
@@ -5367,15 +5643,35 @@ export class ClientSession {
             this.invalidateSessionInfos();
             // New session seeds with the ModelRuntime default model — restore the
             // model the user had selected in the previous chat.
-            if (prevModel && this.sharedModelRuntime) {
+            let modelRestored = !!this.session.model;
+            if (!modelRestored && prevModel && this.sharedModelRuntime) {
                 try {
-                    await this.session.setModel(prevModel);
                     const p = prevModel.provider;
                     const mid = `${p}/${prevModel.id}`;
+                    // 先恢复 provider key，再 setModel（否则 checkAuth 鉴权失败）
                     await this.restoreKeyForModel(mid, this.cwd);
+                    await this.session.setModel(prevModel);
+                    modelRestored = true;
                 }
                 catch {
-                    // model no longer resolvable — keep the default
+                    // model no longer resolvable
+                }
+            }
+            if (!modelRestored) {
+                // 上个会话模型未能恢复（或无上个会话）：回落项目记忆或全局默认模型
+                try {
+                    await this.restoreProjectModelForCwd(this.cwd);
+                }
+                catch {
+                    /* 保持默认 */
+                }
+            }
+            if (prevThinking) {
+                try {
+                    this.session.setThinkingLevel(prevThinking);
+                }
+                catch {
+                    // model may not support previous thinking level
                 }
             }
             this.emitConversations();
@@ -5712,7 +6008,7 @@ export class ClientSession {
                 this.pendingQuestions.delete(qid);
                 questions.push({ resolve: p.resolve, questions: p.questions, conversationId: p.conversationId });
                 // 源页面的对话框可能是即时通道弹出的（live），快照为 null 收不掉它 ——
-                // 明确撤回，让源页面立即收起（目标页由转入方重推 question_pending）。
+                // 明确撤回，让源页面立即收起（目标页主对话由转入方重推 question_pending 或快照呈现）。
                 this.emit({ type: "question_retracted", id: qid });
             }
         }
@@ -5733,8 +6029,8 @@ export class ClientSession {
      * - id 冲突（两边计数器都从 c1 开始，大概率撞上）→ 给搬入方分配新 id，move
      *   集合内的 parentId/问卷归属同步改写。模型手里旧 runId 的后续子代理工具调用
      *   会报 unknown（可经列表查新 id）；定时唤醒的旧 id 同理回落无头执行。
-     * - 事件订阅/终端投递/问卷/页调用全部重接到本会话并立即重推（问卷对话框在新
-     *   页面直接弹出来）。看门狗按剩余时间重布（已逾期的立即触发）。
+     * - 事件订阅/终端投递/问卷/页调用全部重接到本会话，迁入的主对话立即触发弹窗
+     *   （子代理待答问卷通过角标与快照呈现）。看门狗按剩余时间重布（已逾期的立即触发）。
      */
     insertTakeoverConvs(payload) {
         const remap = new Map();
@@ -5758,7 +6054,10 @@ export class ClientSession {
             conv.unsubscribe = conv.session.subscribe((event) => this.onEvent(conv, event));
             for (const [toolCallId, start] of conv.toolStartTimes) {
                 if (!conv.toolWatchdogs.has(toolCallId)) {
-                    this.rearmToolWatchdog(conv, toolCallId, TOOL_WATCHDOG_TIMEOUT_MS - (Date.now() - start));
+                    const baseMs = this.getBaseToolWatchdogTimeoutMs();
+                    if (baseMs > 0) {
+                        this.rearmToolWatchdog(conv, toolCallId, baseMs - (Date.now() - start), baseMs);
+                    }
                 }
             }
             this.convs.set(conv.id, conv);
@@ -5767,12 +6066,23 @@ export class ClientSession {
             mainId = payload.convs[0]?.id ?? "";
         for (const q of payload.questions) {
             const nid = `q-${++this.questionSeq}`;
+            const qConvId = fix(q.conversationId);
             this.pendingQuestions.set(nid, {
                 resolve: q.resolve,
                 questions: q.questions,
-                conversationId: fix(q.conversationId),
+                conversationId: qConvId,
             });
-            this.emit({ type: "question_pending", id: nid, questions: q.questions });
+            // 迁入的主对话立即触发弹窗（子代理问卷留在后台，由角标与切换会话呈现）。
+            if (qConvId === mainId) {
+                const conv = this.convs.get(qConvId);
+                this.emit({
+                    type: "question_pending",
+                    id: nid,
+                    questions: q.questions,
+                    conversationId: qConvId,
+                    ...(conv?.title ? { conversationTitle: conv.title } : {}),
+                });
+            }
         }
         for (const p of payload.pageCalls) {
             const nid = `p-${++this.pageSeq}`;
@@ -5931,16 +6241,21 @@ export class ClientSession {
                 // 子代理带 error 标记：左栏红点提示（普通对话不参与）。
                 ...(conv.isSubagent ? this.subagentRunOutcome(conv) : {}),
                 // 等答复的问卷：左栏「?」角标（主对话/子代理各自挂名下，切过去即可回答）。
-                ...(this.isWaitingOnUser(conv.id) ? { hasQuestion: true } : {}),
+                ...(() => {
+                    const pq = this.getPendingQuestionForConv(conv.id);
+                    return pq ? { hasQuestion: true, questionId: pq.id, questionTitle: pq.title } : {};
+                })(),
                 parentId: conv.parentId,
             });
         }
         // issue #145：流式集合签名变化 → 通知其他客户端重推（左栏「另一处正在运行」近实时）。
         // 签名含等问卷态（问卷挂起/解决不改变流式集合，不带它已打开的别处页面永远看不到 `?`）。
+        // elsewhere 口径含已结束的空闲行：签名同样覆盖它们（流式位 + 等问卷位），
+        // 否则对方跑完（streaming→idle）或空闲行出现/消失时这边收不到重推。
         try {
             const sig = JSON.stringify([...this.convs.values()]
-                .filter((c) => this.conversationStreaming(c))
-                .map((c) => `${c.id}:${this.isWaitingOnUser(c.id) ? 1 : 0}`)
+                .filter((c) => this.conversationStreaming(c) || (!c.isSubagent && this.shownInRunningList(c)))
+                .map((c) => `${c.id}:${this.conversationStreaming(c) ? 1 : 0}:${this.isWaitingOnUser(c.id) ? 1 : 0}`)
                 .sort());
             if (sig !== this.lastRunningSig) {
                 this.lastRunningSig = sig;
@@ -6013,8 +6328,6 @@ export class ClientSession {
             void this.refreshSessions();
     }
     async pushSessions() {
-        if (!this.sessionsRequested)
-            return;
         if (!this.sessionsRequested)
             return;
         try {
@@ -6022,8 +6335,23 @@ export class ClientSession {
             // (<agentDir>/sessions/--<cwd>--/), the same files the pi CLI/TUI
             // use — one listing covers every conversation of the current folder.
             const infos = await this.loadSessionInfos();
+            // 隐藏「被 fork 掉的父会话」，历史列表只保留每条 fork 链最新的链尾会话
+            // （全文搜索 searchSessions 保留全部会话，不受此影响）。
+            const normSessionPath = (p) => String(p).replace(/\\/g, "/").replace(/\/$/, "").toLowerCase();
+            const forkedParentPaths = new Set();
+            for (const info of infos) {
+                if (typeof info.parentSessionPath === "string" && info.parentSessionPath) {
+                    forkedParentPaths.add(normSessionPath(info.parentSessionPath));
+                }
+            }
+            const visibleInfos = forkedParentPaths.size > 0
+                ? (() => {
+                    const kept = infos.filter((info) => !forkedParentPaths.has(normSessionPath(info.path)));
+                    return kept.length > 0 ? kept : infos;
+                })()
+                : infos;
             const sessions = new Map();
-            for (const s of infos) {
+            for (const s of visibleInfos) {
                 sessions.set(s.path, {
                     path: s.path,
                     name: s.name,
@@ -6255,6 +6583,84 @@ export class ClientSession {
             hasPendingWake: () => hasPendingWaitSubscription({ sessionId: conv.session.sessionFile }),
         });
     }
+    /**
+     * 将内存子代理（inMemory）固化为普通持久化对话：
+     * 写入磁盘 .jsonl 会话文件，清除 isSubagent 标记，使它进入历史会话列表并长久保留。
+     */
+    async persistConversation(id) {
+        const conv = this.convs.get(id);
+        if (!conv) {
+            this.emit({
+                type: "notice",
+                level: "warning",
+                text: "该对话不存在或已关闭",
+                textEn: "This conversation does not exist or is already closed",
+            });
+            return;
+        }
+        const sm = conv.session.sessionManager;
+        if (!conv.isSubagent && sm?.isPersisted?.()) {
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: `对话「${conv.title}」已是持久化对话，无需固化`,
+                textEn: `Conversation "${conv.title}" is already persistent`,
+            });
+            return;
+        }
+        try {
+            const cwd = conv.cwd || this.cwd;
+            const sampleSm = SessionManager.create(cwd);
+            const sessionDir = sampleSm.getSessionDir();
+            if (!existsSync(sessionDir)) {
+                mkdirSync(sessionDir, { recursive: true });
+            }
+            const timestamp = new Date().toISOString();
+            const fileTimestamp = timestamp.replace(/[:.]/g, "-");
+            const sessionId = sm?.getSessionId?.() || randomUUID();
+            const sessionFile = join(sessionDir, `${fileTimestamp}_${sessionId}.jsonl`);
+            // 获取所有已存在的 entries 并写盘
+            const entries = sm?.fileEntries ?? [];
+            let entriesToWrite = entries;
+            if (!entriesToWrite.some((e) => e?.type === "session")) {
+                const header = {
+                    type: "session",
+                    version: 3,
+                    id: sessionId,
+                    timestamp,
+                    cwd,
+                };
+                entriesToWrite = [header, ...entriesToWrite];
+            }
+            writeFileSync(sessionFile, entriesToWrite.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+            // 切换 SessionManager 内部状态，后续消息自动追加写盘
+            if (sm) {
+                sm.setSessionFile(sessionFile);
+                sm.sessionDir = sessionDir;
+                sm.persist = true;
+                sm.flushed = true;
+            }
+            conv.isSubagent = false;
+            this.emitConversations();
+            await this.pushProjects();
+            this.flushSnapshot();
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: `已将子代理「${conv.title}」固化为普通对话，并保存至历史记录`,
+                textEn: `Solidified subagent "${conv.title}" into a regular conversation saved to history`,
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `固化子代理失败：${msg}`,
+                textEn: `Failed to persist subagent: ${msg}`,
+            });
+        }
+    }
     /** Dismiss a running conversation from the left-panel list without deleting its
      *  transcript file. Only idle (non-streaming) conversations that are not
      *  retained by terminal/wake/review state can be dismissed. The session stays
@@ -6843,6 +7249,7 @@ export class ClientSession {
             // Preserve the model the user had selected — fork() seeds a new
             // branch with the ModelRuntime default model otherwise.
             const prevModel = this.session.agent.state.model ?? null;
+            const prevThinking = this.session.thinkingLevel ?? null;
             const result = await this.runtime.fork(entryId);
             if (result.cancelled) {
                 this.emit({
@@ -6858,14 +7265,23 @@ export class ClientSession {
             // Restore the previously-selected model on the forked branch.
             if (prevModel && this.sharedModelRuntime) {
                 try {
-                    await this.session.setModel(prevModel);
                     const pm = prevModel;
+                    // 先恢复 provider key，再 setModel（否则 checkAuth 鉴权失败）
                     await this.restoreKeyForModel(`${pm.provider}/${pm.id}`, this.cwd);
+                    await this.session.setModel(prevModel);
                 }
                 catch {
                     // model no longer resolvable — keep the default
                 }
             }
+            if (prevThinking) {
+                try {
+                    this.session.setThinkingLevel(prevThinking);
+                }
+                catch {
+                    // model no longer supports previous thinking level
+                }
+            }
             await this.prompt(trimmed, attachments);
             this.emit({
                 type: "notice",
@@ -7245,18 +7661,20 @@ export class ClientSession {
                 });
                 this.flushSnapshot();
                 // First visit to this project: resume its most recent session —
-                // unless that transcript is streaming on another client (#145):
+                // unless that transcript is still held on another client (#145):
                 // default-opening it would strand the tab on a conversation it
-                // cannot use (the prompt guard refuses) with a stale leaf that
-                // forks history once the owner finishes. Land blank instead.
+                // cannot use (the prompt guard refuses while streaming) with a
+                // stale leaf that forks history once both sides send (idle-held
+                // files fork the same way — 第二个写者不只跑着时才危险). Land
+                // blank instead.
                 let resumeSkipped = null;
-                // 无人在跑时不扫目录（首访切项目的常见情形零开销）。
-                if (this.hasStreamingElsewhere?.() ?? false) {
+                // 别处无可见行时不扫目录（首访切项目的常见情形零开销）。
+                if ((this.listExternalRunning?.() ?? []).length > 0) {
                     try {
                         const infos = await SessionManager.list(abs, piSessionsRoot());
                         const recent = infos[0]?.path ? resolve(infos[0].path) : undefined;
                         const owner = recent ? this.findSessionOwner?.(recent) : null;
-                        if (owner?.isStreaming) {
+                        if (owner && (owner.connected || owner.isStreaming)) {
                             resumeSkipped = owner;
                         }
                     }
@@ -7290,12 +7708,19 @@ export class ClientSession {
                 }
                 await this.bindSession();
                 if (resumeSkipped) {
-                    this.emit({
-                        type: "notice",
-                        level: "info",
-                        text: `该项目最近的对话「${resumeSkipped.title}」正在另一处运行，为你停在了新对话 —— 直接打开会造出第二个写者。左栏「运行的对话」里能看到它（标着“另一处”），等它跑完再打开。`,
-                        textEn: `The most recent conversation ("${resumeSkipped.title}") is running in another window, so you landed on a new chat instead — opening it here would create a second writer. It is listed under Running chats (tagged "Elsewhere"); open it after it finishes.`,
-                    });
+                    this.emit(resumeSkipped.isStreaming
+                        ? {
+                            type: "notice",
+                            level: "info",
+                            text: `该项目最近的对话「${resumeSkipped.title}」正在另一处运行，为你停在了新对话 —— 直接打开会造出第二个写者。左栏「运行的对话」里能看到它（标着“另一处”），等它跑完再打开。`,
+                            textEn: `The most recent conversation ("${resumeSkipped.title}") is running in another window, so you landed on a new chat instead — opening it here would create a second writer. It is listed under Running chats (tagged "Elsewhere"); open it after it finishes.`,
+                        }
+                        : {
+                            type: "notice",
+                            level: "info",
+                            text: `该项目最近的对话「${resumeSkipped.title}」在另一处开着（当前空闲），为你停在了空白新对话 —— 可在左栏「运行的对话」里把它过户过来继续看，或从历史对话里打开（只留一处发送消息，否则历史分叉）。`,
+                            textEn: `The most recent conversation ("${resumeSkipped.title}") is still open in another window (currently idle), so you landed on a blank chat instead — take it over from Running chats (tagged "Elsewhere") or reopen it from History (send new messages from only one place, or the history will fork).`,
+                        });
                 }
             }
             this.pushTerminals();
@@ -7442,8 +7867,9 @@ export class ClientSession {
             const model = mr.getModel(provider, id);
             if (!model)
                 throw new Error(`模型不存在：${modelId}`);
-            await this.session.setModel(model);
+            // 先恢复 provider key，再 setModel（否则 checkAuth 鉴权失败）
             await this.restoreKeyForModel(modelId, this.cwd);
+            await this.session.setModel(model);
             // Immediately remember the model + the key it uses for the current
             // project (not only after a turn). This is what makes project switching
             // restore both the model and the provider key.
@@ -7480,6 +7906,13 @@ export class ClientSession {
             const active = this.modelAdmin.getActiveKeyName(provider);
             if (active)
                 this.stateStore.saveDefaultProviderKey(provider, active);
+            // 同步写入 SDK 的 settingsManager，使底层 session 创建时 findInitialModel 也能识别该默认模型
+            try {
+                this.session.settingsManager.setDefaultModelAndProvider(provider, id);
+            }
+            catch {
+                /* 会话未就绪时忽略 */
+            }
             this.pushDefaultModel();
             this.emit({
                 type: "notice",
@@ -7501,6 +7934,12 @@ export class ClientSession {
     /** Clear the GLOBAL default model (new projects fall back to the SDK default). */
     clearDefaultModel() {
         this.stateStore.clearDefaultModel();
+        try {
+            this.session.settingsManager.setDefaultModelAndProvider(undefined, undefined);
+        }
+        catch {
+            /* 忽略 */
+        }
         this.pushDefaultModel();
         this.emit({
             type: "notice",
@@ -7536,7 +7975,12 @@ export class ClientSession {
     /** Set the thinking level for future turns. */
     setThinking(level) {
         try {
-            this.session.setThinkingLevel(level);
+            const thinkingLevel = level;
+            this.session.setThinkingLevel(thinkingLevel, { persist: true });
+            const cur = this.session.model;
+            if (cur) {
+                this.session.settingsManager.setModelThinkingLevel(cur.provider, cur.id, thinkingLevel);
+            }
         }
         catch (err) {
             this.emit({
@@ -7550,7 +7994,11 @@ export class ClientSession {
     }
     cycleThinking() {
         try {
-            this.session.cycleThinkingLevel();
+            const nextLevel = this.session.cycleThinkingLevel({ persist: true });
+            const cur = this.session.model;
+            if (cur && nextLevel) {
+                this.session.settingsManager.setModelThinkingLevel(cur.provider, cur.id, nextLevel);
+            }
         }
         catch (err) {
             this.emit({
@@ -8492,17 +8940,19 @@ export class AgentService {
                         }
                     }
                     // Sessions use the SDK default per-project dir — no per-client dir.
-                    // issue #145：新标签页默认恢复项目最近的会话 —— 若那条在别处跑着，
-                    // 建之前就决定空白（第二个 writer 根本不会被打开，也无需事后拆 runtime）。
-                    // 先做无 I/O 的便宜判断，无人在跑时不扫目录。
+                    // issue #145：新标签页默认恢复项目最近的会话 —— 若那条仍被别处持有
+                    // （跑着或空闲），建之前就决定空白（第二个 writer 根本不会被打开，
+                    // 也无需事后拆 runtime）。之前只拦 running：空闲持有照样恢复出双
+                    // writer，两边轮流发送分叉历史。其他客户端不存在时不扫目录。
                     let createOpts;
-                    if (this.hasStreamingElsewhere(clientId)) {
+                    if (this.clients.size > 0) {
                         try {
                             const infos = await SessionManager.list(cwd, piSessionsRoot());
                             const recent = infos[0]?.path ? resolve(infos[0].path) : undefined;
                             const owner = recent ? this.findSessionOwner(recent, clientId) : null;
-                            if (owner?.isStreaming)
-                                createOpts = { blank: true, blankTitle: owner.title };
+                            if (owner && (owner.connected || owner.isStreaming)) {
+                                createOpts = { blank: true, blankTitle: owner.title, ...(owner.isStreaming ? {} : { idleHeld: true }) };
+                            }
                         }
                         catch {
                             // 列表失败不挡正常恢复