pi-web-ui 0.91.0 → 0.93.0

package/dist/server/agent-service.js

@@ -35,19 +35,28 @@ 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";
 import { applyHeadTail, makePersistentTerminalTools, makeTerminalBashTool, stripAnsi, TERMINAL_TOOLS_GUIDANCE, } from "./terminals.js";
-import { applyAgentToolsGating, ASK_USER_QUESTION_TOOL_NAME, BROWSER_PAGE_TOOL_NAME, effectiveDisabledAgentTools, isTerminalGuidanceOn, MARKERS_LIST_TOOL_NAME, } from "./tool-manager.js";
+import { applyAgentToolsGating, ASK_USER_QUESTION_TOOL_NAME, BROWSER_PAGE_TOOL_NAME, effectiveDisabledAgentTools, isAgentToolEnabled, isTerminalGuidanceOn, MARKERS_LIST_TOOL_NAME, PRESENT_FILES_TOOL_NAME, } from "./tool-manager.js";
 import { WebUIContext } from "./webui-context.js";
 import { DEFAULT_COMPACTION_RESERVE_TOKENS, effectiveSoftCap, softCapToReserve } from "./soft-cap.js";
 import { decodeText } from "./text-sniff.js";
 import { makeEditSoftTool } from "./edit-soft-tool.js";
+// 覆盖 SDK 内置 read：路径是目录时列出目录条目（行为开关 readDirEnabled，默认开）。
+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";
+import { extractTouches, formatTouchesCompact, intersectTouches } from "./conversation-touches.js";
+import { ClaimStore, matchClaims, mergeTouchSidecar, readTouchSidecar, removeTouchSidecar } from "./claim-store.js";
+import { makeClaimFilesTool } from "./claim-files-tool.js";
 import { makeSkillTool } from "./skill-tool.js";
 import { makeScheduleTools } from "./schedule-agent-tool.js";
 import { sameSessionFile } from "./scheduler-tasks.js";
@@ -73,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;
@@ -85,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
@@ -217,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);
+        },
     };
 }
 /**
@@ -316,6 +343,10 @@ ownerId) {
         },
     };
 }
+/** 判定是否应当即时向前端推送问卷弹窗（只推给当前前台会话，未指定会话按全局放行）。 */
+export function shouldPopQuestion(conversationId, activeId) {
+    return conversationId === undefined || conversationId === activeId;
+}
 // ---------------------------------------------------------------------------
 // 浏览器页面工具（标准 pi 引擎的 browser_page customTool）
 //
@@ -643,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 后台任务，不参与此上限，既不占位也不被此上限拦截。 */
@@ -790,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) {
@@ -1037,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——后台对话产出时用户可能正
@@ -1053,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。
@@ -1167,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));
     }
@@ -1196,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",
@@ -1211,6 +1267,7 @@ export class ClientSession {
             model: conv.session.model?.id,
             output: conv.session.getLastAssistantText() ?? "",
             parentId: conv.parentId,
+            persisted: isPersisted,
         };
     }
     /** 子代理最近一次运行的结局：最后一条 assistant 消息的 errorMessage / stopReason。
@@ -1407,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)
@@ -1430,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 不可见）。
@@ -1510,16 +1568,8 @@ export class ClientSession {
                 const c = this.convs.get(id);
                 if (!c)
                     return undefined;
-                let raw = [];
-                try {
-                    raw = (c.session.messages ??
-                        c.session.agent.state.messages ??
-                        []);
-                }
-                catch {
-                    raw = [];
-                }
-                return { title: c.title, cwd: c.cwd, isSubagent: !!c.isSubagent, messages: raw.map(toTranscriptInput) };
+                // 取数与并行提醒的触碰集同一路径（convTranscript），不另起读取逻辑。
+                return { title: c.title, cwd: c.cwd, isSubagent: !!c.isSubagent, messages: this.convTranscript(c) };
             },
             listHistorySessions: async (scope, cwd) => {
                 const infos = scope === "all"
@@ -1534,6 +1584,29 @@ export class ClientSession {
                     cwd: s.cwd,
                 }));
             },
+            readTouchSidecar: (id, path) => {
+                // sidecar 让 files/status 在压缩后仍有答案（additive 可选方法：
+                // 读不到就回 undefined，调用方回落现算转录 —— 绝不抛错阻塞工具）。
+                try {
+                    if (id) {
+                        const c = this.convs.get(id);
+                        let file;
+                        try {
+                            file = c?.session.sessionFile ?? undefined;
+                        }
+                        catch {
+                            file = undefined;
+                        }
+                        return readTouchSidecar(file);
+                    }
+                    if (path)
+                        return readTouchSidecar(path);
+                    return undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            },
             readHistorySession: async (path) => {
                 const all = await SessionManager.listAll(piSessionsRoot());
                 const hit = all.find((s) => resolve(s.path) === resolve(path));
@@ -1556,6 +1629,28 @@ export class ClientSession {
             },
         };
     }
+    /** claim_files 工具的数据宿主：owner 口径同 subagent/skill（本 runtime 所属会话）。
+     *  常驻注册、不进 AGENT_TOOL_CATALOG（例外：目录工具必须有设置页行，见
+     *  settings-tool-rows.test.ts，而 web/src 正被并行任务占用；advisory 工具常驻
+     *  默认开可接受，目录项 + 设置行等 web/src 空出来后补）。 */
+    claimToolHost(ownerId) {
+        const target = () => {
+            try {
+                return (ownerId ?? "").trim() !== "" ? this.convs.get(ownerId.trim()) : this.convs.get(this.activeId);
+            }
+            catch {
+                return undefined;
+            }
+        };
+        return {
+            cwd: () => target()?.cwd ?? this.cwd,
+            self: () => {
+                const t = target();
+                return { convId: t?.id ?? this.activeId, title: t?.title ?? "" };
+            },
+            store: () => this.getClaimStore?.(),
+        };
+    }
     /** skill 工具的数据宿主：读所属会话 loader 的实时技能表 + 主会话禁用集过滤
      * （与 skillsOverride 主会话语义一致）。ownerId 语义同 browser_page（本
      * runtime 所属会话，不是派发瞬间的 active）。失败回空目录，不抛错。 */
