pi-web-ui 0.91.0 → 0.92.0

package/dist/server/agent-service.js

@@ -40,14 +40,21 @@ 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";
@@ -1510,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"
@@ -1534,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));
@@ -1556,6 +1578,28 @@ export class ClientSession {
             },
         };
     }
+    /** claim_files 工具的数据宿主：owner 口径同 subagent/skill（本 runtime 所属会话）。
+     *  常驻注册、不进 AGENT_TOOL_CATALOG（例外：目录工具必须有设置页行，见
+     *  settings-tool-rows.test.ts，而 web/src 正被并行任务占用；advisory 工具常驻
+     *  默认开可接受，目录项 + 设置行等 web/src 空出来后补）。 */
+    claimToolHost(ownerId) {
+        const target = () => {
+            try {
+                return (ownerId ?? "").trim() !== "" ? this.convs.get(ownerId.trim()) : this.convs.get(this.activeId);
+            }
+            catch {
+                return undefined;
+            }
+        };
+        return {
+            cwd: () => target()?.cwd ?? this.cwd,
+            self: () => {
+                const t = target();
+                return { convId: t?.id ?? this.activeId, title: t?.title ?? "" };
+            },
+            store: () => this.getClaimStore?.(),
+        };
+    }
     /** skill 工具的数据宿主：读所属会话 loader 的实时技能表 + 主会话禁用集过滤
      * （与 skillsOverride 主会话语义一致）。ownerId 语义同 browser_page（本
      * runtime 所属会话，不是派发瞬间的 active）。失败回空目录，不抛错。 */
@@ -1966,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,
@@ -1988,6 +2037,14 @@ export class ClientSession {
                     // 设置关 → 原生 bash；开 → 终端 bash。
                     () => this.settingsSvc.current.terminalBash),
                     ...makePersistentTerminalTools(terminals, effectiveCwd, () => this.getLang()),
+                    // 覆盖 SDK 内置 read（customTools 按 name 覆盖）：路径是目录时列出目录
+                    // 条目（复用 SDK ls 的排序/`/` 后缀/截断口径），其余情况原样转发内置实现。
+                    // 开关是行为开关（read 本体不可关），每次调用实时读设置——不进
+                    // tool-manager 的 ActiveSet 目录。DSH 引擎无 customTool 注册面，不接。
+                    makeReadDirTool(effectiveCwd, {
+                        dirEnabled: () => this.settingsSvc.current.readDirEnabled !== false,
+                        getLang: () => this.getLang(),
+                    }),
                     // 不覆盖内置 edit 的独立宽松编辑工具（缩进不敏感匹配；开关看设置）。
                     makeEditSoftTool(effectiveCwd, () => this.getLang()),
                     // 插件注册的 AI 工具（创建时刻的实时快照，已按 disabledPluginTools 过滤；
@@ -2017,16 +2074,38 @@ export class ClientSession {
                     // 标准引擎的 ask_user_question：模型调用 → 浏览器富渲染问卷（复用 DSH
                     // 的 question_pending/question_answer 协议，前端 DshQuestionDialog）。
                     // DSH 引擎不经此（它走 goal-rpc 的 userQuestions provider）。
-                    makeAskUserQuestionTool(this, ownerId),
+                    makeAskUserQuestionTool(bridge, ownerId),
                     // 浏览器页面工具：模型调用 → page_request 给浏览器 → page-picker 扩展
                     // 操作用户授权的页面 → page_response 回来。ownerId 语义同上（本 runtime
                     // 所属会话，不是派发瞬间的 active）。
-                    makeBrowserPageTool(this, ownerId),
+                    makeBrowserPageTool(bridge, ownerId),
                     // 别的对话读取（运行中含子代理 + 历史转录，只读）：用户引用了别的
                     // 对话（引用 chip / 粘过来的 id / “看看之前那个对话”）时用。子代理
                     // 会话同样注册了它，可自然嵌套读取。不需要 ownerId——读的是本
                     // 客户端的 conversation 体系与落盘历史，与派发者无关。
-                    makeConversationReadTool(this.conversationReadHost(), () => this.getLang()),
+                    // extras 认领表：files/status 顺带展示（AgentService 级共享）。
+                    makeConversationReadTool(this.conversationReadHost(), () => this.getLang(), {
+                        listClaims: (cwd) => (this.getClaimStore?.().list(cwd) ?? []).map((c) => ({
+                            path: c.path,
+                            ownerTitle: c.ownerTitle,
+                            ...(c.note ? { note: c.note } : {}),
+                        })),
+                    }),
+                    // 文件认领（claim_files）：常驻注册、不进工具目录（见 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。
@@ -2038,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 {
@@ -2203,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();
     }
@@ -2962,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": {
@@ -3326,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（用户取消）。
@@ -3651,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 下正在跑的对话（同项目并行感知用）；
@@ -3665,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;
@@ -3889,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);
@@ -3937,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);
     }
