pi-web-ui 0.90.1 → 0.92.0

package/dist/server/agent-service.js

@@ -15,7 +15,7 @@
 // wholesale (no union merge / no stale built-in leftovers).
 import "./patch-remote-catalog.js";
 import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
 import { appendFileSync, existsSync, readFileSync, rmSync, statSync, mkdirSync, watch, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -26,6 +26,7 @@ import { Type } from "typebox";
 import { BgServerTracker } from "./bg-servers.js";
 import { checkAll as checkAllUpdates, collectTargets, compareVersions as compareSemver, resolveNpmRegistry, sortUpdateItems, } from "./update-check.js";
 import { hasActiveSubagentRun, hasPendingWaitSubscription, shouldRetainActive } from "./wait-subscription-scan.js";
+import { COMPACTION_PENDING_TYPE, looksLikeChainCorruption, makeCompactionMarkerId, repairSessionFile, } from "./compaction-markers.js";
 import { removeQueuedByIndexOrText } from "./queue-utils.js";
 import { syncPluginToolsIntoSession } from "./plugins.js";
 import { SettingsService } from "./settings-service.js";
@@ -39,16 +40,28 @@ 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";
 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";
 import { buildAttachmentMessages, parseModelSpec } from "./attachments.js";
 import { buildVisionBridgePrompt, findVisionModels, transcribeImages } from "./vision-bridge.js";
+import { isNotRepoError, scmCommitContext } from "./scm.js";
+import { buildCommitMsgInput, buildCommitMsgPrompt, sanitizeCommitMessage } from "./scm-commitmsg.js";
 import { BUILTIN_SOUL, DEFAULT_PROMPT_TEMPLATE, buildToolsSchemaText, renderPromptTemplate, resolveSectionTexts, } from "./prompt-composer.js";
 import { launchOrigin, toServiceInfo } from "./launch-origin.js";
 import { serializeMessage, serializeStreamingMessage, stripTransientRetryErrors, } from "./serialize.js";
@@ -68,6 +81,8 @@ const STREAMING_SNAPSHOT_INTERVAL_MS = 2000;
 /** Deltas newer than this keep the streaming (low-frequency) snapshot cadence. */
 const DELTA_ACTIVE_WINDOW_MS = 1500;
 const WIDGET_REFRESH_MS = 2000;
+/** SCM「AI 生成提交信息」的单次补全超时——慢供应商不该让按钮转圈到天荒地老。 */
+const SCM_COMMITMSG_TIMEOUT_MS = 60_000;
 /** Model-stall watchdog: warn (don't abort — deep thinking can be legitimately
  *  quiet for minutes) when a streaming run produced NO SDK events for this long.
  *  Covers the failure class the per-tool watchdog cannot see: half-open API
@@ -648,6 +663,13 @@ const TOOL_WATCHDOG_TIMEOUT_MS = (() => {
  *  runtime alive; conversations of other projects keep their own lists).
  *  子代理不计入：子代理是 inMemory 后台任务，不参与此上限，既不占位也不被此上限拦截。 */
 const MAX_OPEN_CONVERSATIONS = 8;
+/** 同时存活的子代理上限（按客户端计，含嵌套派生的孙子辈）。每个子代理都是一个完整
+ *  runtime + TerminalManager，无上限时 AI 一次并行派发几十个会把服务进程拖垮。
+ *  主对话的 8 个上限是按项目计的，子代理按客户端全局计（wait_all 本来就是全局口径）。 */
+const MAX_SUBAGENTS = 16;
+/** SubagentSnapshot.prompt 下发上限：存的是全量 prompt，快照里只带前 N 字符，
+ *  避免 subagent_list 一次把几个长 prompt 全推给模型烧 token。 */
+const SUBAGENT_PROMPT_SNAPSHOT_CAP = 2000;
 const DEFAULT_CONV_TITLE = "新对话";
 /** First user text in a session, truncated for the conversation list. */
 function conversationTitle(session) {
@@ -784,6 +806,26 @@ export function isInsideSessionsDir(agentDir, targetPath) {
     const sessionsRoot = resolve(agentDir, "sessions");
     return abs.startsWith(sessionsRoot + sep);
 }
+/** 会话当前模型的 "provider/id"（无模型时 null；软上限按模型覆盖用，issue #229）。 */
+function modelKeyOf(session) {
+    const m = session?.model;
+    if (!m || typeof m.provider !== "string" || typeof m.id !== "string")
+        return null;
+    return `${m.provider}/${m.id}`;
+}
+/** 会话当前模型的上下文窗口（未知时 0）：live 统计优先，模型定义回落。 */
+function contextWindowOf(session) {
+    try {
+        const live = session?.getSessionStats?.()?.contextUsage?.contextWindow;
+        if (typeof live === "number" && live > 0)
+            return Math.floor(live);
+    }
+    catch {
+        // 会话未就绪 → 回落模型定义。
+    }
+    const def = session?.model?.contextWindow;
+    return typeof def === "number" && def > 0 ? Math.floor(def) : 0;
+}
 /**
  * 选一个断开的残留会话给新标签认领（纯函数）：
  * - 还有别的在线浏览器（非伪客户端且 live）→ 不认领（新标签是第二块屏，
@@ -804,6 +846,23 @@ export function pickAdoptableOrphan(cands) {
     }
     return best?.id ?? null;
 }
+/** 同项目判定（纯函数）：调度视口回退与 id 唤醒的 cwd 护栏用。
+ *  Windows 大小写/分隔符差异归一，空串永不相等。 */
+export function sameCwd(a, b) {
+    const x = String(a ?? "").trim();
+    const y = String(b ?? "").trim();
+    if (!x || !y)
+        return false;
+    const norm = (s) => s.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+    if (norm(x) === norm(y))
+        return true;
+    try {
+        return norm(resolve(x)) === norm(resolve(y));
+    }
+    catch {
+        return false;
+    }
+}
 export class ClientSession {
     clientId;
     /** Set by AgentService.attach: reflects the SERVICE-wide quiesce flag
@@ -986,12 +1045,27 @@ export class ClientSession {
      *  回退到模板模型 / 设置面板默认模型；null = 跟随主对话当前模型（默认行为，
      *  runtime 重建时会继承共享 ModelRuntime 的当前默认）。 */
     async spawnSubagentConversation(prompt, type, cwd, apply, model, parentId) {
+        // 数量上限先行：每个子代理都是完整 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 }));
+        }
+        // 真正的派发者（withSubagentOwner 按 runtime 归属填入）：cwd 基准 / 跟随模型 /
+        // 跟随思考强度一律读它，而不是派发瞬间的 active——后台对话产出时用户可能正
+        // 看着别的项目，读 active 会跟错模型、把相对 cwd 解析到错误的项目下。
+        const spawner = parentId ? this.convs.get(parentId) : undefined;
+        const spawnerSession = spawner?.session ?? this.session;
+        const baseCwd = spawner?.cwd ?? this.cwd;
+        // 相对 cwd 按派发者所在目录解析：直接透传会相对 server 进程 cwd 落到别处。
+        const resolvedCwd = cwd ? resolve(baseCwd, cwd) : baseCwd;
         const conversationId = `sa-${randomUUID().slice(0, 8)}`;
-        const terminals = this.makeTerminalManager(conversationId, cwd);
+        const terminals = this.makeTerminalManager(conversationId, resolvedCwd);
         const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(terminals, apply, conversationId), {
-            cwd,
+            cwd: resolvedCwd,
             agentDir: this.agentDir,
-            sessionManager: SessionManager.inMemory(cwd),
+            sessionManager: SessionManager.inMemory(resolvedCwd),
         });
         const conv = this.makeConversation(runtime, conversationId, terminals);
         conv.isSubagent = true;
@@ -1000,6 +1074,11 @@ export class ClientSession {
         // 对话名下、沉到别的项目组底部（issue #95）。缺省才回退到 active。
         conv.parentId = parentId ?? this.activeId ?? undefined;
         conv.subagentType = type;
+        conv.subagentPrompt = prompt;
+        // 插件工具门与模板扩展白名单对齐：白名单非空时插件/MCP 工具（无 SDK
+        // extensionKey 身份）不进该会话。工厂期 customTools 不注册 + 下面的
+        // syncPluginTools 不回补，模板热改不影响已运行的子代理（与 prompt/技能一致）。
+        conv.subagentBarsPluginTools = !!apply && apply.enabledExtensions.length > 0;
         conv.listed = true;
         conv.title = subagentTitle(prompt);
         this.convs.set(conv.id, conv);
@@ -1009,6 +1088,8 @@ export class ClientSession {
         conv.unsubscribe = conv.session.subscribe((event) => this.onEvent(conv, event));
         // 子代理不走 bindSession——这里同样注入面板的重试次数覆盖。
         this.applyRetryOverrides();
+        // 软上限覆盖同样重放（子代理跟随主对话的压缩阈值，issue #229）。
+        this.applyCompactionOverrides();
         // 扩展绑定（rpc 模式）；用 headless 的 Web UI context：
         // 扩展绑定时不会因缺方法崩，UI 输出也不下发（不会与主对话的 widget/status 冲突）。
         try {
@@ -1030,8 +1111,8 @@ export class ClientSession {
         const resolvedModel = model ?? (apply?.model?.trim() || null) ?? (this.settingsSvc.current.subagentDefaultModel || null);
         const followModel = resolvedModel
             ? resolvedModel
-            : this.session.model
-                ? `${this.session.model.provider}/${this.session.model.id}`
+            : spawnerSession.model
+                ? `${spawnerSession.model.provider}/${spawnerSession.model.id}`
                 : null;
         if (followModel) {
             const slash = followModel.indexOf("/");
@@ -1041,7 +1122,8 @@ export class ClientSession {
             if (m) {
                 try {
                     // 先恢复该 provider 的项目密钥（setModel 的鉴权检查要用），再换模型。
-                    await this.restoreKeyForModel(followModel, cwd);
+                    // 按子代理自己的目录恢复（跨目录派发时派发者的密钥不一定适用）。
+                    await this.restoreKeyForModel(followModel, resolvedCwd);
                     await conv.session.setModel(m);
                 }
                 catch (err) {
@@ -1063,12 +1145,12 @@ export class ClientSession {
                 });
             }
         }
-        // 思考强度：模板指定则固定用它，否则跟随主对话当前强度（与「跟随主对话模型」
-        // 同一取数源：this.session，即共享 ModelRuntime 的当前活动会话）。所以子代理默认
-        // 与主对话一致，而不是默默回到 SDK 默认档位。放在换模型之后：setModel 会按模型
-        // 能力重算强度，我们先让它算完再覆盖。不传 persist：只影响这个子代理会话，不动
-        // 全局默认强度；模型不支持的档位由 SDK 自动收敛（reasoning:false 的模型只能是 off）。
-        const thinkingLevel = apply?.thinkingLevel?.trim() || this.session.thinkingLevel;
+        // 思考强度：模板指定则固定用它，否则跟随派发者当前强度（与「跟随派发者模型」
+        // 同一取数源：spawnerSession）。所以子代理默认与派发者一致，而不是默默回到
+        // SDK 默认档位。放在换模型之后：setModel 会按模型能力重算强度，我们先让它
+        // 算完再覆盖。不传 persist：只影响这个子代理会话，不动全局默认强度；模型不
+        // 支持的档位由 SDK 自动收敛（reasoning:false 的模型只能是 off）。
+        const thinkingLevel = apply?.thinkingLevel?.trim() || spawnerSession.thinkingLevel;
         if (thinkingLevel) {
             try {
                 conv.session.setThinkingLevel(thinkingLevel);
@@ -1109,7 +1191,10 @@ export class ClientSession {
     }
     toSubagentSnapshot(conv) {
         const streaming = conv.session.isStreaming;
-        const state = streaming ? "running" : "done";
+        const { error, canceled } = this.subagentRunOutcome(conv);
+        // state 如实反映终态：之前 canceled 的子代理报的也是 done，只能靠独立 flag
+        // 分辨。"queued" 保留给未来（排队调度），当前 spawn 即运行，无排队态。
+        const state = streaming ? "running" : canceled ? "canceled" : "done";
         let messageCount = 0;
         try {
             messageCount = conv.session.getSessionStats().totalMessages;
@@ -1117,12 +1202,14 @@ export class ClientSession {
         catch {
             // session being replaced — report defaults
         }
-        const { error, canceled } = this.subagentRunOutcome(conv);
+        const fullPrompt = conv.subagentPrompt ?? "";
         return {
             convId: conv.id,
             type: conv.subagentType ?? "general",
             title: conv.title,
-            prompt: "",
+            prompt: fullPrompt.length > SUBAGENT_PROMPT_SNAPSHOT_CAP
+                ? `${fullPrompt.slice(0, SUBAGENT_PROMPT_SNAPSHOT_CAP)}\n… [truncated]`
+                : fullPrompt,
             state,
             streaming,
             error,
@@ -1130,6 +1217,7 @@ export class ClientSession {
             messageCount,
             model: conv.session.model?.id,
             output: conv.session.getLastAssistantText() ?? "",
+            parentId: conv.parentId,
         };
     }
     /** 子代理最近一次运行的结局：最后一条 assistant 消息的 errorMessage / stopReason。
@@ -1200,6 +1288,9 @@ export class ClientSession {
     lastSdkAppendFiles = [];
     /** 当前活动会话的工具/资源快照 → composer 输入。cwd 取活动对话的。 */
     composeInputs(src) {
+        // 技能名录指纹观测（只打日志，不干预组装；预览与 run 共用此入口，
+        // 变化才记一行，首轮静默）。用未注文的目录（fill 前），全文注入不影响指纹。
+        this.noteSkillCatalogDigest(src.skills);
         return {
             cwd: src.cwd,
             systemPromptFile: this.lastBaseSystemPrompt || undefined,
@@ -1364,12 +1455,32 @@ export class ClientSession {
             return !!t && t.enabled;
         },
     };
-    /** schedule_* 工具的数据宿主：全局调度存储＋创建时刻 live 的 cwd/活动对话。 */
+    /** schedule_* 工具的数据宿主：全局调度存储＋创建时刻 live 的 cwd/活动对话。
+     *  issue #231：同时快照 owner 对话的落盘会话文件（压缩/重启后稳定），触发时
+     *  先按 sessionFile 认同一会话（内存对话 id 重启即失效，不可单独做持久键）。 */
     scheduleToolHost() {
         return {
             store: () => this.schedulerStore,
             cwd: () => this.cwd,
             activeConversationId: () => this.activeId,
+            conversationInfo: (id) => {
+                try {
+                    const target = (id ?? "").trim() ? this.convs.get((id ?? "").trim()) : this.convs.get(this.activeId);
+                    if (!target)
+                        return undefined;
+                    let sessionFile = "";
+                    try {
+                        sessionFile = String(target.session.sessionFile ?? "");
+                    }
+                    catch {
+                        sessionFile = "";
+                    }
+                    return { cwd: target.cwd ?? this.cwd, sessionFile };
+                }
+                catch {
+                    return undefined;
+                }
+            },
         };
     }
     /** conversation_read 工具的数据宿主：读本客户端的 conversation 体系 +
@@ -1406,16 +1517,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"
@@ -1430,6 +1533,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));
@@ -1452,6 +1578,67 @@ 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）。失败回空目录，不抛错。 */
+    skillToolHost(ownerId) {
+        return {
+            listSkills: () => {
+                try {
+                    const target = (ownerId ?? "").trim() !== "" ? this.convs.get(ownerId.trim()) : this.convs.get(this.activeId);
+                    const all = target?.session.resourceLoader.getSkills().skills ?? [];
+                    const disabled = new Set(this.settingsSvc.current.disabledSkills);
+                    return all
+                        .filter((s) => !disabled.has(s.name))
+                        .map((s) => ({
+                        name: s.name,
+                        description: s.description ?? "",
+                        filePath: s.filePath ?? "",
+                    }));
+                }
+                catch {
+                    return [];
+                }
+            },
+        };
+    }
+    /** 技能名录指纹（sha256 over name+description，非正文）：变化才打一行日志，
+     * 首轮静默。只观测不干预组装（digest 第一步：日志；复用以后再说）。 */
+    lastSkillCatalogDigest = "";
+    noteSkillCatalogDigest(skills) {
+        const d = createHash("sha256")
+            .update(skills.map((s) => `${s.name}\n${s.description}`).join("\n"))
+            .digest("hex")
+            .slice(0, 16);
+        if (d === this.lastSkillCatalogDigest)
+            return;
+        const prev = this.lastSkillCatalogDigest;
+        this.lastSkillCatalogDigest = d;
+        if (prev)
+            console.log(`[skills] catalog digest ${prev}→${d} (${skills.length} skills)`);
+    }
     widgetsTimer = null;
     /** Model-stall watchdog interval (see startStallTimer). */
     stallTimer = null;
@@ -1575,13 +1762,15 @@ export class ClientSession {
             reloadSession: async () => {
                 await this.session.reload();
                 // reload() 重读磁盘 settings.json，会丢掉内存 applyOverrides
-                // （含重试次数覆盖）——依次重放：重试覆盖 → 终端门控。
+                // （含重试次数覆盖）——依次重放：重试覆盖 → 软上限覆盖 → 终端门控。
                 this.applyRetryOverrides();
+                this.applyCompactionOverrides();
                 // reload() 会把 custom 工具重新加回活跃集——重放终端开关。
                 this.applyToolGating(this.session);
                 await this.pushSlashCommands();
             },
             applyRetryOverrides: () => this.applyRetryOverrides(),
+            applyCompactionOverrides: () => this.applyCompactionOverrides(),
             applyToolGating: () => this.applyToolGating(this.session),
             promptSnapshot: () => this.promptSnapshot(),
             getMarkerState: () => ({
@@ -1631,15 +1820,22 @@ export class ClientSession {
         const cs = new ClientSession(clientId, cwd, agentDir, stateStore);
         const conversationId = cs.nextConversationId();
         const terminals = cs.makeTerminalManager(conversationId, cwd);
-        const runtime = await createAgentSessionRuntime(cs.makeRuntimeFactory(terminals, undefined, conversationId), {
+        // Resume the most recent session for this project — the SDK default
+        // per-project dir (<agentDir>/sessions/--<cwd>--/, shared with the
+        // pi CLI/TUI) — or start a fresh one on first visit.
+        // issue #145: opts.blank = 跳过恢复（最近那条在别处跑着），直接空白新对话。
+        // issue #235：坏转录（重复压缩标记成环）修一次再试，否则整项目首屏
+        // "Failed to initialize session"。
+        const opened = await cs.openManagerAndRuntime(() => (opts?.blank ? SessionManager.create(cwd) : SessionManager.continueRecent(cwd)), (m) => createAgentSessionRuntime(cs.makeRuntimeFactory(terminals, undefined, conversationId), {
             cwd,
             agentDir,
-            // Resume the most recent session for this project — the SDK default
-            // per-project dir (<agentDir>/sessions/--<cwd>--/, shared with the
-            // pi CLI/TUI) — or start a fresh one on first visit.
-            // issue #145: opts.blank = 跳过恢复（最近那条在别处跑着），直接空白新对话。
-            sessionManager: opts?.blank ? SessionManager.create(cwd) : SessionManager.continueRecent(cwd),
-        });
+            sessionManager: m,
+        }), async () => (await SessionManager.list(cwd))[0]?.path);
+        const runtime = opened.runtime;
+        if (opened.repair) {
+            for (const n of cs.transcriptRepairNotices(opened.repair))
+                cs.pendingNotices.push(n);
+        }
         // First conversation = the resumed session; it also seeds the shared
         // ModelRuntime that every later conversation reuses.
         cs.sharedModelRuntime = runtime.services.modelRuntime;
@@ -1779,12 +1975,18 @@ export class ClientSession {
                                     // 把灵魂段换成模板提示词，自动段保留；SYSTEM.md 情形已在
                                     // systemPromptOverride 整体替换，此处边界不存在会自然跳过。
                                     if (apply) {
-                                        if (apply.promptMode !== "replace" || !pickTemplatePrompt(apply, this.getLang()).trim())
+                                        const tplPrompt = pickTemplatePrompt(apply, this.getLang()).trim();
+                                        if (apply.promptMode !== "replace" || !tplPrompt)
                                             return undefined;
                                         const boundary = event.systemPrompt.indexOf("\n\nAvailable tools:");
-                                        if (boundary === -1)
-                                            return undefined;
-                                        const swapped = pickTemplatePrompt(apply, this.getLang()).trimEnd() + event.systemPrompt.slice(boundary);
+                                        // 边界串是 SDK 提示词的内部格式：版本一变就可能对不上。
+                                        // 对不上时不再静默回退默认 persona（模板等于没生效），而是把模板
+                                        // 提示词前置拼接——角色约束仍在，只是灵魂段没被精确替换。
+                                        if (boundary === -1) {
+                                            const fallback = `${tplPrompt}\n\n${event.systemPrompt}`;
+                                            return fallback === event.systemPrompt ? undefined : { systemPrompt: fallback };
+                                        }
+                                        const swapped = tplPrompt + event.systemPrompt.slice(boundary);
                                         return swapped === event.systemPrompt ? undefined : { systemPrompt: swapped };
                                     }
                                     // 主会话：组合模板渲染（模板为空且无覆盖时返回 undefined = 用 SDK 默认）。
@@ -1808,6 +2010,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,
@@ -1830,11 +2037,22 @@ 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 过滤；
                     // 后续注册经 refreshPluginTools 动态补入已有会话）。
-                    ...this.enabledPluginToolDefs(),
+                    // 子代理模板带非空扩展白名单时不注入：插件/MCP 工具没有 SDK extensionKey
+                    // 身份、无法参与白名单匹配，全放行等于白名单没关门，全收编才符合「只加载这些」。
+                    // 空白名单 = 跟随主会话（插件工具照常进入子代理）。
+                    ...(apply && apply.enabledExtensions.length > 0 ? [] : this.enabledPluginToolDefs()),
                     // 第一方子代理工具（spawn/get_result/steer/list/stop）。子代理会话
                     // 也注册了它们，因此可自然嵌套派发。host 按 ownerId 包装：子代理的
                     // 父对话 = 真正调用 spawn 的那个会话（本 runtime 所属会话），而不是
@@ -1856,16 +2074,42 @@ 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）：常驻注册、不进工具目录（见 claimToolHost
+                    // 注释）。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。
+                    makeSkillTool(this.skillToolHost(ownerId), () => this.getLang()),
                     // 定时唤醒三件套（schedule_task/list/cancel，issue #193）：默认绑定
                     // 发起对话（ownerId，无则活动对话），到期 steer 语义唤醒它；子代理
                     // 会话同样注册（owner 即真正派发的父对话）。开关走统一工具 tab。
@@ -1873,6 +2117,9 @@ export class ClientSession {
                     ...makeScheduleTools(this.scheduleToolHost(), ownerId, () => this.getLang()),
                 ],
             });
+            // 桥接工具归属锚点：SDK 会话对象在本 runtime 生命周期内稳定，过户只搬对话
+            // 不改它（见 ClientSession.findConversationHome）。
+            bridgeAnchor.session = created.session;
             // 终端工具开关从创建起就生效（工具始终注册进注册表，只调活跃集）。
             this.applyToolGating(created.session);
             return {
@@ -2038,6 +2285,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();
     }
@@ -2075,6 +2325,8 @@ export class ClientSession {
         // 默认重试 3 次——这里把面板的 retryMaxAttempts 覆盖注入，否则“设了 6
         // 次还是按 3 次重试”。已存在会话重复注入是幂等的（同值覆盖）。
         this.applyRetryOverrides();
+        // 软上限覆盖同路重放（新 runtime 的 SettingsManager 是干净的，issue #229）。
+        this.applyCompactionOverrides();
         this.scheduleSnapshot();
         this.webUi.refresh();
         this.startWidgetsTimer();
@@ -2343,6 +2595,94 @@ export class ClientSession {
         await conv.session.sendUserMessage(text, conv.session.isStreaming ? { deliverAs: "steer" } : undefined);
         return { ok: true };
     }
+    /** issue #231：本客户端内按稳定键定位调度唤醒目标。
+     *  sessionFile 优先（压缩/重启后内存对话 id 已变，落盘会话文件才是同一会话）；
+     *  只有没给 sessionFile 时才按内存 id 找，且 id 必须附带 cwd 一致才认 ——
+     *  各客户端计数器都从 c1 开始，跨项目同 id 必然撞车，不校验 cwd 会把巡检
+     *  报告投进完全无关的项目对话。
+     *  excludeIds 用于视口回退时跳过已知的忙对话。 */
+    resolveSchedulerTarget(opts) {
+        const wantFile = String(opts.sessionFile ?? "").trim();
+        const wantId = String(opts.conversationId ?? "").trim();
+        const wantCwd = String(opts.cwd ?? "").trim();
+        const excluded = opts.excludeIds;
+        if (wantFile) {
+            let best = null;
+            for (const c of this.convs.values()) {
+                if (!c?.session || (excluded && excluded.has(c.id)))
+                    continue;
+                let f = "";
+                try {
+                    f = String(c.session.sessionFile ?? "");
+                }
+                catch {
+                    continue;
+                }
+                if (!sameSessionFile(f, wantFile))
+                    continue;
+                if (!best || c.lastActiveAt > best.lastActiveAt)
+                    best = c;
+            }
+            if (best)
+                return best;
+        }
+        if (wantId) {
+            const c = this.convs.get(wantId);
+            if (!c?.session || (excluded && excluded.has(c.id)))
+                return null;
+            if (wantCwd && !sameCwd(c.cwd, wantCwd))
+                return null;
+            return c;
+        }
+        return null;
+    }
+    /** issue #231：本客户端内同项目的最近活跃对话（视口回退目标）。
+     *  主对话优先（用户正看着的面），没有主对话时才考虑子代理行；
+     *  最近活跃者即用户当前的视口。 */
+    findViewportInCwd(cwd, excludeIds) {
+        const want = String(cwd ?? "").trim();
+        if (!want)
+            return null;
+        let best = null;
+        let bestSub = null;
+        for (const c of this.convs.values()) {
+            if (!c?.session || (excludeIds && excludeIds.has(c.id)))
+                continue;
+            if (!sameCwd(c.cwd, want))
+                continue;
+            if (c.isSubagent) {
+                if (!bestSub || c.lastActiveAt > bestSub.lastActiveAt)
+                    bestSub = c;
+            }
+            else if (!best || c.lastActiveAt > best.lastActiveAt) {
+                best = c;
+            }
+        }
+        return best ?? bestSub;
+    }
+    /** issue #231：带压缩忙检测的调度 steer。压缩进行中时 SDK 直接抛错
+     *  （Cannot submit a prompt while compaction is in progress），调用方据 busy
+     *  另寻视口兄弟或稍后重试，而不是当成“对话不在”静默转无头。 */
+    async trySteerScheduler(conv, text) {
+        try {
+            try {
+                if (conv.session.isCompacting === true) {
+                    return { ok: false, busy: true, error: "上下文压缩进行中，稍后重试" };
+                }
+            }
+            catch {
+                /* 读不到压缩态就直接投递，失败按异常走 */
+            }
+            await conv.session.sendUserMessage(text, conv.session.isStreaming ? { deliverAs: "steer" } : undefined);
+            return { ok: true };
+        }
+        catch (err) {
+            const msg = String(err?.message ?? err);
+            if (/compaction is in progress/i.test(msg))
+                return { ok: false, busy: true, error: msg };
+            return { ok: false, busy: false, error: msg };
+        }
+    }
     /** 插件扩展点（供 runSteerer）：向指定对话插队一条用户消息，复用子代理 steer 的
      *  sendUserMessage + deliverAs:'steer' 路径（运行时插队；未跑时按普通消息投递）。
      *  先找本客户端 conversations，找不到再经 steerConversationElsewhere 问其他客户端；
@@ -2707,6 +3047,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": {
@@ -2949,12 +3314,14 @@ export class ClientSession {
                             contextWindow: cu.contextWindow,
                             percent: (conv.lastCompactionTokens / cu.contextWindow) * 100,
                             estimated: true,
+                            softCap: this.activeSoftCap(cu.contextWindow),
                         };
                     }
                     return {
                         tokens: cu.tokens,
                         contextWindow: cu.contextWindow,
                         percent: cu.percent,
+                        softCap: this.activeSoftCap(cu.contextWindow),
                     };
                 })(),
             };
@@ -3069,6 +3436,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（用户取消）。
@@ -3394,6 +3792,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 下正在跑的对话（同项目并行感知用）；
@@ -3408,6 +3822,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;
@@ -3588,8 +4004,9 @@ export class ClientSession {
         },
         refreshSessions: () => this.refreshSessions(),
         afterReload: () => {
-            // /reload 同样重读磁盘 settings.json——重放重试覆盖 + 终端门控。
+            // /reload 同样重读磁盘 settings.json——重放重试覆盖 + 软上限覆盖 + 终端门控。
             this.applyRetryOverrides();
+            this.applyCompactionOverrides();
             this.applyToolGating(this.session);
         },
         pluginCommands: () => this.pluginCommandsProvider?.() ?? [],
@@ -3631,8 +4048,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);
@@ -3679,6 +4100,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);
     }
@@ -3710,6 +4139,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
@@ -3734,25 +4164,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 —
@@ -3776,9 +4221,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 {
@@ -3833,6 +4279,40 @@ export class ClientSession {
             }
         }
     }
+    /** 把压缩软上限换算成各存活会话的 compaction reserveTokens 覆盖
+     *  （issue #229）。与重试覆盖同一 live 机制：applyOverrides 只改内存
+     *  合并视图，SDK 每次自动压缩检查前都重读 getCompactionSettings()，
+     *  无需 reload；软上限关闭时回填 SDK 默认 reserve（不让旧覆盖泄漏）。
+     *  窗口未知（会话未就绪/无模型）的会话跳过——创建/就绪/换模型路径
+     *  会重放（见各 applyRetryOverrides 调用点）。 */
+    applyCompactionOverrides() {
+        const s = this.settingsSvc.current;
+        for (const c of this.convs.values()) {
+            try {
+                const modelId = modelKeyOf(c.session);
+                const contextWindow = contextWindowOf(c.session);
+                const cap = effectiveSoftCap(s.softCapTokens, s.softCapByModel, modelId);
+                const reserve = softCapToReserve(contextWindow, cap);
+                c.session.settingsManager.applyOverrides({
+                    compaction: { reserveTokens: reserve ?? DEFAULT_COMPACTION_RESERVE_TOKENS },
+                });
+            }
+            catch {
+                // 会话未就绪或已释放 → 其 runtime 创建时统一注入。
+            }
+        }
+    }
+    /** 当前活动对话的生效软上限（快照底栏标记线用；null = 关闭/未知）。 */
+    activeSoftCap(contextWindow) {
+        try {
+            const s = this.settingsSvc.current;
+            const cap = effectiveSoftCap(s.softCapTokens, s.softCapByModel, modelKeyOf(this.session));
+            return softCapToReserve(contextWindow, cap) === null ? null : cap;
+        }
+        catch {
+            return null;
+        }
+    }
     /** Extensions/skills changed externally (e.g. `pi remove` finished in the
      *  terminal): re-run session.reload() and re-push state. Streaming-safe —
      *  deferred to agent_end, same as settings reloads. */
@@ -3867,6 +4347,7 @@ export class ClientSession {
                 try {
                     await this.session.reload();
                     this.applyRetryOverrides();
+                    this.applyCompactionOverrides();
                     this.applyToolGating(this.session);
                     await this.pushSlashCommands();
                     this.pushSettings();
@@ -3929,8 +4410,14 @@ export class ClientSession {
         return (this.pluginToolsProvider?.() ?? []).filter((t) => !off.has(t.name)).map(pluginToolToDefinition);
     }
     /** 把插件 AI 工具同步进一个已存在的会话（新增/更新/移除；禁用工具同步移除）。
-     *  实际 diff 逻辑在 plugins.ts 的 syncPluginToolsIntoSession（可单测）。 */
+     *  实际 diff 逻辑在 plugins.ts 的 syncPluginToolsIntoSession（可单测）。
+     *  模板白名单的子代理（subagentBarsPluginTools）跳过：工厂期就没注册，这里
+     *  不回补，否则白名单等于没关门。 */
     syncPluginTools(session) {
+        for (const conv of this.convs.values()) {
+            if (conv.session === session && conv.subagentBarsPluginTools)
+                return;
+        }
         try {
             const defs = this.enabledPluginToolDefs();
             const next = syncPluginToolsIntoSession(session, defs, this.appliedPluginToolNames);
@@ -4039,6 +4526,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 {
@@ -4202,33 +4704,135 @@ export class ClientSession {
             // issue #145：同项目并行感知 —— 同一 cwd 下别处（或其他对话）正在跑时，
             // 允许并行（可以同时改不同部分），但用户与 AI 都必须知道。只在新一轮启动时
             // 通告一次（steer/排队等流式中发送不重复打扰）。
-            if (!conv.isSubagent && !s.isStreaming) {
+            // 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",
@@ -4655,11 +5259,17 @@ export class ClientSession {
             this.clearAllToolWatchdogs(conv);
             conv.toolStartTimes.clear();
             await conv.runtime.dispose();
-            const runtime = await createAgentSessionRuntime(this.makeRuntimeFactory(conv.terminals, undefined, conv.id), {
+            // #235：转录链损坏时修一次再试（见 openManagerAndRuntime）。
+            const opened = await this.openManagerAndRuntime(() => SessionManager.continueRecent(conv.cwd), (m) => createAgentSessionRuntime(this.makeRuntimeFactory(conv.terminals, undefined, conv.id), {
                 cwd: conv.cwd,
                 agentDir: this.agentDir,
-                sessionManager: SessionManager.continueRecent(conv.cwd),
-            });
+                sessionManager: m,
+            }), async () => (await SessionManager.list(conv.cwd))[0]?.path);
+            const runtime = opened.runtime;
+            if (opened.repair) {
+                for (const n of this.transcriptRepairNotices(opened.repair))
+                    this.emit(n);
+            }
             conv.runtime = runtime;
             conv.session = runtime.session;
             this.emit({
@@ -4814,9 +5424,11 @@ export class ClientSession {
                 return;
             // parentId joins the live chain: a null-parent marker would become a
             // second root and hijack the leaf, corrupting the transcript.
+            // #235: id 必须唯一——硬编码共享 id ＋ SDK byId last-wins ＋ 标记恰为末行
+            // 时新消息 parent 记成共享 id ＝ 下次 open 回溯成环，整个会话打不开。
             const marker = {
                 type: "custom",
-                id: "pi-web-ui-compaction-pending",
+                id: makeCompactionMarkerId("pending"),
                 parentId: conv.session.sessionManager.getLeafId(),
                 timestamp: new Date().toISOString(),
                 customType: "pi-web-ui/compaction-pending",
@@ -4843,10 +5455,18 @@ export class ClientSession {
             const file = conv.session.sessionFile;
             if (!file || !existsSync(file))
                 return;
-            const id = "pi-web-ui-compaction-pending";
             const raw = readFileSync(file, "utf8");
             const lines = raw.split("\n");
-            const idx = lines.findIndex((line) => line.includes(`"${id}"`));
+            // #235：按 customType 定位（id 自本 fix 起唯一，老文件仍是硬编码 id，
+            // 按 id 找已不可靠）。取最后一个：重叠压缩时它属于本次，旧残留留给
+            // 下次 open 的 repair/notice 处理。
+            let idx = -1;
+            for (let i = lines.length - 1; i >= 0; i--) {
+                if (lines[i].includes(`"${COMPACTION_PENDING_TYPE}"`)) {
+                    idx = i;
+                    break;
+                }
+            }
             if (idx < 0)
                 return;
             // ponytail: full-file rewrite on compaction end — compactions are rare
@@ -4864,7 +5484,7 @@ export class ClientSession {
                 }
                 const done = {
                     type: "custom",
-                    id: "pi-web-ui-compaction-done",
+                    id: makeCompactionMarkerId("done"),
                     parentId,
                     timestamp: new Date().toISOString(),
                     customType: "pi-web-ui/compaction-done",
@@ -4894,15 +5514,80 @@ export class ClientSession {
                 return;
             const kept = raw.split("\n").filter((line) => !line.includes("pi-web-ui/compaction-pending"));
             writeFileSync(file, kept.join("\n"));
-            this.emit({
+            this.emitCompactionInterruptedNotice();
+        }
+        catch {
+            // Best-effort, same as the write path.
+        }
+    }
+    emitCompactionInterruptedNotice() {
+        this.emit({
+            type: "notice",
+            level: "warning",
+            text: "上次压缩上下文被服务端重启打断，未完成。可发送 /compact 重试。",
+            textEn: "The last context compaction was interrupted by a server restart and did not finish. Send /compact to retry.",
+        });
+    }
+    /** #235 修复产生的提示（调用方决定 emit 还是进 pendingNotices）。 */
+    transcriptRepairNotices(repair) {
+        const out = [];
+        if (repair.interrupted) {
+            out.push({
                 type: "notice",
                 level: "warning",
                 text: "上次压缩上下文被服务端重启打断，未完成。可发送 /compact 重试。",
                 textEn: "The last context compaction was interrupted by a server restart and did not finish. Send /compact to retry.",
             });
         }
+        if (repair.renamedIds > 0 || repair.rewiredParents > 0 || repair.cyclesBroken > 0) {
+            out.push({
+                type: "notice",
+                level: "warning",
+                text: `对话记录链损坏已自动修复（重复的压缩标记），原文件备份在 ${repair.backup ?? "同目录 .bak 文件"}。如内容异常可手动恢复。`,
+                textEn: `The conversation transcript had a corrupted parent chain (duplicate compaction markers) and was auto-repaired. The original file is backed up at ${repair.backup ?? "a .bak file next to it"}; restore it manually if anything looks off.`,
+            });
+        }
+        return out;
+    }
+    /**
+     * #235：已知路径先修后开（openConversation 走这条——单文件预扫描零负担）。
+     * 返回 null = 文件健康或无需处理；返回 repair = 修过，调用方弹提示。
+     */
+    repairTranscriptFileBeforeOpen(filePath) {
+        let repair = null;
+        try {
+            repair = repairSessionFile(filePath);
+        }
         catch {
-            // Best-effort, same as the write path.
+            return null;
+        }
+        if (!repair?.changed)
+            return null;
+        for (const n of this.transcriptRepairNotices(repair))
+            this.emit(n);
+        return repair;
+    }
+    /**
+     * #235：manager＋runtime 一起建，链损坏报错则修最近文件后重试一次。
+     * SessionManager.open 本身不走 parent 链（真正死循环的是 runtime 初始化里的
+     * getBranch），所以重试必须把两步都包进来；修完用全新 manager 重读。
+     */
+    async openManagerAndRuntime(makeManager, makeRuntime, locateFile) {
+        try {
+            const manager = makeManager();
+            const runtime = await makeRuntime(manager);
+            return { manager, runtime, repair: null };
+        }
+        catch (err) {
+            if (!looksLikeChainCorruption(err))
+                throw err;
+            const file = await locateFile().catch(() => undefined);
+            const repair = file ? repairSessionFile(file) : null;
+            if (!repair?.changed)
+                throw err;
+            const manager = makeManager();
+            const runtime = await makeRuntime(manager);
+            return { manager, runtime, repair };
         }
     }
     displaceActive() {
@@ -4959,6 +5644,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();
@@ -4966,6 +5659,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) => ({
@@ -5426,6 +6128,8 @@ export class ClientSession {
                 }
             }
             rmSync(abs, { force: true });
+            // 转录删了，sidecar 再留着就是孤儿，一起清掉（不存在不报错）。
+            removeTouchSidecar(abs);
             // 转录删了，未发送草稿再留着就是孤儿，一起清掉。
             try {
                 this.drafts.pruneSessionFile(abs);
@@ -5997,6 +6701,9 @@ export class ClientSession {
                     });
                 }
             }
+            // #235：先修后开——坏转录到 open 后的 getBranch 会死循环，修完再读。
+            // 单文件预扫描，健康文件只多一次小读；修过即弹提示（含压缩被打断）。
+            this.repairTranscriptFileBeforeOpen(targetPath);
             const sessionManager = SessionManager.open(targetPath);
             const targetCwd = sessionManager.getCwd();
             const conversationId = this.nextConversationId();
@@ -6301,6 +7008,79 @@ export class ClientSession {
     async scmQuery(kind, reqId, arg) {
         return this.files.scmQuery(kind, reqId, arg);
     }
+    /**
+     * SCM「AI 生成提交信息」：用当前对话模型做一次 completeSimple 一次性补全
+     * （与视觉桥同一条通路）——不进对话上下文、不打断正在流式的回复。
+     * 恰好应答一次：任何失败都以 ok:false 的 scm_data（kind "commitmsg"）收尾，
+     * 前端按钮不会卡在转圈。
+     */
+    async scmGenCommitMessage(reqId) {
+        const lang = this.getLang();
+        const cwd = this.conv?.cwd ?? this.cwd;
+        const reply = (ok, extra) => {
+            this.emit({ type: "scm_data", reqId, kind: "commitmsg", ok, ...extra });
+        };
+        const fail = (err) => {
+            reply(false, { error: err instanceof Error ? err.message : String(err) });
+        };
+        try {
+            const runtime = this.runtime.services.modelRuntime;
+            const model = this.session?.model;
+            if (!model) {
+                throw new Error(pick(lang, "当前没有可用模型——先在顶栏选择一个模型再生成", "No model available — pick one in the top bar first", "scm.commitmsg.no.model"));
+            }
+            const ctx = await scmCommitContext(cwd, () => lang);
+            const input = buildCommitMsgInput(ctx, lang === "zh" ? "zh" : "en");
+            if (!input) {
+                throw new Error(pick(lang, "没有可描述的更改（工作区干净）", "Nothing to describe (working tree clean)", "scm.commitmsg.no.changes"));
+            }
+            const ac = new AbortController();
+            const timer = setTimeout(() => ac.abort(), SCM_COMMITMSG_TIMEOUT_MS);
+            // 提示词可配置（设置 → 提示词 → AI 提交信息）：追加/替换内置默认。
+            const commitSettings = this.settingsSvc.current;
+            const systemPrompt = buildCommitMsgPrompt(commitSettings.scmCommitMsgPromptMode === "replace" ? "replace" : "append", commitSettings.scmCommitMsgPrompt ?? "");
+            let msg;
+            try {
+                msg = await runtime.completeSimple(model, {
+                    systemPrompt,
+                    messages: [
+                        {
+                            role: "user",
+                            timestamp: Date.now(),
+                            content: [{ type: "text", text: input }],
+                        },
+                    ],
+                }, { signal: ac.signal, maxTokens: 400 });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (msg.stopReason === "error" || msg.stopReason === "aborted") {
+                throw new Error(msg.errorMessage ||
+                    pick(lang, `模型异常终止（${msg.stopReason}）`, `Model terminated abnormally (${msg.stopReason})`, "scm.commitmsg.model.terminated"));
+            }
+            const raw = msg.content
+                .filter((b) => b.type === "text")
+                .map((b) => b.text ?? "")
+                .join("\n");
+            const text = sanitizeCommitMessage(raw);
+            if (!text) {
+                throw new Error(pick(lang, "模型返回了空的提交信息", "The model returned an empty commit message", "scm.commitmsg.empty"));
+            }
+            reply(true, { text });
+        }
+        catch (err) {
+            if (isNotRepoError(err)) {
+                fail(new Error(pick(lang, "当前目录不是 Git 仓库", "Current directory is not a Git repository", "scm.commitmsg.not.repo")));
+                return;
+            }
+            if (err instanceof Error && /abort/i.test(`${err.name} ${err.message}`)) {
+                fail(new Error(pick(lang, `生成提交信息超时（${Math.round(SCM_COMMITMSG_TIMEOUT_MS / 1000)} 秒）`, `Commit-message generation timed out (${Math.round(SCM_COMMITMSG_TIMEOUT_MS / 1000)}s)`, "scm.commitmsg.timeout")));
+                return;
+            }
+            fail(err);
+        }
+    }
     /** Read a workspace file for the preview panel (size-capped, binary-safe). */
     async readFile(relPath) {
         return this.files.readFile(relPath);
@@ -6469,7 +7249,6 @@ export class ClientSession {
                 // 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.
-                let sessionManager = SessionManager.continueRecent(abs);
                 let resumeSkipped = null;
                 // 无人在跑时不扫目录（首访切项目的常见情形零开销）。
                 if (this.hasStreamingElsewhere?.() ?? false) {
@@ -6478,7 +7257,6 @@ export class ClientSession {
                         const recent = infos[0]?.path ? resolve(infos[0].path) : undefined;
                         const owner = recent ? this.findSessionOwner?.(recent) : null;
                         if (owner?.isStreaming) {
-                            sessionManager = SessionManager.create(abs);
                             resumeSkipped = owner;
                         }
                     }
@@ -6488,11 +7266,18 @@ export class ClientSession {
                 }
                 const conversationId = this.nextConversationId();
                 const terminals = this.makeTerminalManager(conversationId, abs);
-                const newRuntime = await createAgentSessionRuntime(this.makeRuntimeFactory(terminals, undefined, conversationId), {
+                // #235：manager＋runtime 一起建，转录链损坏时修最近文件后重试一次
+                // （见 openManagerAndRuntime）。blank（别处在跑）是全新空会话，不会坏。
+                const opened = await this.openManagerAndRuntime(() => (resumeSkipped ? SessionManager.create(abs) : SessionManager.continueRecent(abs)), (m) => createAgentSessionRuntime(this.makeRuntimeFactory(terminals, undefined, conversationId), {
                     cwd: abs,
                     agentDir: this.agentDir,
-                    sessionManager,
-                });
+                    sessionManager: m,
+                }), async () => (await SessionManager.list(abs))[0]?.path);
+                const newRuntime = opened.runtime;
+                if (opened.repair) {
+                    for (const n of this.transcriptRepairNotices(opened.repair))
+                        this.emit(n);
+                }
                 const conv = this.makeConversation(newRuntime, conversationId, terminals);
                 this.convs.set(conv.id, conv);
                 this.activeId = conv.id;
@@ -6642,7 +7427,9 @@ export class ClientSession {
             return "";
         }
     }
-    /** Switch to a specific model by "provider/id" (e.g. "anthropic/claude-sonnet-5"). */
+    /** Switch to a specific model by "provider/id" (e.g. "anthropic/claude-sonnet-5").
+     *  失败时只发 notice 不抛错（UI 路径靠 notice 提示，见 cycleModel 等调用方）。
+     *  需要「失败即拒绝」的无头路径（插件/定时任务）用 switchModelOrThrow。 */
     async setModel(modelId) {
         try {
             const mr = this.runtime.services.modelRuntime;
@@ -6661,6 +7448,8 @@ export class ClientSession {
             // project (not only after a turn). This is what makes project switching
             // restore both the model and the provider key.
             this.rememberProjectModel(modelId);
+            // 换模型后按新模型的窗口重算软上限覆盖（按模型覆盖可能不同，issue #229）。
+            this.applyCompactionOverrides();
         }
         catch (err) {
             this.emit({
@@ -6672,6 +7461,78 @@ 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 打错/没配密钥」会变成静默按旧模型跑 ——
+     *  账单与效果都和用户预期不符。这里统一改成响亮失败。 */
+    async switchModelOrThrow(modelId) {
+        await this.setModel(modelId);
+        // 复核结果：读不到（无活跃对话）不阻断，读得到且不符才拒绝。
+        // 注意 session 是 getter，无活跃对话时会抛，不能用 `?.` 兜底。
+        let curId = "";
+        try {
+            const cur = this.session?.model;
+            curId = cur ? `${cur.provider}/${cur.id}` : "";
+        }
+        catch {
+            curId = "";
+        }
+        if (curId && curId !== modelId)
+            throw new Error(`切换模型失败（${modelId}），当前仍是 ${curId} —— 请检查模型 ID 与供应商密钥`);
+    }
     /** Set the thinking level for future turns. */
     setThinking(level) {
         try {
@@ -6762,6 +7623,42 @@ export class ClientSession {
         }
     }
 }
+/** issue #226：插件无头调用的工作目录校验（纯函数，可单测）。
+ *  存在性语义与定时任务一致（须存在且为目录，不默默跑错目录）；另在
+ *  Windows 下拒绝 SystemRoot 及其子树（如 C:\Windows\System32）——后台服务/
+ *  快捷方式启动时宿主 cwd 常飘到 system32，直接跑就是高危误操作。 */
+export function checkPluginCwd(cwd) {
+    const trimmed = String(cwd ?? "").trim();
+    if (!trimmed)
+        return { ok: false, error: "工作目录为空" };
+    let abs;
+    try {
+        abs =
+            process.platform === "win32" && /^[A-Za-z]:$/.test(trimmed) ? `${trimmed.toUpperCase()}${sep}` : resolve(trimmed);
+    }
+    catch {
+        return { ok: false, error: `工作目录非法：${trimmed}` };
+    }
+    try {
+        if (!statSync(abs).isDirectory())
+            throw new Error("not-a-dir");
+    }
+    catch {
+        return { ok: false, error: `目标项目不存在或不是目录：${trimmed}` };
+    }
+    if (process.platform === "win32") {
+        const sysRoot = (process.env.SystemRoot || process.env.windir || "C:\\Windows")
+            .replace(/\//g, "\\")
+            .replace(/\\+$/, "");
+        const norm = abs.replace(/\//g, "\\").replace(/\\+$/, "");
+        const low = norm.toLowerCase();
+        const rootLow = sysRoot.toLowerCase();
+        if (low === rootLow || low.startsWith(`${rootLow}\\`)) {
+            return { ok: false, error: `拒绝在系统目录执行：${abs}（请在插件设置里指定项目工作目录）` };
+        }
+    }
+    return { ok: true, abs };
+}
 export class AgentService {
     cwd;
     /** index.ts 注入：SDK 工具执行事件的插件转发钩子，attach 时拷贝到每个新会话。 */
@@ -6781,6 +7678,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:
@@ -6801,6 +7700,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. */
@@ -6875,30 +7775,165 @@ export class AgentService {
     }
     /** issue #193：定时任务唤醒发起对话。逐个客户端找持有方，用 steer 语义投递
      *  （运行时插队、未跑时普通投递，不切用户当前对话）；都找不到回 ok:false，
-     *  调用方（index.ts executor）回落无头执行。quiesced 时直接拒绝。 */
-    async wakeConversation(id, text) {
-        if (!id || !text.trim())
+     *  调用方（index.ts executor）回落视口/无头执行。quiesced 时直接拒绝。
+     *  issue #226：成功时带回持有方 clientId（插件绑定网页会话时原样回执）。
+     *  issue #231：opts.sessionFile 是跨压缩/重启的稳定键 —— 优先按它认同一会话
+     *  （内存对话 id 重启即失效，压缩后同文件对话可能已换新 id，成功时带回**实际**
+     *  投递的 conversationId + sessionFile，调用方据此重绑定任务）；id 相位带 cwd
+     *  护栏（各客户端计数器都从 c1 开始，不校验会把报告投进无关项目）。压缩进行中
+     *  的持有方回 busy:true（调用方另寻视口兄弟，而不是当成“不在”静默转无头）。 */
+    async wakeConversation(id, text, opts) {
+        const wantFile = String(opts?.sessionFile ?? "").trim();
+        const wantCwd = String(opts?.cwd ?? "").trim();
+        if ((!id && !wantFile) || !text.trim())
             return { ok: false, error: "唤醒目标或文本为空" };
         if (this.quiesced)
             return { ok: false, error: "服务器正忙（quiesced），请稍后重试" };
-        for (const cs of this.clients.values()) {
+        const liveFile = (c) => {
             try {
-                const r = await cs.steerOwnConversation(id, text);
-                if (r) {
+                return String(c.session.sessionFile ?? "");
+            }
+            catch {
+                return "";
+            }
+        };
+        const flush = (cs) => {
+            try {
+                cs.flushSnapshot();
+            }
+            catch {
+                // 推送失败不影响已投递的唤醒
+            }
+        };
+        // 相位一：落盘会话文件（稳定键）。同文件可能在多处打开，取最近活跃者；
+        // 全部忙（压缩中）则报 busy，调用方去找视口兄弟。
+        if (wantFile) {
+            const hits = [];
+            for (const [clientId, cs] of this.clients) {
+                try {
+                    const conv = cs.resolveSchedulerTarget({ sessionFile: wantFile });
+                    if (conv)
+                        hits.push({ cs, clientId, conv });
+                }
+                catch {
+                    // 单客户端坏了继续找下一个
+                }
+            }
+            hits.sort((a, b) => b.conv.lastActiveAt - a.conv.lastActiveAt);
+            let busyError;
+            for (const h of hits) {
+                try {
+                    const r = await h.cs.trySteerScheduler(h.conv, text);
+                    if (r.ok) {
+                        flush(h.cs);
+                        return { ok: true, conversationId: h.conv.id, sessionFile: liveFile(h.conv), clientId: h.clientId };
+                    }
+                    if (r.busy)
+                        busyError = r.error;
+                    // 非忙失败（投递异常）试下一个同文件持有方
+                }
+                catch {
+                    // 单客户端坏了继续找下一个
+                }
+            }
+            if (hits.length > 0) {
+                if (busyError)
+                    return { ok: false, busy: true, error: busyError };
+                // 同文件持有方都在但都投递失败 —— id 相位大概率指向同一批，无需再试
+                return { ok: false, error: "目标对话投递失败（持有方异常）" };
+            }
+            // 无同文件持有方 —— 老任务只有 id，继续相位二
+        }
+        // 相位二：内存对话 id（易失键，必须配 cwd 护栏防跨项目串台）。
+        if (id) {
+            const hits = [];
+            for (const [clientId, cs] of this.clients) {
+                try {
+                    const conv = cs.resolveSchedulerTarget({
+                        conversationId: id,
+                        ...(wantCwd ? { cwd: wantCwd } : {}),
+                    });
+                    if (conv)
+                        hits.push({ cs, clientId, conv });
+                }
+                catch {
+                    // 单客户端坏了继续找下一个
+                }
+            }
+            hits.sort((a, b) => b.conv.lastActiveAt - a.conv.lastActiveAt);
+            let busyError;
+            for (const h of hits) {
+                try {
+                    const r = await h.cs.trySteerScheduler(h.conv, text);
+                    if (r.ok) {
+                        flush(h.cs);
+                        return { ok: true, conversationId: h.conv.id, sessionFile: liveFile(h.conv), clientId: h.clientId };
+                    }
+                    if (r.busy)
+                        busyError = r.error;
+                }
+                catch {
+                    // 单客户端坏了继续找下一个
+                }
+            }
+            if (busyError)
+                return { ok: false, busy: true, error: busyError };
+        }
+        return { ok: false, error: "目标对话不在运行中（已关闭或服务重启过）" };
+    }
+    /** issue #231：同项目视口回退 —— 原绑定对话不在时，把唤醒投给该项目最近活跃
+     *  的对话（用户当前正看着的面），而不是静默转无头。excludeIds 跳过已知忙对话；
+     *  候选全部忙回 busy:true；无候选回 ok:false。成功带回实际投递方（调用方重绑定）。 */
+    async wakeViewportInCwd(cwd, text, excludeIds) {
+        const want = String(cwd ?? "").trim();
+        if (!want || !text.trim())
+            return { ok: false, error: "回退目标或文本为空" };
+        if (this.quiesced)
+            return { ok: false, error: "服务器正忙（quiesced），请稍后重试" };
+        const cands = [];
+        for (const [clientId, cs] of this.clients) {
+            try {
+                const conv = cs.findViewportInCwd(want, excludeIds);
+                if (conv)
+                    cands.push({ cs, clientId, conv });
+            }
+            catch {
+                // 单客户端坏了继续找下一个
+            }
+        }
+        cands.sort((a, b) => b.conv.lastActiveAt - a.conv.lastActiveAt);
+        if (cands.length === 0)
+            return { ok: false, error: "同项目无存活对话" };
+        let busyError;
+        for (const c of cands) {
+            try {
+                const r = await c.cs.trySteerScheduler(c.conv, text);
+                if (r.ok) {
                     try {
-                        cs.flushSnapshot();
+                        c.cs.flushSnapshot();
                     }
                     catch {
                         // 推送失败不影响已投递的唤醒
                     }
-                    return { ok: true, conversationId: id };
+                    let f = "";
+                    try {
+                        f = String(c.conv.session.sessionFile ?? "");
+                    }
+                    catch {
+                        f = "";
+                    }
+                    return { ok: true, conversationId: c.conv.id, sessionFile: f, clientId: c.clientId };
                 }
+                if (r.busy)
+                    busyError = r.error;
             }
             catch {
                 // 单客户端坏了继续找下一个
             }
         }
-        return { ok: false, error: "目标对话不在运行中（已关闭或服务重启过）" };
+        if (busyError)
+            return { ok: false, busy: true, error: busyError };
+        return { ok: false, error: "同项目对话投递失败" };
     }
     /** issue #145：别处在某 cwd 下正在跑的对话（同项目并行感知用，不含请求方）。 */
     listProjectRunners(cwd, excludeClientId) {
@@ -6911,6 +7946,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) {
@@ -6985,7 +8037,11 @@ export class AgentService {
      *  快照/notice 发了即丢，不攒内存。fire-and-forget：prompt 投递即返回，
      *  运行结果经 onRunEvent(run_end) 按 conversationId 关联。
      *  v1 语义：与该服务 cwd 下最近会话共享（单用户视角连续）；peer 名由插件
-     *  拼进文本前缀，per-peer 会话隔离以后再加。 */
+     *  拼进文本前缀，per-peer 会话隔离以后再加。
+     *  issue #226：对齐定时任务的四件套——conversationId 命中时走 steer 语义
+     *  投递（网页端实时可见，miss 则回落无头）；cwd 显式 pin 住（不存在/系统
+     *  目录即拒绝，不默默跑错目录）；model/thinkingLevel 投递前应用（失败即
+     *  拒绝，不回落，避免账单/效果与预期不符）。 */
     async chatFromPlugin(pluginId, req) {
         const safe = String(pluginId ?? "plugin").replace(/[^A-Za-z0-9_-]/g, "") || "plugin";
         const acct = String(req?.accountId ?? "default").replace(/[^A-Za-z0-9_-]/g, "") || "default";
@@ -6995,10 +8051,52 @@ export class AgentService {
             throw new Error("chatFromPlugin: text 为空");
         if (this.quiesced)
             throw new QuiesceRejectedError("插件无头调用被拒绝，请等服务器恢复后重试");
+        // 1. 绑定已有会话：steer 语义投递，网页端实时可见（微信当远程遥控器用）。
+        // miss/已回收时不抛错，回落无头伪客户端（浏览器关着时微信照常可用）。
+        const target = String(req?.conversationId ?? "").trim();
+        if (target) {
+            const w = await this.wakeConversation(target, text);
+            if (w.ok)
+                return { conversationId: target, clientId: w.clientId ?? clientId };
+        }
+        // 2. 工作空间：不传回落伪客户端当前目录；传了必须存在且非系统目录。
+        const cwdReq = String(req?.cwd ?? "").trim();
+        let cwdAbs = "";
+        if (cwdReq) {
+            const chk = checkPluginCwd(cwdReq);
+            if (!chk.ok)
+                throw new Error(`chatFromPlugin: ${chk.error}`);
+            cwdAbs = chk.abs ?? "";
+        }
         const cs = await this.attach(clientId, () => { });
-        const before = cs.readConversationForPlugins()?.conversationId ?? "";
+        try {
+            if (cwdAbs && cs.cwd !== cwdAbs)
+                await cs.setCwd(cwdAbs);
+        }
+        catch (err) {
+            throw new Error(`chatFromPlugin: 切换工作目录失败（${cwdAbs}）：${err.message}`);
+        }
+        const model = String(req?.model ?? "").trim();
+        if (model) {
+            try {
+                await cs.switchModelOrThrow(model);
+            }
+            catch (err) {
+                throw new Error(`chatFromPlugin: 切换模型失败（${model}）：${err.message}`);
+            }
+        }
+        const thinking = String(req?.thinkingLevel ?? "").trim();
+        if (thinking) {
+            try {
+                cs.setThinking(thinking);
+            }
+            catch (err) {
+                throw new Error(`chatFromPlugin: 切换思考强度失败（${thinking}）：${err.message}`);
+            }
+        }
+        const conversationId = cs.readConversationForPlugins()?.conversationId ?? "";
         void cs.prompt(text);
-        return { conversationId: before, clientId };
+        return { conversationId, clientId };
     }
     /** 内置定时任务的无头执行（issue #184，server/scheduler-tasks.ts 的 executor）。
      *  每个任务独立伪客户端 `scheduler:<taskId>`（专属会话连续、无浏览器也能跑）；
@@ -7030,7 +8128,7 @@ export class AgentService {
             const model = String(task.model ?? "").trim();
             if (model) {
                 try {
-                    await cs.setModel(model);
+                    await cs.switchModelOrThrow(model);
                 }
                 catch (err) {
                     return { ok: false, error: `切换模型失败（${model}）：${err.message}` };
@@ -7194,6 +8292,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);