@@ -1605,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). */
@@ -1808,14 +1906,22 @@ 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();
         await cs.restoreProjectProviderKeysForCwd(cwd);
@@ -1966,6 +2072,11 @@ export class ClientSession {
                     ],
                 },
             });
+            // 桥接工具目标（问卷 / 页面）：每次调用都解析「现在谁持有这条对话」，
+            // 而不是认这个 runtime 是在哪个 ClientSession 里建出来的（过户会换主）。
+            // anchor 在拿到 created.session 后回填（SDK 的 runtime.session 就是它）。
+            const bridgeAnchor = {};
+            const bridge = this.bridgeTarget(bridgeAnchor, ownerId);
             const created = await createAgentSessionFromServices({
                 services,
                 sessionManager,
@@ -1988,6 +2099,14 @@ export class ClientSession {
                     // 设置关 → 原生 bash；开 → 终端 bash。
                     () => this.settingsSvc.current.terminalBash),
                     ...makePersistentTerminalTools(terminals, effectiveCwd, () => this.getLang()),
+                    // 覆盖 SDK 内置 read（customTools 按 name 覆盖）：路径是目录时列出目录
+                    // 条目（复用 SDK ls 的排序/`/` 后缀/截断口径），其余情况原样转发内置实现。
+                    // 开关是行为开关（read 本体不可关），每次调用实时读设置——不进
+                    // tool-manager 的 ActiveSet 目录。DSH 引擎无 customTool 注册面，不接。
+                    makeReadDirTool(effectiveCwd, {
+                        dirEnabled: () => this.settingsSvc.current.readDirEnabled !== false,
+                        getLang: () => this.getLang(),
+                    }),
                     // 不覆盖内置 edit 的独立宽松编辑工具（缩进不敏感匹配；开关看设置）。
                     makeEditSoftTool(effectiveCwd, () => this.getLang()),
                     // 插件注册的 AI 工具（创建时刻的实时快照，已按 disabledPluginTools 过滤；
@@ -2017,16 +2136,38 @@ export class ClientSession {
                     // 标准引擎的 ask_user_question：模型调用 → 浏览器富渲染问卷（复用 DSH
                     // 的 question_pending/question_answer 协议，前端 DshQuestionDialog）。
                     // DSH 引擎不经此（它走 goal-rpc 的 userQuestions provider）。
-                    makeAskUserQuestionTool(this, ownerId),
+                    makeAskUserQuestionTool(bridge, ownerId),
                     // 浏览器页面工具：模型调用 → page_request 给浏览器 → page-picker 扩展
                     // 操作用户授权的页面 → page_response 回来。ownerId 语义同上（本 runtime
                     // 所属会话，不是派发瞬间的 active）。
-                    makeBrowserPageTool(this, ownerId),
+                    makeBrowserPageTool(bridge, ownerId),
                     // 别的对话读取（运行中含子代理 + 历史转录，只读）：用户引用了别的
                     // 对话（引用 chip / 粘过来的 id / “看看之前那个对话”）时用。子代理
                     // 会话同样注册了它，可自然嵌套读取。不需要 ownerId——读的是本
                     // 客户端的 conversation 体系与落盘历史，与派发者无关。
-                    makeConversationReadTool(this.conversationReadHost(), () => this.getLang()),
+                    // extras 认领表：files/status 顺带展示（AgentService 级共享）。
+                    makeConversationReadTool(this.conversationReadHost(), () => this.getLang(), {
+                        listClaims: (cwd) => (this.getClaimStore?.().list(cwd) ?? []).map((c) => ({
+                            path: c.path,
+                            ownerTitle: c.ownerTitle,
+                            ...(c.note ? { note: c.note } : {}),
+                        })),
+                    }),
+                    // 文件认领（claim_files）：开关走统一工具 tab（ActiveSet 门控）。
+                    // ownerId 语义同 subagent/skill（本 runtime 所属会话）。
+                    // DSH 引擎无 customTool 注册面，不接（提醒里照样能看到认领）。
+                    makeClaimFilesTool(this.claimToolHost(ownerId), () => this.getLang()),
+                    // 展示文件给用户（present_files，issue #231）：模型给路径清单，服务端
+                    // 只做只读探测（stat + 未知扩展嗅探 + 文本摘录），结构化 items 走 tool
+                    // result 的 details 下发，前端渲染成图片/视频内联 + 预览/本地打开/
+                    // 在文件夹中显示/下载/复制路径的卡片。不打开任何窗口，系统级动作
+                    // 一律由用户点卡片触发（file_open_default / file_reveal）。
+                    // 开关走统一工具 tab（ActiveSet 门控；enabled 兜底只做报错文案）。
+                    // DSH 引擎无 customTool 注册面，不接。
+                    makePresentFilesTool(effectiveCwd, {
+                        enabled: () => isAgentToolEnabled(PRESENT_FILES_TOOL_NAME, effectiveDisabledAgentTools(this.settingsSvc.current)),
+                        getLang: () => this.getLang(),
+                    }),
                     // 技能全文按名加载（名录在 {{skills}} 段）：模型不再拼路径调 read。
                     // 子代理会话同样注册（owner 即真正派发的父对话，读该会话 loader）。
                     // DSH 引擎无 customTool 注册面，不接。开关走统一工具 tab。
@@ -2038,6 +2179,9 @@ export class ClientSession {
                     ...makeScheduleTools(this.scheduleToolHost(), ownerId, () => this.getLang()),
                 ],
             });
+            // 桥接工具归属锚点：SDK 会话对象在本 runtime 生命周期内稳定，过户只搬对话
+            // 不改它（见 ClientSession.findConversationHome）。
+            bridgeAnchor.session = created.session;
             // 终端工具开关从创建起就生效（工具始终注册进注册表，只调活跃集）。
             this.applyToolGating(created.session);
             return {
@@ -2203,6 +2347,9 @@ export class ClientSession {
         // model picker needs it even before the client asks).
         this.modelAdmin.listProviderKeys();
         this.modelAdmin.listProviderOAuthFlows();
+        // Reconnect: push the global default model (the picker's ★ marker +
+        // "set as global default" button state).
+        this.pushDefaultModel();
         // PTYs are conversation-owned and survive a socket reconnect.
         this.pushTerminals();
     }
@@ -2286,25 +2433,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);
@@ -2385,9 +2555,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),
@@ -2700,7 +2873,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?.({
@@ -2815,7 +2988,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": {
@@ -2962,6 +3137,31 @@ export class ClientSession {
                     this.settingsSvc.consumePendingReload();
                     void this.applySettingsReload();
                 }
+                // 触碰 sidecar 落盘：压缩后旧消息被摘要替代，files 回落现算会丢历史；
+                // 条数没涨就不写（不在热路径）；子代理 inMemory 无转录文件，merge 内 no-op。
+                try {
+                    let count = conv.touchSidecarCount ?? -1;
+                    try {
+                        count = conv.session.getSessionStats().totalMessages;
+                    }
+                    catch {
+                        // 会话替换中 —— 按上次条数处理（多半直接跳过）
+                    }
+                    if (count !== (conv.touchSidecarCount ?? -1)) {
+                        conv.touchSidecarCount = count;
+                        let file;
+                        try {
+                            file = conv.session.sessionFile ?? undefined;
+                        }
+                        catch {
+                            file = undefined;
+                        }
+                        void mergeTouchSidecar(file, extractTouches(this.convTranscript(conv)));
+                    }
+                }
+                catch {
+                    // sidecar 只是加速 + 防压缩丢失，失败了下次重算
+                }
                 break;
             }
             case "entry_appended": {
@@ -3038,7 +3238,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 {
@@ -3062,6 +3262,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" ||
@@ -3105,8 +3315,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
@@ -3119,8 +3332,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
@@ -3128,28 +3346,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).
@@ -3160,13 +3367,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.
@@ -3176,6 +3391,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;
@@ -3188,7 +3424,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,
@@ -3326,6 +3562,37 @@ export class ClientSession {
     // -----------------------------------------------------------------------
     // 用户提问桥（标准 pi 引擎 ask_user_question customTool）
     // -----------------------------------------------------------------------
+    /**
+     * 桥接工具目标（ask_user_question / browser_page）：**调用瞬间**按 runtime 身份
+     *  解析当前持有它的会话与对话 id，而不是用建 runtime 时捕获的 `this` + ownerId
+     *  （过户会把 runtime 搬到另一个 ClientSession，闭包里的会话引用与 id 都不跟着
+     *  搬 —— 详见 findConversationHome）。
+     *
+     *  工厂（makeAskUserQuestionTool / makeBrowserPageTool）是鸭子类型，只要求这几个
+     *  方法，所以这里给的是一个按需转发的小适配器：工厂传进来的 convId 是**建时**的
+     *  旧 id（过户撞车改名后它要么查不到、要么撞到别的对话），一律以解析结果为准。
+     *  解析不到（未接线 / 会话被替换 / 对话已关闭）时兜底建时的会话与 id —— 与改动前
+     *  行为一致。anchor 由 runtime 创建处在拿到 `created.session` 后回填。
+     */
+    bridgeTarget(anchor, ownerId) {
+        const home = () => {
+            const found = anchor.session ? this.findConversationHome?.(anchor.session) : undefined;
+            return found ?? { session: this, convId: ownerId };
+        };
+        return {
+            askUser: (questions, sig) => {
+                const h = home();
+                return h.session.askUser(questions, sig, h.convId);
+            },
+            pageCall: (req, sig) => {
+                const h = home();
+                return h.session.pageCall(req, sig, h.convId);
+            },
+            // 截图「给图还是走视觉桥」按当前持有方的模型与设置判定（过户后由它驱动）。
+            canSeeImages: () => home().session.canSeeImages(),
+            transcribeToolImage: (image, signal) => home().session.transcribeToolImage(image, signal),
+        };
+    }
     /** 标准引擎模型调 ask_user_question：发 question_pending 给浏览器并阻塞等待
      *  question_answer。sig 为工具执行信号的当前状态（aborted → 立即 reject）。
      *  返回 answers（用户选中/自定义），或 null（用户取消）。
@@ -3349,11 +3616,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 需匹配
@@ -3378,7 +3652,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;
     }
@@ -3399,14 +3680,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() {
@@ -3651,6 +3952,22 @@ export class ClientSession {
      *  attach 时由 AgentService 接到全局 onClientCwdChanged —— 编辑器等
      *  工作区跟随型插件借此把根目录切到用户当前项目。 */
     onCwdChanged = undefined;
+    /** 过户后的桥接投递解析（attach 时由 AgentService 接线）：给一个 SDK 会话（＝
+     *  一个 runtime 的身份），返回**当前**持有它的客户端会话 + 该对话**当前** id。
+     *
+     *  为什么需要它：runtime 创建时把 `this`（当时的 ClientSession）与当时的
+     *  conversationId 闭包进桥接工具（ask_user_question / browser_page），而
+     *  `take_over_conversation` 只搬对话（runtime/终端/订阅/看门狗/在途问卷与页
+     *  调用），搬不动闭包里的会话引用。过户后模型再提问/截图，用捕获的 `this` 就会把
+     *  question_pending / page_request 推给过户前那台设备 —— 持有方收不到，问卷还会
+     *  挂在老设备的注册表里（且不进它的快照：该 conv 已不在它名下）→ 刷新即丢，
+     *  而 pi 引擎问卷不超时，那一轮 run 就永远挂住。
+     *
+     *  用 SDK 会话对象（稳定标识）而不是建时的 conversationId：过户遇到 id 撞车会把
+     *  对话改名（c1→c2），那时旧 id 要么查不到、要么查到老会话里的另一条对话，都会
+     *  投错。（注意不能用 runtime 对象比：SDK 会把工厂返回值包成新的 AgentSessionRuntime
+     *  实例，而 `runtime.session` 与本工厂的 `created.session` 是同一个对象。） */
+    findConversationHome = undefined;
     /** issue #145 跨客户端同会话感知 —— attach 时由 AgentService 接线：
      *  - findSessionOwner：别处是否已持有同一 session 文件（查重建第二个 writer 用）；
      *  - listProjectRunners：别处在同一 cwd 下正在跑的对话（同项目并行感知用）；
@@ -3665,6 +3982,8 @@ export class ClientSession {
     /** issue #145：除本客户端外是否有人在跑（扫目录查重前置的无 I/O 判断）。 */
     hasStreamingElsewhere = undefined;
     listProjectRunners = undefined;
+    /** issue #145 同款接线：全局认领表（AgentService 级单例，attach 时由 AgentService 接线）。 */
+    getClaimStore = undefined;
     listExternalRunning = undefined;
     notifyExternalClients = undefined;
     onRunningChanged = undefined;
@@ -3805,6 +4124,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;
@@ -3878,6 +4213,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). */
@@ -3889,8 +4247,12 @@ export class ClientSession {
         await this.modelAdmin.clearProviderApiKey(provider);
         // The provider is back to unconfigured — drop its key preference in
         // EVERY project, otherwise each project switch re-tries a restore.
-        if (!usingOAuth)
+        if (!usingOAuth) {
             this.stateStore.deleteProviderEverywhere(provider.trim());
+            const defKey = this.stateStore.getDefaultProviderKey(provider.trim());
+            if (defKey)
+                this.stateStore.repointDeletedKeyInDefault(provider.trim(), defKey, null);
+        }
     }
     startProviderOAuth(provider) {
         this.modelAdmin.startProviderOAuth(provider);
@@ -3937,6 +4299,14 @@ export class ClientSession {
     cloneProvider(providerId, reqId) {
         return this.modelAdmin.cloneProvider(providerId, reqId);
     }
+    /** Enrich custom-provider draft rows from public catalogs (enrich_models_result). */
+    enrichModels(reqId, ids, hints) {
+        return this.modelAdmin.enrichModels(reqId, ids, hints, () => this.getLang());
+    }
+    /** Abort in-flight enrich_models request. */
+    abortEnrichModels(reqId) {
+        this.modelAdmin.abortEnrichModels(reqId);
+    }
     saveModelConfig(providerId, config) {
         return this.modelAdmin.saveModelConfig(providerId, config);
     }
@@ -3968,6 +4338,7 @@ export class ClientSession {
         // (or drop the pin when no keys remain), not just the current one.
         const active = this.modelAdmin.getActiveKeyName(provider);
         this.stateStore.repointDeletedKeyEverywhere(provider, keyName, active);
+        this.stateStore.repointDeletedKeyInDefault(provider, keyName, active);
     }
     /** Restore per-project provider keys when entering a project. For each
      *  provider that has a saved key for `cwd`, activate it if it differs from
@@ -3992,25 +4363,40 @@ export class ClientSession {
         }
     }
     /** When a model is set, ensure its provider's per-project key is restored.
-     *  Silent + self-healing like the bulk restore above. */
+     *  Silent + self-healing like the bulk restore above. Falls back to the
+     *  GLOBAL default key when the project has no pin for this provider (new
+     *  project following the global default model). */
     async restoreKeyForModel(modelId, cwd) {
         const slash = modelId.indexOf("/");
         if (slash <= 0)
             return;
         const provider = modelId.slice(0, slash);
-        const saved = this.stateStore.getProjectProviderKey(this.clientId, cwd, provider);
-        if (!saved)
+        const projectPin = this.stateStore.getProjectProviderKey(this.clientId, cwd, provider);
+        if (projectPin) {
+            const cur = this.modelAdmin.getActiveKeyName(provider);
+            if (cur === projectPin)
+                return;
+            if (!this.modelAdmin.hasProviderKey(provider, projectPin)) {
+                this.stateStore.deleteProjectProviderKey(this.clientId, cwd, provider);
+                return;
+            }
+            const ok = await this.modelAdmin.activateProviderKey(provider, projectPin, { silent: true });
+            if (!ok)
+                this.stateStore.deleteProjectProviderKey(this.clientId, cwd, provider);
             return;
-        const cur = this.modelAdmin.getActiveKeyName(provider);
-        if (cur === saved)
+        }
+        // No project pin — follow the global default key (if any). No
+        // self-healing deletes here: the ref belongs to the global default,
+        // not this project (key deletions already repoint it, see
+        // repointDeletedKeyInDefault).
+        const globalPin = this.stateStore.getDefaultProviderKey(provider);
+        if (!globalPin)
             return;
-        if (!this.modelAdmin.hasProviderKey(provider, saved)) {
-            this.stateStore.deleteProjectProviderKey(this.clientId, cwd, provider);
+        if (this.modelAdmin.getActiveKeyName(provider) === globalPin)
             return;
-        }
-        const ok = await this.modelAdmin.activateProviderKey(provider, saved, { silent: true });
-        if (!ok)
-            this.stateStore.deleteProjectProviderKey(this.clientId, cwd, provider);
+        if (!this.modelAdmin.hasProviderKey(provider, globalPin))
+            return;
+        await this.modelAdmin.activateProviderKey(provider, globalPin, { silent: true });
     }
     /** Remember the just-selected model (and the key that was active for its
      *  provider) for the current project. Called IMMEDIATELY on model selection —
@@ -4034,9 +4420,10 @@ export class ClientSession {
      *  own per-session model: switching back to a RUNNING / completed chat must not
      *  silently overwrite its model with the project default. So a fresh chat in the
      *  project gets the remembered model; an in-progress one keeps what it had and
-     *  the user switches via the picker. Silent on failure (model no longer in catalog). */
+     *  the user switches via the picker. Silent on failure (model no longer in catalog).
+     *  Fallback chain: project memory > GLOBAL default model > SDK default (no-op). */
     async restoreProjectModelForCwd(cwd) {
-        const savedModel = this.stateStore.getProjectModel(this.clientId, cwd);
+        const savedModel = this.stateStore.getProjectModel(this.clientId, cwd) ?? this.stateStore.getDefaultModel();
         if (!savedModel)
             return;
         try {
@@ -4058,8 +4445,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 {
@@ -4338,6 +4737,21 @@ export class ClientSession {
             return false;
         }
     }
+    /** 某对话的转录最小结构（内存实时消息，含未落盘的；与 conversationReadHost
+     *  的 readRunningConversation 同一取数逻辑 —— 并行提醒算触碰集时复用，
+     *  不另起读取路径）。 */
+    convTranscript(conv) {
+        let raw = [];
+        try {
+            raw = (conv.session.messages ??
+                conv.session.agent.state.messages ??
+                []);
+        }
+        catch {
+            raw = [];
+        }
+        return raw.map(toTranscriptInput);
+    }
     /** issue #145：当前活动对话的 session 文件（resolved），无则 undefined。 */
     activeSessionFileResolved() {
         try {
@@ -4368,21 +4782,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;
@@ -4503,32 +4935,133 @@ export class ClientSession {
             // 通告一次（steer/排队等流式中发送不重复打扰）。
             // parallelReminderEnabled=false 时整段跳过（不发 notice、不注 AI、不通知对端）。
             if (!conv.isSubagent && !s.isStreaming && this.settingsSvc.current.parallelReminderEnabled !== false) {
+                // 认领心跳：本对话发 prompt = 还活着，自己名下的认领续期（同步内存操作）。
+                try {
+                    this.getClaimStore?.().touch(conv.id);
+                }
+                catch {
+                    // ignore
+                }
+                let projectClaims = [];
+                try {
+                    projectClaims = this.getClaimStore?.().list(conv.cwd) ?? [];
+                }
+                catch {
+                    projectClaims = [];
+                }
+                // 本窗口正在跑的：子代理也算进来（以前 !c.isSubagent 把它们排除在外，
+                // 对方用子代理干活时 AI 完全收不到提示），标明归属。触碰集就地从内存
+                // 消息算，无 I/O，不阻塞发送路径。
                 const localRunners = [...this.convs.values()]
-                    .filter((c) => c.id !== conv.id && !c.isSubagent && c.cwd === conv.cwd && this.conversationStreaming(c))
-                    .map((c) => ({ title: c.title }));
+                    .filter((c) => c.id !== conv.id && c.cwd === conv.cwd && this.conversationStreaming(c))
+                    .map((c) => {
+                    let label;
+                    if (c.isSubagent) {
+                        const parent = c.parentId ? this.convs.get(c.parentId) : undefined;
+                        label = parent ? `本窗口「${parent.title}」的子代理「${c.title}」` : `本窗口子代理「${c.title}」`;
+                    }
+                    else {
+                        label = `本窗口「${c.title}」`;
+                    }
+                    return { label, touches: extractTouches(this.convTranscript(c)) };
+                });
                 const externalRunners = (this.listProjectRunners?.(conv.cwd) ?? []).filter((r) => r.sessionFile === undefined || (activeFile !== undefined && resolve(r.sessionFile) !== activeFile));
-                const runnerTitles = [
-                    ...localRunners.map((r) => `本窗口「${r.title}」`),
+                // 取舍（诚实降级）：外部运行只有 title + sessionFile，触碰集要读对方
+                // 转录文件 —— 同步文件 I/O 会阻塞发送路径，不做；提醒里如实写
+                // 「外部运行的文件触碰未知」，不编造。
+                // 每条 ≤60 字符（以前整串 slice(0, 600)，经常从半截路径处拦腰截断）。
+                const capItem = (st) => (st.length <= 60 ? st : `${st.slice(0, 59)}…`);
+                const noticeTitles = [
+                    ...localRunners.map((r) => r.label),
                     ...externalRunners.map((r) => `另一处「${r.title}」`),
-                ];
-                if (runnerTitles.length > 0) {
-                    const shown = runnerTitles.slice(0, 3).join("、");
-                    const more = runnerTitles.length > 3 ? `等 ${runnerTitles.length} 处` : "";
+                ].map(capItem);
+                const aiItems = [
+                    ...localRunners.map((r) => `${r.label}·${r.touches.length} files`),
+                    ...externalRunners.map((r) => `另一处「${r.title}」·touches unknown`),
+                ].map(capItem);
+                if (noticeTitles.length > 0) {
+                    const shown = noticeTitles.slice(0, 3).join("、");
+                    const more = noticeTitles.length > 3 ? `等 ${noticeTitles.length} 处` : "";
                     this.emit({
                         type: "notice",
                         level: "info",
                         text: `同项目并行提醒：${shown}${more}正在同一项目运行。你可以继续（适合改不同文件），改动同一文件前请先确认；拿不准就等它跑完。`,
                         textEn: `Parallel-work notice: ${shown}${more ? " and more" : ""} running in the same project. You may continue (fine for different files); confirm before touching the same files, or wait for it to finish when unsure.`,
                     });
-                    // 给 AI 的上下文：评估冲突概率，拿不准就 ask_user_question 让用户选
-                    // （并行 / 等它跑完 / 只读围观）。display:false —— 用户界面只看上面的 notice。
-                    const aiReminder = `(System reminder: ${runnerTitles.length} other run(s) [${runnerTitles.join("; ").slice(0, 600)}] ` +
-                        `are currently running in the same project directory. You may work in parallel on different files, ` +
-                        `but before reading/writing files or running commands, assess the conflict probability with the other run(s) ` +
-                        `(same files? same commands? migrations?). If a conflict is likely or you are unsure, ` +
-                        `use ask_user_question to let the user choose: continue in parallel / wait / watch read-only.)\n` +
-                        `（系统提醒：同一项目另有 ${runnerTitles.length} 处运行（${shown}${more}）。改不同文件可并行；` +
-                        `读写文件或跑命令前先评估冲突概率，拿不准就用 ask_user_question 让用户选择：并行 / 等它跑完 / 只读围观。）`;
+                    // 给 AI 的上下文：交集由服务端算好写明“⚠ 双方都动过 X”，AI 不用自己
+                    // 算；拿不准就 ask_user_question 让用户选（并行 / 等它跑完 / 只读围观）。
+                    // display:false —— 用户界面只看上面的 notice。分两档：无交集只给一行
+                    // （省 token），有交集才展开细节。
+                    const mine = extractTouches(this.convTranscript(conv));
+                    // 认领升级（advisory，但比触碰更强：这是对方的事前意图）：
+                    // 我动过 + 对方认领 → 最强信号单独点名；其他认领只给一行汇总。
+                    const othersClaims = projectClaims.filter((c) => c.ownerConvId !== conv.id);
+                    const myClaimed = matchClaims(mine, othersClaims.map((c) => ({
+                        path: c.path,
+                        ownerConvId: c.ownerConvId,
+                        ownerTitle: c.ownerTitle,
+                        claimedAt: 0,
+                        expiresAt: 0,
+                    })), conv.cwd);
+                    const claimHitEn = myClaimed
+                        .slice(0, 3)
+                        .map((h) => `${h.touch.path} (claimed by ${h.claim.ownerTitle})`)
+                        .join("; ");
+                    const claimHitZh = myClaimed
+                        .slice(0, 3)
+                        .map((h) => `${h.touch.path}（${h.claim.ownerTitle}已认领）`)
+                        .join("、");
+                    const claimMore = myClaimed.length > 3 ? ` (+${myClaimed.length - 3})` : "";
+                    const claimsSummaryEn = othersClaims.length > 0
+                        ? ` Claimed by others (steer clear): ${othersClaims
+                            .slice(0, 3)
+                            .map((c) => `${c.path} ("${c.ownerTitle}")`)
+                            .join("; ")}${othersClaims.length > 3 ? ` (+${othersClaims.length - 3})` : ""}.`
+                        : "";
+                    const claimsSummaryZh = othersClaims.length > 0
+                        ? ` 对方认领（绕行）：${othersClaims
+                            .slice(0, 3)
+                            .map((c) => `${c.path}（「${c.ownerTitle}」）`)
+                            .join("、")}${othersClaims.length > 3 ? `（等 ${othersClaims.length - 3} 处）` : ""}。`
+                        : "";
+                    const clashes = localRunners
+                        .map((r) => ({ label: r.label, hits: intersectTouches(r.touches, mine) }))
+                        .filter((r) => r.hits.length > 0);
+                    const extNoteEn = externalRunners.length > 0 ? ` Touched files of external run(s) are unknown.` : "";
+                    const extNoteZh = externalRunners.length > 0 ? `外部运行的文件触碰未知。` : "";
+                    let aiReminder;
+                    if (clashes.length === 0 && myClaimed.length === 0) {
+                        aiReminder =
+                            `(System reminder: ${aiItems.length} other run(s) [${aiItems.join("; ")}] ` +
+                                `are currently running in the same project directory. No file written by both you and them was detected, ` +
+                                `so working on different files in parallel is fine; before writing the same files or running project-wide ` +
+                                `commands, assess the conflict risk first, and use ask_user_question when unsure ` +
+                                `(continue in parallel / wait / watch read-only).${extNoteEn}${claimsSummaryEn})\n` +
+                                `（系统提醒：同一项目另有 ${aiItems.length} 处运行（${shown}${more}）。未发现双方都写过的文件，` +
+                                `改不同文件可并行；动同一文件或跑全局命令前先评估冲突，拿不准就用 ask_user_question 让用户选择：` +
+                                `并行 / 等它跑完 / 只读围观。${extNoteZh}${claimsSummaryZh}）`;
+                    }
+                    else {
+                        // 有交集档：每处 ≤3 条完整路径 + 计数（路径永不截断，见 conversation-touches）。
+                        const clashPartsEn = clashes.map((h) => `${h.label} — you both wrote: ${formatTouchesCompact(h.hits)}`);
+                        if (myClaimed.length > 0) {
+                            clashPartsEn.push(`⚠ you touched and others claimed: ${claimHitEn}${claimMore} — ask the user before touching these again`);
+                        }
+                        const clashEn = clashPartsEn.join("; ");
+                        const clashPartsZh = clashes.map((h) => `⚠ ${h.label}双方都动过：${formatTouchesCompact(h.hits)}`);
+                        if (myClaimed.length > 0) {
+                            clashPartsZh.push(`⚠ 你动过、对方已认领：${claimHitZh}${claimMore} —— 动之前先问用户`);
+                        }
+                        const clashZh = clashPartsZh.join("；");
+                        aiReminder =
+                            `(System reminder: ${aiItems.length} other run(s) [${aiItems.join("; ")}] ` +
+                                `are currently running in the same project directory. ⚠ ${clashEn} — re-read these files before ` +
+                                `touching them again, and use ask_user_question when unsure ` +
+                                `(continue in parallel / wait / watch read-only).${extNoteEn})\n` +
+                                `（系统提醒：同一项目另有 ${aiItems.length} 处运行（${shown}${more}）。` +
+                                `${clashZh} —— 再动这些文件前先读最新内容，拿不准就用 ask_user_question 让用户选择：` +
+                                `并行 / 等它跑完 / 只读围观。${extNoteZh}）`;
+                    }
                     try {
                         await s.sendCustomMessage({
                             customType: "parallel-work-reminder",
@@ -5043,6 +5576,7 @@ 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();
@@ -5074,6 +5608,14 @@ export class ClientSession {
                     // model no longer resolvable — keep the default
                 }
             }
+            if (prevThinking) {
+                try {
+                    this.session.setThinkingLevel(prevThinking);
+                }
+                catch {
+                    // model may not support previous thinking level
+                }
+            }
             this.emitConversations();
             this.goalSvc.emitGoalStatus();
             this.pushTerminals();
@@ -5340,6 +5882,14 @@ export class ClientSession {
         const conv = this.convs.get(id);
         if (!conv || id === this.activeId)
             return;
+        // 对话真关闭（dismiss/释放）→ 放掉它的认领。过户不走这里（对话换个会话
+        // 继续，owner 不变，认领继续有效），所以只在此处释放。
+        try {
+            this.getClaimStore?.().releaseByOwner(id);
+        }
+        catch {
+            // ignore
+        }
         this.convs.delete(id);
         this.clearAllToolWatchdogs(conv);
         conv.terminals.killAll();
@@ -5347,6 +5897,15 @@ export class ClientSession {
         conv.unsubscribe = undefined;
         void conv.runtime.dispose().catch(() => { });
     }
+    /** 本会话是否持有这个 SDK 会话对应的对话；命中则给出它的**当前** id
+     *  （AgentService 按 runtime 身份解析过户后的归属方用，见 findConversationHome）。 */
+    conversationIdOfSession(sdkSession) {
+        for (const c of this.convs.values()) {
+            if (c.session === sdkSession)
+                return c.id;
+        }
+        return undefined;
+    }
     /** 过户用的对话摘要（AgentService 拼移动集合 + 容量检查用）。 */
     takeoverBriefs() {
         return [...this.convs.values()].map((c) => ({
@@ -5391,7 +5950,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 });
             }
         }
@@ -5412,8 +5971,8 @@ export class ClientSession {
      * - id 冲突（两边计数器都从 c1 开始，大概率撞上）→ 给搬入方分配新 id，move
      *   集合内的 parentId/问卷归属同步改写。模型手里旧 runId 的后续子代理工具调用
      *   会报 unknown（可经列表查新 id）；定时唤醒的旧 id 同理回落无头执行。
-     * - 事件订阅/终端投递/问卷/页调用全部重接到本会话并立即重推（问卷对话框在新
-     *   页面直接弹出来）。看门狗按剩余时间重布（已逾期的立即触发）。
+     * - 事件订阅/终端投递/问卷/页调用全部重接到本会话，迁入的主对话立即触发弹窗
+     *   （子代理待答问卷通过角标与快照呈现）。看门狗按剩余时间重布（已逾期的立即触发）。
      */
     insertTakeoverConvs(payload) {
         const remap = new Map();
@@ -5437,7 +5996,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);
@@ -5446,12 +6008,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}`;
@@ -5610,16 +6183,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;
@@ -5692,8 +6270,6 @@ export class ClientSession {
             void this.refreshSessions();
     }
     async pushSessions() {
-        if (!this.sessionsRequested)
-            return;
         if (!this.sessionsRequested)
             return;
         try {
@@ -5701,8 +6277,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,
@@ -5807,6 +6398,8 @@ export class ClientSession {
                 }
             }
             rmSync(abs, { force: true });
+            // 转录删了，sidecar 再留着就是孤儿，一起清掉（不存在不报错）。
+            removeTouchSidecar(abs);
             // 转录删了，未发送草稿再留着就是孤儿，一起清掉。
             try {
                 this.drafts.pruneSessionFile(abs);
@@ -5932,6 +6525,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
@@ -6520,6 +7191,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({
@@ -6543,6 +7215,14 @@ export class ClientSession {
                     // 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",
@@ -6922,18 +7602,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;
                         }
                     }
@@ -6967,12 +7649,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();
@@ -7138,6 +7827,59 @@ export class ClientSession {
         }
         this.flushSnapshot();
     }
+    /** Set the GLOBAL default model ("provider/id"): projects with no memory
+     *  fall back to it (project memory wins). Also remembers the provider's
+     *  currently-active key globally so new projects restore the same {model,
+     *  key} pair. Shared across clients, persisted server-side. */
+    async setDefaultModel(modelId) {
+        try {
+            const mr = this.runtime.services.modelRuntime;
+            const slash = modelId.indexOf("/");
+            if (slash <= 0 || slash === modelId.length - 1) {
+                throw new Error(`无效的模型 ID：${modelId}`);
+            }
+            const provider = modelId.slice(0, slash);
+            const id = modelId.slice(slash + 1);
+            if (!mr.getModel(provider, id))
+                throw new Error(`模型不存在：${modelId}`);
+            this.stateStore.saveDefaultModel(modelId);
+            const active = this.modelAdmin.getActiveKeyName(provider);
+            if (active)
+                this.stateStore.saveDefaultProviderKey(provider, active);
+            this.pushDefaultModel();
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: `🌍 已设全局默认模型 ${modelId}（新项目自动使用，项目记忆优先）`,
+                textEn: `🌍 Global default model set to ${modelId} (new projects follow it; project memory wins)`,
+            });
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `设置全局默认模型失败：${err.message}`,
+                textEn: `Failed to set global default model: ${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /** Clear the GLOBAL default model (new projects fall back to the SDK default). */
+    clearDefaultModel() {
+        this.stateStore.clearDefaultModel();
+        this.pushDefaultModel();
+        this.emit({
+            type: "notice",
+            level: "info",
+            text: "🌍 已清除全局默认模型（新项目回到 SDK 默认）",
+            textEn: "🌍 Global default model cleared (new projects use the SDK default)",
+        });
+        this.flushSnapshot();
+    }
+    /** Push the current global default model (attach + after every change). */
+    pushDefaultModel() {
+        this.emit({ type: "default_model", modelId: this.stateStore.getDefaultModel() ?? null });
+    }
     /** 切换模型，失败时抛出（无头路径专用：插件 host.chat / 定时任务）。
      *  setModel 为兼容 UI 把异常吞成 notice（面板要能看到原因、调用方是 fire-and-forget），
      *  无头路径拿不到那个 notice，于是「模型 ID 打错/没配密钥」会变成静默按旧模型跑 ——
@@ -7160,7 +7902,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({
@@ -7174,7 +7921,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({
@@ -7302,6 +8053,8 @@ export class AgentService {
     /** index.ts 注入：内置调度存储（attach 时拷贝到每个新会话，供 schedule_* 工具）。 */
     schedulerStore = undefined;
     clients = new Map();
+    /** 全局认领表（跨浏览器标签页共享；<dataDir>/claims.json，best-effort 持久化）。 */
+    claimStore;
     /** Quiesce (draining) state — the service refuses NEW work (prompts, forks,
      *  session resumes, new clients) so a deploy/upgrade/backup can stop cleanly
      *  once existing runs finish. Controlled via the local control socket:
@@ -7322,6 +8075,7 @@ export class AgentService {
     constructor(cwd, stateFile) {
         this.cwd = cwd;
         this.stateStore = new ClientStateStore(stateFile);
+        this.claimStore = new ClaimStore(join(this.stateStore.dataDir, "claims.json"));
     }
     /** Get or create the session for a client, racing attach calls safely. */
     /** True while the service is draining — new work is refused. */
@@ -7567,6 +8321,23 @@ export class AgentService {
         }
         return out;
     }
+    /** 按 SDK 会话（runtime 身份）找它当前归属的客户端会话与对话 id（过户后归属会变）：
+     *  桥接工具（问卷 / 页面）在调用瞬间用它投递，见 ClientSession.bridgeTarget。
+     *  一条对话任一时刻只属于一个会话（过户先摘后插），扫一遍即可 —— 问卷/截图都是
+     *  低频调用，不值得为此再维护一张全局索引。 */
+    findConversationHome(sdkSession) {
+        for (const cs of this.clients.values()) {
+            try {
+                const convId = cs.conversationIdOfSession(sdkSession);
+                if (convId)
+                    return { session: cs, convId };
+            }
+            catch {
+                // 单客户端坏了不影响解析
+            }
+        }
+        return undefined;
+    }
     /** issue #145：别处所有正在跑的对话（左栏 elsewhere 只读感知 + 手动过户用）。
      *  owner/convId 标识过户目标（手动过户入口）；DSH 引擎不填（不可过户）。 */
     listExternalRunning(excludeClientId) {
@@ -7896,6 +8667,8 @@ export class AgentService {
         cs.findSessionOwner = (targetPath) => this.findSessionOwner(targetPath, clientId);
         cs.hasStreamingElsewhere = () => this.hasStreamingElsewhere(clientId);
         cs.listProjectRunners = (cwd) => this.listProjectRunners(cwd, clientId);
+        cs.getClaimStore = () => this.claimStore;
+        cs.findConversationHome = (sdkSession) => this.findConversationHome(sdkSession);
         cs.listExternalRunning = () => this.listExternalRunning(clientId);
         cs.notifyExternalClients = (msg) => this.notifyClientsExcept(clientId, msg);
         cs.onRunningChanged = () => this.pokeExternalRunning(clientId);
@@ -8094,17 +8867,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 {
                             // 列表失败不挡正常恢复