@@ -3968,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
@@ -3992,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;
+        }
+        // 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;
-        const cur = this.modelAdmin.getActiveKeyName(provider);
-        if (cur === saved)
+        if (this.modelAdmin.getActiveKeyName(provider) === globalPin)
             return;
-        if (!this.modelAdmin.hasProviderKey(provider, saved)) {
-            this.stateStore.deleteProjectProviderKey(this.clientId, cwd, provider);
+        if (!this.modelAdmin.hasProviderKey(provider, globalPin))
             return;
-        }
-        const ok = await this.modelAdmin.activateProviderKey(provider, saved, { silent: true });
-        if (!ok)
-            this.stateStore.deleteProjectProviderKey(this.clientId, cwd, provider);
+        await this.modelAdmin.activateProviderKey(provider, globalPin, { silent: true });
     }
     /** Remember the just-selected model (and the key that was active for its
      *  provider) for the current project. Called IMMEDIATELY on model selection —
@@ -4034,9 +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 {
@@ -4338,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 {
@@ -4503,32 +4706,133 @@ export class ClientSession {
             // 通告一次（steer/排队等流式中发送不重复打扰）。
             // parallelReminderEnabled=false 时整段跳过（不发 notice、不注 AI、不通知对端）。
             if (!conv.isSubagent && !s.isStreaming && this.settingsSvc.current.parallelReminderEnabled !== false) {
+                // 认领心跳：本对话发 prompt = 还活着，自己名下的认领续期（同步内存操作）。
+                try {
+                    this.getClaimStore?.().touch(conv.id);
+                }
+                catch {
+                    // ignore
+                }
+                let projectClaims = [];
+                try {
+                    projectClaims = this.getClaimStore?.().list(conv.cwd) ?? [];
+                }
+                catch {
+                    projectClaims = [];
+                }
+                // 本窗口正在跑的：子代理也算进来（以前 !c.isSubagent 把它们排除在外，
+                // 对方用子代理干活时 AI 完全收不到提示），标明归属。触碰集就地从内存
+                // 消息算，无 I/O，不阻塞发送路径。
                 const localRunners = [...this.convs.values()]
-                    .filter((c) => c.id !== conv.id && !c.isSubagent && c.cwd === conv.cwd && this.conversationStreaming(c))
-                    .map((c) => ({ title: c.title }));
+                    .filter((c) => c.id !== conv.id && c.cwd === conv.cwd && this.conversationStreaming(c))
+                    .map((c) => {
+                    let label;
+                    if (c.isSubagent) {
+                        const parent = c.parentId ? this.convs.get(c.parentId) : undefined;
+                        label = parent ? `本窗口「${parent.title}」的子代理「${c.title}」` : `本窗口子代理「${c.title}」`;
+                    }
+                    else {
+                        label = `本窗口「${c.title}」`;
+                    }
+                    return { label, touches: extractTouches(this.convTranscript(c)) };
+                });
                 const externalRunners = (this.listProjectRunners?.(conv.cwd) ?? []).filter((r) => r.sessionFile === undefined || (activeFile !== undefined && resolve(r.sessionFile) !== activeFile));
-                const runnerTitles = [
-                    ...localRunners.map((r) => `本窗口「${r.title}」`),
+                // 取舍（诚实降级）：外部运行只有 title + sessionFile，触碰集要读对方
+                // 转录文件 —— 同步文件 I/O 会阻塞发送路径，不做；提醒里如实写
+                // 「外部运行的文件触碰未知」，不编造。
+                // 每条 ≤60 字符（以前整串 slice(0, 600)，经常从半截路径处拦腰截断）。
+                const capItem = (st) => (st.length <= 60 ? st : `${st.slice(0, 59)}…`);
+                const noticeTitles = [
+                    ...localRunners.map((r) => r.label),
                     ...externalRunners.map((r) => `另一处「${r.title}」`),
-                ];
-                if (runnerTitles.length > 0) {
-                    const shown = runnerTitles.slice(0, 3).join("、");
-                    const more = runnerTitles.length > 3 ? `等 ${runnerTitles.length} 处` : "";
+                ].map(capItem);
+                const aiItems = [
+                    ...localRunners.map((r) => `${r.label}·${r.touches.length} files`),
+                    ...externalRunners.map((r) => `另一处「${r.title}」·touches unknown`),
+                ].map(capItem);
+                if (noticeTitles.length > 0) {
+                    const shown = noticeTitles.slice(0, 3).join("、");
+                    const more = noticeTitles.length > 3 ? `等 ${noticeTitles.length} 处` : "";
                     this.emit({
                         type: "notice",
                         level: "info",
                         text: `同项目并行提醒：${shown}${more}正在同一项目运行。你可以继续（适合改不同文件），改动同一文件前请先确认；拿不准就等它跑完。`,
                         textEn: `Parallel-work notice: ${shown}${more ? " and more" : ""} running in the same project. You may continue (fine for different files); confirm before touching the same files, or wait for it to finish when unsure.`,
                     });
-                    // 给 AI 的上下文：评估冲突概率，拿不准就 ask_user_question 让用户选
-                    // （并行 / 等它跑完 / 只读围观）。display:false —— 用户界面只看上面的 notice。
-                    const aiReminder = `(System reminder: ${runnerTitles.length} other run(s) [${runnerTitles.join("; ").slice(0, 600)}] ` +
-                        `are currently running in the same project directory. You may work in parallel on different files, ` +
-                        `but before reading/writing files or running commands, assess the conflict probability with the other run(s) ` +
-                        `(same files? same commands? migrations?). If a conflict is likely or you are unsure, ` +
-                        `use ask_user_question to let the user choose: continue in parallel / wait / watch read-only.)\n` +
-                        `（系统提醒：同一项目另有 ${runnerTitles.length} 处运行（${shown}${more}）。改不同文件可并行；` +
-                        `读写文件或跑命令前先评估冲突概率，拿不准就用 ask_user_question 让用户选择：并行 / 等它跑完 / 只读围观。）`;
+                    // 给 AI 的上下文：交集由服务端算好写明“⚠ 双方都动过 X”，AI 不用自己
+                    // 算；拿不准就 ask_user_question 让用户选（并行 / 等它跑完 / 只读围观）。
+                    // display:false —— 用户界面只看上面的 notice。分两档：无交集只给一行
+                    // （省 token），有交集才展开细节。
+                    const mine = extractTouches(this.convTranscript(conv));
+                    // 认领升级（advisory，但比触碰更强：这是对方的事前意图）：
+                    // 我动过 + 对方认领 → 最强信号单独点名；其他认领只给一行汇总。
+                    const othersClaims = projectClaims.filter((c) => c.ownerConvId !== conv.id);
+                    const myClaimed = matchClaims(mine, othersClaims.map((c) => ({
+                        path: c.path,
+                        ownerConvId: c.ownerConvId,
+                        ownerTitle: c.ownerTitle,
+                        claimedAt: 0,
+                        expiresAt: 0,
+                    })), conv.cwd);
+                    const claimHitEn = myClaimed
+                        .slice(0, 3)
+                        .map((h) => `${h.touch.path} (claimed by ${h.claim.ownerTitle})`)
+                        .join("; ");
+                    const claimHitZh = myClaimed
+                        .slice(0, 3)
+                        .map((h) => `${h.touch.path}（${h.claim.ownerTitle}已认领）`)
+                        .join("、");
+                    const claimMore = myClaimed.length > 3 ? ` (+${myClaimed.length - 3})` : "";
+                    const claimsSummaryEn = othersClaims.length > 0
+                        ? ` Claimed by others (steer clear): ${othersClaims
+                            .slice(0, 3)
+                            .map((c) => `${c.path} ("${c.ownerTitle}")`)
+                            .join("; ")}${othersClaims.length > 3 ? ` (+${othersClaims.length - 3})` : ""}.`
+                        : "";
+                    const claimsSummaryZh = othersClaims.length > 0
+                        ? ` 对方认领（绕行）：${othersClaims
+                            .slice(0, 3)
+                            .map((c) => `${c.path}（「${c.ownerTitle}」）`)
+                            .join("、")}${othersClaims.length > 3 ? `（等 ${othersClaims.length - 3} 处）` : ""}。`
+                        : "";
+                    const clashes = localRunners
+                        .map((r) => ({ label: r.label, hits: intersectTouches(r.touches, mine) }))
+                        .filter((r) => r.hits.length > 0);
+                    const extNoteEn = externalRunners.length > 0 ? ` Touched files of external run(s) are unknown.` : "";
+                    const extNoteZh = externalRunners.length > 0 ? `外部运行的文件触碰未知。` : "";
+                    let aiReminder;
+                    if (clashes.length === 0 && myClaimed.length === 0) {
+                        aiReminder =
+                            `(System reminder: ${aiItems.length} other run(s) [${aiItems.join("; ")}] ` +
+                                `are currently running in the same project directory. No file written by both you and them was detected, ` +
+                                `so working on different files in parallel is fine; before writing the same files or running project-wide ` +
+                                `commands, assess the conflict risk first, and use ask_user_question when unsure ` +
+                                `(continue in parallel / wait / watch read-only).${extNoteEn}${claimsSummaryEn})\n` +
+                                `（系统提醒：同一项目另有 ${aiItems.length} 处运行（${shown}${more}）。未发现双方都写过的文件，` +
+                                `改不同文件可并行；动同一文件或跑全局命令前先评估冲突，拿不准就用 ask_user_question 让用户选择：` +
+                                `并行 / 等它跑完 / 只读围观。${extNoteZh}${claimsSummaryZh}）`;
+                    }
+                    else {
+                        // 有交集档：每处 ≤3 条完整路径 + 计数（路径永不截断，见 conversation-touches）。
+                        const clashPartsEn = clashes.map((h) => `${h.label} — you both wrote: ${formatTouchesCompact(h.hits)}`);
+                        if (myClaimed.length > 0) {
+                            clashPartsEn.push(`⚠ you touched and others claimed: ${claimHitEn}${claimMore} — ask the user before touching these again`);
+                        }
+                        const clashEn = clashPartsEn.join("; ");
+                        const clashPartsZh = clashes.map((h) => `⚠ ${h.label}双方都动过：${formatTouchesCompact(h.hits)}`);
+                        if (myClaimed.length > 0) {
+                            clashPartsZh.push(`⚠ 你动过、对方已认领：${claimHitZh}${claimMore} —— 动之前先问用户`);
+                        }
+                        const clashZh = clashPartsZh.join("；");
+                        aiReminder =
+                            `(System reminder: ${aiItems.length} other run(s) [${aiItems.join("; ")}] ` +
+                                `are currently running in the same project directory. ⚠ ${clashEn} — re-read these files before ` +
+                                `touching them again, and use ask_user_question when unsure ` +
+                                `(continue in parallel / wait / watch read-only).${extNoteEn})\n` +
+                                `（系统提醒：同一项目另有 ${aiItems.length} 处运行（${shown}${more}）。` +
+                                `${clashZh} —— 再动这些文件前先读最新内容，拿不准就用 ask_user_question 让用户选择：` +
+                                `并行 / 等它跑完 / 只读围观。${extNoteZh}）`;
+                    }
                     try {
                         await s.sendCustomMessage({
                             customType: "parallel-work-reminder",
@@ -5340,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();
@@ -5347,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) => ({
@@ -5807,6 +6128,8 @@ export class ClientSession {
                 }
             }
             rmSync(abs, { force: true });
+            // 转录删了，sidecar 再留着就是孤儿，一起清掉（不存在不报错）。
+            removeTouchSidecar(abs);
             // 转录删了，未发送草稿再留着就是孤儿，一起清掉。
             try {
                 this.drafts.pruneSessionFile(abs);
@@ -7138,6 +7461,59 @@ export class ClientSession {
         }
         this.flushSnapshot();
     }
+    /** Set the GLOBAL default model ("provider/id"): projects with no memory
+     *  fall back to it (project memory wins). Also remembers the provider's
+     *  currently-active key globally so new projects restore the same {model,
+     *  key} pair. Shared across clients, persisted server-side. */
+    async setDefaultModel(modelId) {
+        try {
+            const mr = this.runtime.services.modelRuntime;
+            const slash = modelId.indexOf("/");
+            if (slash <= 0 || slash === modelId.length - 1) {
+                throw new Error(`无效的模型 ID：${modelId}`);
+            }
+            const provider = modelId.slice(0, slash);
+            const id = modelId.slice(slash + 1);
+            if (!mr.getModel(provider, id))
+                throw new Error(`模型不存在：${modelId}`);
+            this.stateStore.saveDefaultModel(modelId);
+            const active = this.modelAdmin.getActiveKeyName(provider);
+            if (active)
+                this.stateStore.saveDefaultProviderKey(provider, active);
+            this.pushDefaultModel();
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: `🌍 已设全局默认模型 ${modelId}（新项目自动使用，项目记忆优先）`,
+                textEn: `🌍 Global default model set to ${modelId} (new projects follow it; project memory wins)`,
+            });
+        }
+        catch (err) {
+            this.emit({
+                type: "notice",
+                level: "error",
+                text: `设置全局默认模型失败：${err.message}`,
+                textEn: `Failed to set global default model: ${err.message}`,
+            });
+        }
+        this.flushSnapshot();
+    }
+    /** Clear the GLOBAL default model (new projects fall back to the SDK default). */
+    clearDefaultModel() {
+        this.stateStore.clearDefaultModel();
+        this.pushDefaultModel();
+        this.emit({
+            type: "notice",
+            level: "info",
+            text: "🌍 已清除全局默认模型（新项目回到 SDK 默认）",
+            textEn: "🌍 Global default model cleared (new projects use the SDK default)",
+        });
+        this.flushSnapshot();
+    }
+    /** Push the current global default model (attach + after every change). */
+    pushDefaultModel() {
+        this.emit({ type: "default_model", modelId: this.stateStore.getDefaultModel() ?? null });
+    }
     /** 切换模型，失败时抛出（无头路径专用：插件 host.chat / 定时任务）。
      *  setModel 为兼容 UI 把异常吞成 notice（面板要能看到原因、调用方是 fire-and-forget），
      *  无头路径拿不到那个 notice，于是「模型 ID 打错/没配密钥」会变成静默按旧模型跑 ——
@@ -7302,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:
@@ -7322,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. */
@@ -7567,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) {
@@ -7896,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);