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

package/src/codex/CodexRuntime.ts

@@ -1,9 +1,11 @@
 import { statSync } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
 import type { Logger } from "pino";
 import type {
   AgentRuntime,
   AgentProcessInfo,
   ApprovalDecision,
+  ApprovalRequest,
   CreateRuntimeSessionInput,
   ConversationTurn,
   ForkRuntimeSessionInput,
@@ -33,9 +35,10 @@ import { AppServerRequestError } from "./AppServerConnection.js";
 import { workspaceSandboxFromConfig, workspaceSandboxFromResponse, type TurnSandboxPolicy, type WorkspaceSandboxPolicy } 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, type ProviderModelConfig } from "./ProviderModels.js";
 
 const WINDOWS_SCREENSHOT_DEVELOPER_INSTRUCTIONS = [
@@ -84,6 +87,7 @@ interface CodexSession extends RuntimeSession {
   activeTurnStartedAt?: number;
   terminalTurnIds: Set<string>;
   modeChangeRequestIds: Set<string>;
+  planContinuationTurnId?: string;
   finalText: string;
   generatedImagePaths: string[];
   messagePhases: Map<string, "commentary" | "final_answer">;
@@ -91,7 +95,6 @@ interface CodexSession extends RuntimeSession {
   unphasedFinalMessageId?: string;
   needsResume: boolean;
   workspaceSandboxPolicy?: WorkspaceSandboxPolicy;
-  canReplaceEmptyThread: boolean;
   settingsRecoveryError?: string;
   rolloutPath?: string;
   turnCount?: number;
@@ -109,7 +112,12 @@ interface PendingModeChange {
   turnId: string;
   requestId: string;
   targetMode: "plan" | "default";
+  sourceToolCallId?: string;
   responding: boolean;
+  decision?: ApprovalDecision;
+  automatic?: boolean;
+  continued?: boolean;
+  terminalEvent?: Extract<RuntimeEvent, { type: "turn_completed" }>;
 }
 
 export class CodexRuntime implements AgentRuntime {
@@ -184,6 +192,20 @@ export class CodexRuntime implements AgentRuntime {
     return this.runSessionOperation(input.localSessionId, () => this.resumeSessionNow(input));
   }
 
+  async prepareSessionForSettings(input: ResumeRuntimeSessionInput): Promise<RuntimeSession> {
+    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;
+    });
+  }
+
   private async resumeSessionNow(input: ResumeRuntimeSessionInput): Promise<RuntimeSession> {
     const client = await this.client();
     const response = await client.request<ThreadResponse>("thread/resume", {
@@ -195,8 +217,16 @@ export class CodexRuntime implements AgentRuntime {
       ...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;
   }
@@ -243,13 +273,18 @@ export class CodexRuntime implements AgentRuntime {
     const session = this.requireSession(sessionId);
     const client = await this.client();
     await this.ensureSessionResumed(session, client);
-    session.canReplaceEmptyThread = false;
     const start = async () => client.request<{ turn: { id: string } }>("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),
@@ -591,9 +626,10 @@ export class CodexRuntime implements AgentRuntime {
       .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 } : {}),
@@ -627,6 +663,12 @@ export class CodexRuntime implements AgentRuntime {
   }
 
   async interruptRemoteTurn(remoteSessionId: string, turnId: string, sessionId?: string): Promise<void> {
+    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 },
@@ -645,17 +687,51 @@ export class CodexRuntime implements AgentRuntime {
     });
   }
 
-  async archiveRemoteSession(remoteSessionId: string): Promise<void> {
-    await (await this.client()).request(
-      "thread/archive",
-      { threadId: remoteSessionId },
-      CONTROL_REQUEST_TIMEOUT_MS,
-    );
+  async archiveRemoteSession(remoteSessionId: string, options: { allowUnmaterialized?: boolean } = {}): Promise<void> {
+    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<{ status: string }>(
+        "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);
     }
   }
 
+  private async isUnmaterializedThread(client: AppServerClient, remoteSessionId: string): Promise<boolean> {
+    const { thread } = await client.request<ThreadReadResponse>(
+      "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 as NodeJS.ErrnoException).code === "ENOENT") return true;
+      throw error;
+    }
+  }
+
   async setTitle(sessionId: string, title: string): Promise<void> {
     return this.runSessionOperation(sessionId, () => this.setTitleNow(sessionId, title));
   }
@@ -696,7 +772,6 @@ export class CodexRuntime implements AgentRuntime {
     const session = this.requireSession(sessionId);
     const client = await this.client();
     await this.ensureSessionResumed(session, client);
-    session.canReplaceEmptyThread = false;
     const response = await client.request<{ goal: RuntimeGoal }>(
       "thread/goal/set",
       { threadId: session.remoteSessionId, ...update },
@@ -738,7 +813,16 @@ export class CodexRuntime implements AgentRuntime {
     settings: RuntimeExecutionSettings,
     persist?: (session: RuntimeSession) => Promise<void>,
   ): Promise<RuntimeSession> {
-    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 });
+      }
+    });
   }
 
   private async setExecutionSettingsNow(
@@ -756,82 +840,54 @@ export class CodexRuntime implements AgentRuntime {
     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: string | undefined;
+    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: ThreadResponse;
-      if (empty) {
-        response = await client.request<ThreadResponse>("thread/start", {
-          ...params, threadSource: "user", allowProviderModelFallback: false,
-        }, SESSION_REQUEST_TIMEOUT_MS);
-        replacementId = response.thread.id;
-      } else {
-        response = await client.request<ThreadResponse>("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<ThreadResponse>("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<ThreadResponse>("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;
@@ -844,60 +900,42 @@ export class CodexRuntime implements AgentRuntime {
           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;
   }
 
-  private async detachThreadForSettings(client: AppServerClient, session: CodexSession): Promise<void> {
+  private async detachThreadForSettings(client: AppServerClient, session: CodexSession, onDetach?: () => void): Promise<void> {
     const current = await client.request<ThreadReadResponse>("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<{ status: string }>("thread/unsubscribe", {
       threadId: session.remoteSessionId,
     }, CONTROL_REQUEST_TIMEOUT_MS);
-    if (result.status !== "unsubscribed" && result.status !== "notLoaded") {
-      throw new Error("当前任务仍由其他客户端加载，无法安全切换 Provider。请先在原客户端释放任务。");
-    }
-  }
-
-  private async forkThreadForSettings(
-    client: AppServerClient,
-    session: CodexSession,
-    settings: RuntimeExecutionSettings,
-  ): Promise<ThreadResponse> {
-    const turns = await this.listRecentThreadTurnsThroughCompleted(client, session.remoteSessionId);
-    const lastTurnId = turns.find((turn) => turn.status === "completed")?.id;
-    if (!lastTurnId) {
-      throw new Error("无法为 Provider 切换找到已完成的 Turn。请先完成一轮任务后重试。");
+    if (!["unsubscribed", "notLoaded", "notSubscribed"].includes(result.status)) {
+      throw new Error(`App Server 返回了未知的取消订阅状态：${result.status}`);
     }
-    return client.request<ThreadResponse>("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);
   }
 
-  private async discardUnusedThread(client: AppServerClient, threadId: string): Promise<void> {
-    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.");
-    }
+  async respondToApproval(
+    sessionId: string,
+    requestId: string,
+    decision: ApprovalDecision,
+  ): Promise<void> {
+    return this.resolveApproval(sessionId, requestId, decision);
   }
 
-  async respondToApproval(
+  private async resolveApproval(
     sessionId: string,
     requestId: string,
     decision: ApprovalDecision,
+    automatic = false,
   ): Promise<void> {
     const modeChange = this.modeChanges.get(requestId);
     if (modeChange) {
@@ -910,20 +948,29 @@ export class CodexRuntime implements AgentRuntime {
       }
       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;
     }
@@ -934,6 +981,36 @@ export class CodexRuntime implements AgentRuntime {
     this.emit({ type: "approval_resolved", sessionId, turnId: pending.turnId, requestId, decision });
   }
 
+  private async reconcileCompletedPlanEntry(
+    requestId: string, pending: PendingModeChange, error: unknown,
+  ): Promise<boolean> {
+    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?: string, fallbackModel?: string): Promise<ModelOption[]> {
     return (await this.listModelsWithStatus(modelProvider, fallbackModel)).models;
   }
@@ -1174,34 +1251,47 @@ export class CodexRuntime implements AgentRuntime {
       const requestId = `mode:${mapped.threadId}:${mapped.requestId}`;
       if (session.modeChangeRequestIds.has(requestId)) return;
       session.modeChangeRequestIds.add(requestId);
-      this.modeChanges.set(requestId, {
+      const pending: PendingModeChange = {
         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: ApprovalRequest = {
+        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: unknown) => {
+          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}`;
       const pending = this.modeChanges.get(requestId);
       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") {
       this.emit({
@@ -1232,6 +1322,7 @@ export class CodexRuntime implements AgentRuntime {
       if (mapped.phase === "final_answer") this.promoteUnphasedMessage(session, mapped.turnId, mapped.itemId);
       else if (session.unphasedFinalMessageId === mapped.itemId) 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.
@@ -1283,6 +1374,8 @@ export class CodexRuntime implements AgentRuntime {
     } else if (mapped.kind === "plan") {
       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"
@@ -1409,6 +1502,8 @@ export class CodexRuntime implements AgentRuntime {
       ...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);
   }
 
@@ -1487,13 +1582,13 @@ export class CodexRuntime implements AgentRuntime {
   }
 
   private adoptTurn(session: CodexSession, turnId: string, startedAt: number): void {
-    session.canReplaceEmptyThread = false;
     if (!session.knownTurnIds.has(turnId)) {
       session.knownTurnIds.add(turnId);
       if (session.turnCount !== undefined) session.turnCount += 1;
     }
     session.activeTurnId = turnId;
     session.activeTurnStartedAt = startedAt;
+    session.planContinuationTurnId = undefined;
     session.modeChangeRequestIds.clear();
     session.unphasedMessages.clear();
     session.unphasedFinalMessageId = undefined;
@@ -1596,7 +1691,6 @@ export class CodexRuntime implements AgentRuntime {
       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(),
@@ -1626,10 +1720,38 @@ export class CodexRuntime implements AgentRuntime {
     return session;
   }
 
+  private clearPlanContinuation(session: CodexSession, turnId: string): void {
+    session.planContinuationTurnId = undefined;
+    for (const pending of this.modeChanges.values()) {
+      if (pending.sessionId === session.localSessionId && pending.turnId === turnId && pending.responding) {
+        pending.continued = true;
+      }
+    }
+  }
+
+  private confirmPlanContinuation(pending: PendingModeChange, decision: ApprovalDecision): void {
+    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;
+  }
+
   private emit(event: RuntimeEvent): void {
     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) listener(event);
@@ -1642,6 +1764,7 @@ export class CodexRuntime implements AgentRuntime {
     this.modeChanges.clear();
     for (const session of this.sessions.values()) {
       session.needsResume = true;
+      session.planContinuationTurnId = undefined;
       const turnId = session.activeTurnId;
       if (!turnId) continue;
       session.activeTurnId = undefined;
@@ -2037,13 +2160,6 @@ function remoteThreadStatus(value: string | undefined): RemoteSessionSummary["st
   return "not_loaded";
 }
 
-function providerSettingsMatch(
-  response: Pick<ThreadResponse, "modelProvider" | "model">,
-  settings: RuntimeExecutionSettings,
-): boolean {
-  return response.modelProvider === settings.modelProvider && response.model === settings.model;
-}
-
 function codexSourceLabel(source: unknown): string {
   if (typeof source === "string") return source;
   if (isRecord(source)) {