@keyou007/agent-bot 0.1.24-alpha.5 → 0.1.24-alpha.7

package/dist/codex/CodexRuntime.js

@@ -1,13 +1,15 @@
 import { statSync } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
 import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import { AppServerRequestError } from "./AppServerConnection.js";
 import { workspaceSandboxFromConfig, workspaceSandboxFromResponse } from "./AppServerPermissions.js";
 import { formatCodexError, mapCodexNotification } from "./CodexEventMapper.js";
 import { CodexLocalActivityDetector } from "./CodexLocalActivityDetector.js";
+import { hasCompletedTraePlanEntry } from "./TraePlanEntry.js";
 import { detectProjectlessWorkspace } from "./ProjectlessWorkspace.js";
 import { threadWriterLockPath } from "./ThreadWriterProcess.js";
-import { assertProviderSettingsApplied, PROVIDER_SWITCH_BUSY, providerSwitchFailure } from "./ProviderSwitch.js";
+import { assertProviderSettingsApplied, PROVIDER_SWITCH_BUSY, PROVIDER_SWITCH_EMPTY, ProviderSwitchError, providerSwitchFailure } from "./ProviderSwitch.js";
 import { fetchProviderModels } from "./ProviderModels.js";
 const WINDOWS_SCREENSHOT_DEVELOPER_INSTRUCTIONS = [
     "When capturing any screenshot on Windows, use one fresh process and make it Per-Monitor DPI Aware V2 before loading System.Windows.Forms, System.Drawing, or UI Automation, and before calling any screen, window, or bounds API.",
@@ -94,6 +96,20 @@ export class CodexRuntime {
     async resumeSession(input) {
         return this.runSessionOperation(input.localSessionId, () => this.resumeSessionNow(input));
     }
+    async prepareSessionForSettings(input) {
+        return this.runSessionOperation(input.localSessionId, async () => {
+            const existing = this.sessions.get(input.localSessionId);
+            if (existing)
+                return existing;
+            const session = this.makeSession(input, {
+                thread: { id: input.remoteSessionId, name: input.title },
+                modelProvider: input.modelProvider, model: input.model,
+            }, input.reasoningEffort);
+            session.needsResume = true;
+            this.sessions.set(input.localSessionId, session);
+            return session;
+        });
+    }
     async resumeSessionNow(input) {
         const client = await this.client();
         const response = await client.request("thread/resume", {
@@ -105,8 +121,18 @@ export class CodexRuntime {
             ...threadLifecycleParams(input.cwd),
             ...permissionParams(input.permissionMode),
         }, SESSION_REQUEST_TIMEOUT_MS);
+        if (response.thread.id !== input.remoteSessionId)
+            throw new Error("App Server 返回了不同的任务 ID，未恢复会话。");
         const reasoningEffort = await this.resolveReasoningEffort(input, response);
         const session = this.makeSession(input, response, reasoningEffort);
+        try {
+            assertProviderSettingsApplied(response, { modelProvider: input.modelProvider });
+        }
+        catch (error) {
+            // Keep the attachment available for an explicit settings repair, but never send to the wrong Provider.
+            session.settingsRecoveryError = providerSwitchFailure(error);
+            session.needsResume = true;
+        }
         this.sessions.set(input.localSessionId, session);
         return session;
     }
@@ -150,13 +176,18 @@ export class CodexRuntime {
         const session = this.requireSession(sessionId);
         const client = await this.client();
         await this.ensureSessionResumed(session, client);
-        session.canReplaceEmptyThread = false;
         const start = async () => client.request("turn/start", {
             threadId: session.remoteSessionId,
             input: codexUserInput(prompt),
             cwd: session.cwd,
             model: session.model,
             effort: session.reasoningEffort,
+            ...(typeof prompt !== "string" && prompt.collaborationMode ? {
+                collaborationMode: {
+                    mode: prompt.collaborationMode,
+                    settings: { model: session.model, reasoning_effort: session.reasoningEffort ?? null, developer_instructions: null },
+                },
+            } : {}),
             summary: "auto",
             approvalPolicy: session.permissionMode === "auto" ? "never" : "on-request",
             sandboxPolicy: await this.turnSandboxPolicy(session, client),
@@ -444,9 +475,10 @@ export class CodexRuntime {
             .find((session) => session.remoteSessionId === remoteSessionId);
         const detectedTurnId = activeThreads?.get(remoteSessionId);
         // A turn started in this process is evidence; a restored activeTurnId alone is not.
+        const observedTurnId = runtimeSession?.activeTurnStartedAt !== undefined ? runtimeSession.activeTurnId : undefined;
         const active = status === "active" || Boolean(activeThreads?.has(remoteSessionId))
-            || Boolean(runtimeSession?.activeTurnId && runtimeSession.activeTurnStartedAt !== undefined);
-        const activeTurnId = detectedTurnId ?? runtimeSession?.activeTurnId;
+            || Boolean(observedTurnId);
+        const activeTurnId = detectedTurnId ?? observedTurnId;
         return {
             active,
             ...(active && activeTurnId ? { activeTurnId } : {}),
@@ -479,6 +511,14 @@ export class CodexRuntime {
         await this.interruptRemoteTurn(session.remoteSessionId, turnId, sessionId);
     }
     async interruptRemoteTurn(remoteSessionId, turnId, sessionId) {
+        for (const session of this.sessions.values()) {
+            if (session.remoteSessionId === remoteSessionId)
+                session.planContinuationTurnId = undefined;
+        }
+        for (const pending of this.modeChanges.values()) {
+            if (pending.turnId === turnId)
+                pending.decision = "cancel";
+        }
         await (await this.client()).request("turn/interrupt", { threadId: remoteSessionId, turnId }, CONTROL_REQUEST_TIMEOUT_MS);
         this.logger.info({ ...(sessionId ? { sessionId } : {}), threadId: remoteSessionId, turnId }, "App Server accepted the turn interrupt request.");
     }
@@ -488,13 +528,53 @@ export class CodexRuntime {
             await this.archiveRemoteSession(session.remoteSessionId);
         });
     }
-    async archiveRemoteSession(remoteSessionId) {
-        await (await this.client()).request("thread/archive", { threadId: remoteSessionId }, CONTROL_REQUEST_TIMEOUT_MS);
+    async archiveRemoteSession(remoteSessionId, options = {}) {
+        const client = await this.client();
+        try {
+            await client.request("thread/archive", { threadId: remoteSessionId }, CONTROL_REQUEST_TIMEOUT_MS);
+        }
+        catch (error) {
+            if (!options.allowUnmaterialized || !(error instanceof AppServerRequestError)
+                || error.method !== "thread/archive" || error.code !== -32600
+                || error.serverMessage !== `no rollout found for thread id ${remoteSessionId}`
+                || !await this.isUnmaterializedThread(client, remoteSessionId))
+                throw error;
+            // Codex has nothing to move to its archive before the first user message.
+            const result = await client.request("thread/unsubscribe", { threadId: remoteSessionId }, CONTROL_REQUEST_TIMEOUT_MS);
+            if (!["unsubscribed", "notLoaded", "notSubscribed"].includes(result.status)) {
+                throw new Error(`Cannot release empty App Server task: ${result.status}`);
+            }
+            this.logger.info({ remoteSessionId }, "Released an empty App Server task without a materialized rollout.");
+        }
         for (const [localSessionId, session] of this.sessions) {
             if (session.remoteSessionId === remoteSessionId)
                 this.sessions.delete(localSessionId);
         }
     }
+    async isUnmaterializedThread(client, remoteSessionId) {
+        const { thread } = await client.request("thread/read", { threadId: remoteSessionId, includeTurns: false }, CONTROL_REQUEST_TIMEOUT_MS);
+        if (thread.id !== remoteSessionId || thread.preview !== "" || thread.forkedFromId !== null
+            || !["idle", "notLoaded"].includes(thread.status?.type ?? "") || !thread.path
+            || (thread.turns?.length ?? 0) > 0)
+            return false;
+        for (const session of this.sessions.values()) {
+            if (session.remoteSessionId === remoteSessionId && (session.activeTurnId
+                || session.knownTurnIds.size > 0 || (session.turnCount ?? 0) > 0))
+                return false;
+        }
+        const active = await this.localActivityDetector?.activeThreads([remoteSessionId]);
+        if (active?.has(remoteSessionId))
+            return false;
+        try {
+            statSync(thread.path);
+            return false;
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return true;
+            throw error;
+        }
+    }
     async setTitle(sessionId, title) {
         return this.runSessionOperation(sessionId, () => this.setTitleNow(sessionId, title));
     }
@@ -523,7 +603,6 @@ export class CodexRuntime {
         const session = this.requireSession(sessionId);
         const client = await this.client();
         await this.ensureSessionResumed(session, client);
-        session.canReplaceEmptyThread = false;
         const response = await client.request("thread/goal/set", { threadId: session.remoteSessionId, ...update }, CONTROL_REQUEST_TIMEOUT_MS);
         return response.goal;
     }
@@ -547,7 +626,18 @@ export class CodexRuntime {
         await this.runSessionOperation(sessionId, async () => { this.requireSession(sessionId).permissionMode = mode; });
     }
     async setExecutionSettings(sessionId, settings, persist) {
-        return this.runSessionOperation(sessionId, () => this.setExecutionSettingsNow(sessionId, settings, persist));
+        return this.runSessionOperation(sessionId, async () => {
+            try {
+                return await this.setExecutionSettingsNow(sessionId, settings, persist);
+            }
+            catch (error) {
+                if (error instanceof ProviderSwitchError)
+                    throw error;
+                // Errors outside the mutation block are preflight failures; no settings were changed.
+                const session = this.sessions.get(sessionId);
+                throw new ProviderSwitchError(providerSwitchFailure(error), Boolean(session && !session.needsResume && !session.settingsRecoveryError), { cause: error });
+            }
+        });
     }
     async setExecutionSettingsNow(sessionId, settings, persist) {
         const session = this.requireSession(sessionId);
@@ -561,88 +651,60 @@ export class CodexRuntime {
         if (metadata.thread.status?.type === "active" || localActive?.has(session.remoteSessionId) || session.activeTurnId) {
             throw new Error(PROVIDER_SWITCH_BUSY);
         }
-        let empty = false;
-        if (session.canReplaceEmptyThread && !metadata.thread.forkedFromId && !metadata.thread.preview?.trim()) {
+        if (session.turnCount === 0 && !metadata.thread.forkedFromId && !metadata.thread.preview?.trim()) {
             try {
                 const turns = await this.readLatestThreadTurns(client, session.remoteSessionId, "summary");
-                empty = turns.length === 0;
-                if (!empty)
-                    session.canReplaceEmptyThread = false;
+                if (turns.length === 0)
+                    throw new Error(PROVIDER_SWITCH_EMPTY);
             }
             catch (error) {
                 if (!(error instanceof AppServerRequestError) || error.method !== "thread/turns/list"
                     || !/missing source rollout|no rollout found/iu.test(error.serverMessage))
                     throw error;
-                empty = true;
+                throw new Error(PROVIDER_SWITCH_EMPTY, { cause: error });
             }
         }
         const previous = { ...session };
-        let replacementId;
+        const restoreProvider = previous.modelProvider?.trim()
+            || (metadata.thread.id === previous.remoteSessionId ? metadata.thread.modelProvider?.trim() : undefined);
         let detached = false;
         try {
             const params = {
                 cwd: session.cwd, modelProvider: settings.modelProvider, model: settings.model,
                 ...threadLifecycleParams(session.cwd), ...permissionParams(settings.permissionMode),
             };
-            if (!empty) {
-                await this.detachThreadForSettings(client, session);
-                detached = true;
-            }
-            let response;
-            if (empty) {
-                response = await client.request("thread/start", {
-                    ...params, threadSource: "user", allowProviderModelFallback: false,
-                }, SESSION_REQUEST_TIMEOUT_MS);
-                replacementId = response.thread.id;
-            }
-            else {
-                response = await client.request("thread/resume", {
-                    ...params, threadId: session.remoteSessionId, excludeTurns: true,
-                }, SESSION_REQUEST_TIMEOUT_MS);
-                if (!providerSettingsMatch(response, settings)) {
-                    this.logger.warn({
-                        sessionId,
-                        threadId: session.remoteSessionId,
-                        requestedProvider: settings.modelProvider,
-                        actualProvider: response.modelProvider,
-                        requestedModel: settings.model,
-                        actualModel: response.model,
-                    }, "App Server did not apply Provider settings while resuming; forking the latest completed Turn.");
-                    await this.detachThreadForSettings(client, session);
-                    response = await this.forkThreadForSettings(client, session, settings);
-                    replacementId = response.thread.id;
-                }
-            }
+            await this.detachThreadForSettings(client, session, () => { detached = true; });
+            const response = await client.request("thread/resume", {
+                ...params, threadId: session.remoteSessionId, excludeTurns: true,
+            }, SESSION_REQUEST_TIMEOUT_MS);
             assertProviderSettingsApplied(response, settings);
-            if (!empty && !replacementId && response.thread.id !== session.remoteSessionId) {
+            if (response.thread.id !== session.remoteSessionId) {
                 throw new Error("App Server 返回了不同的任务 ID，未保存设置。");
             }
-            if (session.title && (empty || replacementId))
-                await client.request("thread/name/set", {
-                    threadId: response.thread.id, name: session.title,
-                }, SESSION_REQUEST_TIMEOUT_MS);
-            const candidate = { ...session, ...settings, remoteSessionId: response.thread.id,
+            const candidate = { ...session, ...settings,
                 workspaceSandboxPolicy: workspaceSandboxFromResponse(response.sandbox),
                 needsResume: false, settingsRecoveryError: undefined };
             await persist?.(candidate);
-            Object.assign(session, candidate);
+            Object.assign(session, settings);
+            session.workspaceSandboxPolicy = candidate.workspaceSandboxPolicy;
+            session.needsResume = this.attachedClient !== client;
+            session.settingsRecoveryError = undefined;
         }
         catch (error) {
-            if (replacementId)
-                await this.discardUnusedThread(client, replacementId);
             let recovery = "原任务设置未更改。";
             if (detached) {
                 try {
+                    if (!restoreProvider)
+                        throw new Error("无法确认切换前的 Provider，不能验证原设置已恢复。");
                     await this.detachThreadForSettings(client, previous);
                     const restored = await client.request("thread/resume", {
                         threadId: previous.remoteSessionId, excludeTurns: true, cwd: previous.cwd,
-                        modelProvider: previous.modelProvider, model: previous.model,
+                        modelProvider: restoreProvider, model: previous.model,
                         ...threadLifecycleParams(previous.cwd), ...permissionParams(previous.permissionMode),
                     }, SESSION_REQUEST_TIMEOUT_MS);
-                    if (previous.modelProvider && previous.model)
-                        assertProviderSettingsApplied(restored, {
-                            modelProvider: previous.modelProvider, model: previous.model,
-                        });
+                    assertProviderSettingsApplied(restored, {
+                        modelProvider: restoreProvider, model: previous.model,
+                    });
                     if (restored.thread.id !== previous.remoteSessionId)
                         throw new Error("恢复时返回了不同的任务 ID。");
                     session.needsResume = false;
@@ -656,52 +718,29 @@ export class CodexRuntime {
                     session.needsResume = true;
                 }
             }
-            throw new Error(`Provider 切换失败：${providerSwitchFailure(error)} ${recovery}`, { cause: error });
+            throw new ProviderSwitchError(`Provider 切换失败：${providerSwitchFailure(error)} ${recovery}`, !session.needsResume && !session.settingsRecoveryError, { cause: error });
         }
-        if (replacementId)
-            await this.discardUnusedThread(client, previous.remoteSessionId);
         return session;
     }
-    async detachThreadForSettings(client, session) {
+    async detachThreadForSettings(client, session, onDetach) {
         const current = await client.request("thread/read", {
             threadId: session.remoteSessionId, includeTurns: false,
         }, SYNC_REQUEST_TIMEOUT_MS);
         if (session.activeTurnId || current.thread.status?.type === "active")
             throw new Error(PROVIDER_SWITCH_BUSY);
+        // A timeout does not cancel the remote unsubscribe, so recovery is required once it is sent.
+        onDetach?.();
         const result = await client.request("thread/unsubscribe", {
             threadId: session.remoteSessionId,
         }, CONTROL_REQUEST_TIMEOUT_MS);
-        if (result.status !== "unsubscribed" && result.status !== "notLoaded") {
-            throw new Error("当前任务仍由其他客户端加载，无法安全切换 Provider。请先在原客户端释放任务。");
-        }
-    }
-    async forkThreadForSettings(client, session, settings) {
-        const turns = await this.listRecentThreadTurnsThroughCompleted(client, session.remoteSessionId);
-        const lastTurnId = turns.find((turn) => turn.status === "completed")?.id;
-        if (!lastTurnId) {
-            throw new Error("无法为 Provider 切换找到已完成的 Turn。请先完成一轮任务后重试。");
-        }
-        return client.request("thread/fork", {
-            threadId: session.remoteSessionId,
-            lastTurnId,
-            cwd: session.cwd,
-            model: settings.model,
-            modelProvider: settings.modelProvider,
-            threadSource: "user",
-            excludeTurns: true,
-            ...threadLifecycleParams(session.cwd),
-            ...permissionParams(settings.permissionMode),
-        }, FORK_REQUEST_TIMEOUT_MS);
-    }
-    async discardUnusedThread(client, threadId) {
-        try {
-            await client.request("thread/unsubscribe", { threadId }, CONTROL_REQUEST_TIMEOUT_MS);
-        }
-        catch (error) {
-            this.logger.warn({ error, threadId }, "Failed to release an unused empty Thread after changing Provider.");
+        if (!["unsubscribed", "notLoaded", "notSubscribed"].includes(result.status)) {
+            throw new Error(`App Server 返回了未知的取消订阅状态：${result.status}`);
         }
     }
     async respondToApproval(sessionId, requestId, decision) {
+        return this.resolveApproval(sessionId, requestId, decision);
+    }
+    async resolveApproval(sessionId, requestId, decision, automatic = false) {
         const modeChange = this.modeChanges.get(requestId);
         if (modeChange) {
             if (modeChange.sessionId !== sessionId
@@ -714,22 +753,34 @@ export class CodexRuntime {
             if (modeChange.responding)
                 throw new Error("Approval response is already in progress.");
             modeChange.responding = true;
+            modeChange.decision = decision;
+            modeChange.automatic = automatic;
             try {
                 const client = await this.client();
                 if (this.modeChanges.get(requestId) !== modeChange)
                     throw new Error("Approval request is no longer pending.");
-                await client.request("mode/change/respond", {
-                    threadId: this.requireSession(sessionId).remoteSessionId,
-                    requestId: modeChange.requestId,
-                    decision: decision === "accept" ? "approved" : decision === "decline" ? "rejected" : "cancelled",
-                }, CONTROL_REQUEST_TIMEOUT_MS);
+                try {
+                    await client.request("mode/change/respond", {
+                        threadId: this.requireSession(sessionId).remoteSessionId,
+                        requestId: modeChange.requestId,
+                        decision: decision === "accept" ? "approved" : decision === "decline" ? "rejected" : "cancelled",
+                    }, CONTROL_REQUEST_TIMEOUT_MS);
+                }
+                catch (error) {
+                    if (!await this.reconcileCompletedPlanEntry(requestId, modeChange, error))
+                        throw error;
+                }
                 if (this.modeChanges.get(requestId) === modeChange) {
+                    this.confirmPlanContinuation(modeChange, decision);
                     this.modeChanges.delete(requestId);
-                    this.emit({ type: "approval_resolved", sessionId, turnId: modeChange.turnId, requestId, decision });
+                    this.emit({ type: "approval_resolved", sessionId, turnId: modeChange.turnId, requestId, decision,
+                        ...(automatic ? { automatic: true } : {}) });
                 }
             }
             finally {
                 modeChange.responding = false;
+                if (modeChange.terminalEvent)
+                    this.emit(modeChange.terminalEvent);
             }
             return;
         }
@@ -740,6 +791,36 @@ export class CodexRuntime {
         pending.resolve({ decision });
         this.emit({ type: "approval_resolved", sessionId, turnId: pending.turnId, requestId, decision });
     }
+    async reconcileCompletedPlanEntry(requestId, pending, error) {
+        const session = this.sessions.get(pending.sessionId);
+        if (!pending.automatic || pending.decision !== "accept" || pending.targetMode !== "plan"
+            || this.provider.getAgentFamily?.() !== "traex" || !session?.rolloutPath
+            || !(error instanceof AppServerRequestError) || error.method !== "mode/change/respond" || error.code !== -32600
+            || error.serverMessage !== `failed to respond to mode change request: No pending mode change found for request_id: ${pending.requestId}`) {
+            return false;
+        }
+        const toolCallId = pending.sourceToolCallId ?? pending.requestId;
+        for (const waitMs of [0, 100, 200]) {
+            if (waitMs)
+                await delay(waitMs);
+            if (this.modeChanges.get(requestId) !== pending || this.sessions.get(pending.sessionId) !== session
+                || session.activeTurnId !== pending.turnId)
+                return false;
+            try {
+                if (!await hasCompletedTraePlanEntry(session.rolloutPath, pending.turnId, toolCallId))
+                    continue;
+                if (this.modeChanges.get(requestId) !== pending || this.sessions.get(pending.sessionId) !== session
+                    || session.activeTurnId !== pending.turnId)
+                    return false;
+                this.logger.info({ sessionId: pending.sessionId, turnId: pending.turnId, requestId, toolCallId }, "Verified that TraeX already completed the automatic plan-mode entry.");
+                return true;
+            }
+            catch (verificationError) {
+                this.logger.debug({ error: verificationError, sessionId: pending.sessionId, requestId }, "Could not verify TraeX plan-mode entry from the rollout tail.");
+            }
+        }
+        return false;
+    }
     async listModels(modelProvider, fallbackModel) {
         return (await this.listModelsWithStatus(modelProvider, fallbackModel)).models;
     }
@@ -958,25 +1039,37 @@ export class CodexRuntime {
             if (session.modeChangeRequestIds.has(requestId))
                 return;
             session.modeChangeRequestIds.add(requestId);
-            this.modeChanges.set(requestId, {
+            const pending = {
                 sessionId, turnId: mapped.turnId, requestId: mapped.requestId,
                 targetMode: mapped.targetMode, responding: false,
-            });
-            this.emit({
-                type: "approval_requested", sessionId, turnId: mapped.turnId,
-                request: {
-                    id: requestId,
-                    kind: "mode_change",
-                    title: mapped.targetMode === "default" ? "确认方案并开始执行" : "确认进入规划模式",
-                    reason: [mapped.reason, ...(mapped.allowedPrompts ?? []).map((entry) => `- ${entry.tool}: ${entry.prompt}`)]
-                        .filter(Boolean).join("\n"),
-                    options: [
-                        { id: "accept", label: mapped.targetMode === "default" ? "Approve Plan" : "Enter Plan Mode" },
-                        { id: "decline", label: "Reject" },
-                        { id: "cancel", label: "Cancel Request" },
-                    ],
-                },
-            });
+                sourceToolCallId: mapped.sourceToolCallId ?? undefined,
+            };
+            this.modeChanges.set(requestId, pending);
+            const automatic = session.permissionMode === "auto" && this.provider.getAgentFamily?.() === "traex";
+            const request = {
+                id: requestId,
+                kind: "mode_change",
+                ...(automatic ? { automatic: true } : {}),
+                title: mapped.targetMode === "default" ? "确认方案并开始执行" : "确认进入规划模式",
+                reason: [mapped.reason, ...(mapped.allowedPrompts ?? []).map((entry) => `- ${entry.tool}: ${entry.prompt}`)]
+                    .filter(Boolean).join("\n"),
+                options: [
+                    { id: "accept", label: mapped.targetMode === "default" ? "Approve Plan" : "Enter Plan Mode" },
+                    { id: "decline", label: "Reject" },
+                    { id: "cancel", label: "Cancel Request" },
+                ],
+            };
+            this.emit({ type: "approval_requested", sessionId, turnId: mapped.turnId, request });
+            if (automatic) {
+                void this.resolveApproval(sessionId, requestId, "accept", true).catch((error) => {
+                    if (this.modeChanges.get(requestId) !== pending || session.activeTurnId !== mapped.turnId)
+                        return;
+                    this.logger.warn({ error, sessionId, requestId, turnId: mapped.turnId, targetMode: mapped.targetMode,
+                        sourceToolCallId: pending.sourceToolCallId }, "Failed to automatically approve the TraeX mode change.");
+                    this.emit({ type: "approval_requested", sessionId, turnId: mapped.turnId,
+                        request: { ...request, automatic: false, reason: ["自动同意失败，请手动确认。", request.reason].filter(Boolean).join("\n\n") } });
+                });
+            }
         }
         else if (mapped.kind === "mode_change_resolved") {
             const requestId = `mode:${mapped.threadId}:${mapped.requestId}`;
@@ -984,10 +1077,12 @@ export class CodexRuntime {
             if (!pending || pending.sessionId !== sessionId || pending.turnId !== mapped.turnId
                 || pending.targetMode !== mapped.targetMode)
                 return;
+            this.confirmPlanContinuation(pending, mapped.decision === "approved" ? "accept" : "decline");
             this.modeChanges.delete(requestId);
             this.emit({
                 type: "approval_resolved", sessionId, turnId: mapped.turnId, requestId,
                 decision: mapped.decision === "approved" ? "accept" : mapped.decision === "rejected" ? "decline" : "cancel",
+                ...(pending.automatic && mapped.decision === "approved" ? { automatic: true } : {}),
             });
         }
         else if (mapped.kind === "token_usage") {
@@ -1024,6 +1119,7 @@ export class CodexRuntime {
                 session.unphasedFinalMessageId = undefined;
         }
         else if (mapped.kind === "agent_delta") {
+            this.clearPlanContinuation(session, mapped.turnId);
             const phase = session.messagePhases.get(mapped.itemId);
             if (phase !== "final_answer") {
                 // Providers may omit phase. Keep their text in sequence until a tool or completion disambiguates it.
@@ -1081,6 +1177,9 @@ export class CodexRuntime {
             this.emit({ type: "plan_updated", sessionId, turnId: mapped.turnId, steps: mapped.steps });
         }
         else if (mapped.kind === "tool") {
+            // A backend that resumes tool execution itself needs no client handoff.
+            if (mapped.phase === "started")
+                this.clearPlanContinuation(session, mapped.turnId);
             if (mapped.phase === "started")
                 session.unphasedFinalMessageId = undefined;
             if (mapped.phase === "updated"
@@ -1208,6 +1307,9 @@ export class CodexRuntime {
             ...threadLifecycleParams(session.cwd),
             ...permissionParams(session.permissionMode),
         }, SESSION_REQUEST_TIMEOUT_MS);
+        if (response.thread.id !== session.remoteSessionId)
+            throw new Error("App Server 返回了不同的任务 ID，未恢复会话。");
+        assertProviderSettingsApplied(response, { modelProvider: session.modelProvider });
         session.workspaceSandboxPolicy = workspaceSandboxFromResponse(response.sandbox);
     }
     async turnSandboxPolicy(session, client) {
@@ -1276,7 +1378,6 @@ export class CodexRuntime {
         this.finishSnapshotTurn(session, latest);
     }
     adoptTurn(session, turnId, startedAt) {
-        session.canReplaceEmptyThread = false;
         if (!session.knownTurnIds.has(turnId)) {
             session.knownTurnIds.add(turnId);
             if (session.turnCount !== undefined)
@@ -1284,6 +1385,7 @@ export class CodexRuntime {
         }
         session.activeTurnId = turnId;
         session.activeTurnStartedAt = startedAt;
+        session.planContinuationTurnId = undefined;
         session.modeChangeRequestIds.clear();
         session.unphasedMessages.clear();
         session.unphasedFinalMessageId = undefined;
@@ -1373,7 +1475,6 @@ export class CodexRuntime {
             unphasedMessages: new Map(),
             needsResume: false,
             workspaceSandboxPolicy: workspaceSandboxFromResponse(response.sandbox),
-            canReplaceEmptyThread: !("remoteSessionId" in input),
             rolloutPath: stringValue(response.thread.path)?.trim() || undefined,
             turnCount: "remoteSessionId" in input ? undefined : 0,
             knownTurnIds: new Set(),
@@ -1403,11 +1504,39 @@ export class CodexRuntime {
             throw new Error(`App Server turn is no longer active: ${turnId}`);
         return session;
     }
+    clearPlanContinuation(session, turnId) {
+        session.planContinuationTurnId = undefined;
+        for (const pending of this.modeChanges.values()) {
+            if (pending.sessionId === session.localSessionId && pending.turnId === turnId && pending.responding) {
+                pending.continued = true;
+            }
+        }
+    }
+    confirmPlanContinuation(pending, decision) {
+        const session = this.sessions.get(pending.sessionId);
+        // Do not start work approved in a different client.
+        if (session && pending.responding && !pending.continued && pending.decision === "accept" && decision === "accept"
+            && pending.targetMode === "default")
+            session.planContinuationTurnId = pending.turnId;
+    }
     emit(event) {
         if (event.type === "turn_completed" || event.type === "turn_cancelled" || event.type === "turn_failed") {
             for (const [requestId, pending] of this.modeChanges) {
-                if (pending.sessionId === event.sessionId && pending.turnId === event.turnId)
-                    this.modeChanges.delete(requestId);
+                if (pending.sessionId !== event.sessionId || pending.turnId !== event.turnId)
+                    continue;
+                if (event.type === "turn_completed" && pending.responding && pending.decision === "accept"
+                    && pending.targetMode === "default") {
+                    // The terminal notification may beat the approval RPC response.
+                    pending.terminalEvent = event;
+                    return;
+                }
+                this.modeChanges.delete(requestId);
+            }
+            const session = this.sessions.get(event.sessionId);
+            if (session?.planContinuationTurnId === event.turnId) {
+                session.planContinuationTurnId = undefined;
+                if (event.type === "turn_completed")
+                    event = { ...event, approvedPlan: true };
             }
         }
         for (const listener of this.listeners)
@@ -1420,6 +1549,7 @@ export class CodexRuntime {
         this.modeChanges.clear();
         for (const session of this.sessions.values()) {
             session.needsResume = true;
+            session.planContinuationTurnId = undefined;
             const turnId = session.activeTurnId;
             if (!turnId)
                 continue;
@@ -1732,9 +1862,6 @@ function remoteThreadStatus(value) {
         return "error";
     return "not_loaded";
 }
-function providerSettingsMatch(response, settings) {
-    return response.modelProvider === settings.modelProvider && response.model === settings.model;
-}
 function codexSourceLabel(source) {
     if (typeof source === "string")
         return source;