@keyou007/agent-bot 0.1.24-alpha.4 → 0.1.24-alpha.6

package/src/codex/CodexRuntime.ts

@@ -4,6 +4,7 @@ import type {
   AgentRuntime,
   AgentProcessInfo,
   ApprovalDecision,
+  ApprovalRequest,
   CreateRuntimeSessionInput,
   ConversationTurn,
   ForkRuntimeSessionInput,
@@ -30,11 +31,12 @@ import type {
 import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 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 { 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 = [
@@ -83,13 +85,14 @@ interface CodexSession extends RuntimeSession {
   activeTurnStartedAt?: number;
   terminalTurnIds: Set<string>;
   modeChangeRequestIds: Set<string>;
+  planContinuationTurnId?: string;
   finalText: string;
   generatedImagePaths: string[];
   messagePhases: Map<string, "commentary" | "final_answer">;
   unphasedMessages: Map<string, string>;
   unphasedFinalMessageId?: string;
   needsResume: boolean;
-  canReplaceEmptyThread: boolean;
+  workspaceSandboxPolicy?: WorkspaceSandboxPolicy;
   settingsRecoveryError?: string;
   rolloutPath?: string;
   turnCount?: number;
@@ -108,6 +111,10 @@ interface PendingModeChange {
   requestId: string;
   targetMode: "plan" | "default";
   responding: boolean;
+  decision?: ApprovalDecision;
+  automatic?: boolean;
+  continued?: boolean;
+  terminalEvent?: Extract<RuntimeEvent, { type: "turn_completed" }>;
 }
 
 export class CodexRuntime implements AgentRuntime {
@@ -138,6 +145,10 @@ export class CodexRuntime implements AgentRuntime {
     return this.sessions.get(localSessionId);
   }
 
+  forgetSession(localSessionId: string): void {
+    this.sessions.delete(localSessionId);
+  }
+
   getProcessInfo(): AgentProcessInfo {
     return this.provider.getProcessInfo?.() ?? {};
   }
@@ -178,6 +189,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", {
@@ -189,8 +214,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;
   }
@@ -237,15 +270,21 @@ 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 = () => client.request<{ turn: { id: string } }>("turn/start", {
+    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),
     }, SESSION_REQUEST_TIMEOUT_MS);
     let response: { turn: { id: string } };
     try {
@@ -294,7 +333,9 @@ export class CodexRuntime implements AgentRuntime {
         return listed;
       }
     }));
-    const activeThreads = await this.localActivityDetector?.activeThreads(sessions.map((session) => session.id));
+    const activeThreads = await this.localActivityDetector?.activeThreads(
+      sessions.filter((session) => session.status === "not_loaded").map((session) => session.id),
+    );
     return {
       sessions: activeThreads
         ? sessions.map((session) => markLocallyDetectedActive(session, activeThreads))
@@ -499,7 +540,8 @@ export class CodexRuntime implements AgentRuntime {
     remoteSessionId: string,
     summary: RemoteSessionSummary,
   ): Promise<RemoteSessionSummary> {
-    const activeThreads = await this.localActivityDetector?.activeThreads([remoteSessionId]);
+    const activeThreads = summary.status === "not_loaded"
+      ? await this.localActivityDetector?.activeThreads([remoteSessionId]) : undefined;
     const activeSummary = activeThreads ? markLocallyDetectedActive(summary, activeThreads) : summary;
     const settings = await this.localActivityDetector?.threadSettings([remoteSessionId]);
     return {
@@ -571,24 +613,23 @@ export class CodexRuntime implements AgentRuntime {
   }
 
   async inspectRemoteSessionActivity(remoteSessionId: string): Promise<RemoteSessionActivity> {
-    const [response, activeThreads] = await Promise.all([
-      (await this.client()).request<ThreadReadResponse>(
-        "thread/read",
-        { threadId: remoteSessionId, includeTurns: false },
-        SYNC_REQUEST_TIMEOUT_MS,
-      ),
-      this.localActivityDetector?.activeThreads([remoteSessionId]),
-    ]);
+    const response = await (await this.client()).request<ThreadReadResponse>(
+      "thread/read", { threadId: remoteSessionId, includeTurns: false }, SYNC_REQUEST_TIMEOUT_MS,
+    );
+    const status = remoteThreadStatus(response.thread.status?.type);
+    const activeThreads = status === "not_loaded"
+      ? await this.localActivityDetector?.activeThreads([remoteSessionId]) : undefined;
     const runtimeSession = [...this.sessions.values()]
       .find((session) => session.remoteSessionId === remoteSessionId);
     const detectedTurnId = activeThreads?.get(remoteSessionId);
-    const active = remoteThreadStatus(response.thread.status?.type) === "active"
-      || Boolean(runtimeSession?.activeTurnId)
-      || Boolean(activeThreads?.has(remoteSessionId));
-    const activeTurnId = detectedTurnId ?? runtimeSession?.activeTurnId;
+    // 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(observedTurnId);
+    const activeTurnId = detectedTurnId ?? observedTurnId;
     return {
       active,
-      ...(activeTurnId ? { activeTurnId } : {}),
+      ...(active && activeTurnId ? { activeTurnId } : {}),
     };
   }
 
@@ -619,6 +660,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 },
@@ -637,17 +684,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));
   }
@@ -688,7 +769,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 },
@@ -730,7 +810,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(
@@ -748,84 +837,58 @@ 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;
+          session.workspaceSandboxPolicy = workspaceSandboxFromResponse(restored.sandbox);
           session.settingsRecoveryError = undefined;
         } catch (restoreError) {
           this.logger.warn({ error: restoreError, sessionId }, "Failed to restore Provider after a rejected settings change.");
@@ -834,60 +897,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。请先在原客户端释放任务。");
+    if (!["unsubscribed", "notLoaded", "notSubscribed"].includes(result.status)) {
+      throw new Error(`App Server 返回了未知的取消订阅状态：${result.status}`);
     }
   }
 
-  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。请先完成一轮任务后重试。");
-    }
-    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) {
@@ -900,6 +945,8 @@ 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.");
@@ -909,11 +956,14 @@ export class CodexRuntime implements AgentRuntime {
           decision: decision === "accept" ? "approved" : decision === "decline" ? "rejected" : "cancelled",
         }, CONTROL_REQUEST_TIMEOUT_MS);
         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;
     }
@@ -1164,34 +1214,45 @@ 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" },
-          ],
-        },
-      });
+      };
+      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) => {
+          this.logger.warn({ error, sessionId, requestId }, "Failed to automatically approve the TraeX mode change.");
+          if (this.modeChanges.get(requestId) !== pending || session.activeTurnId !== mapped.turnId) return;
+          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({
@@ -1222,6 +1283,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.
@@ -1273,6 +1335,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"
@@ -1390,7 +1454,7 @@ export class CodexRuntime implements AgentRuntime {
   }
 
   private async resumeAppServerSession(session: CodexSession, client: AppServerClient): Promise<void> {
-    await client.request("thread/resume", {
+    const response = await client.request<ThreadResponse>("thread/resume", {
       threadId: session.remoteSessionId,
       excludeTurns: true,
       cwd: session.cwd,
@@ -1399,6 +1463,21 @@ 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);
+  }
+
+  private async turnSandboxPolicy(session: CodexSession, client: AppServerClient): Promise<TurnSandboxPolicy> {
+    if (session.permissionMode === "auto") return { type: "dangerFullAccess" };
+    if (!session.workspaceSandboxPolicy) {
+      // Resolve project-specific options once, without resuming or scanning history.
+      const response = await client.request<{ config?: unknown }>("config/read", {
+        cwd: session.cwd, includeLayers: false,
+      }, CONTROL_REQUEST_TIMEOUT_MS);
+      session.workspaceSandboxPolicy = workspaceSandboxFromConfig(response.config);
+    }
+    return session.workspaceSandboxPolicy;
   }
 
   private async synchronizeSessionNow(sessionId: string): Promise<RuntimeSession> {
@@ -1435,7 +1514,9 @@ export class CodexRuntime implements AgentRuntime {
     }
     if (latestInProgress) {
       this.supersedeTurn(session, activeTurnId);
-      this.adoptTurn(session, latestInProgress.id, turnStartedAt(latestInProgress));
+      if (thread.status?.type === "active") {
+        this.adoptTurn(session, latestInProgress.id, turnStartedAt(latestInProgress));
+      }
       return;
     }
 
@@ -1462,13 +1543,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;
@@ -1570,7 +1651,7 @@ export class CodexRuntime implements AgentRuntime {
       messagePhases: new Map(),
       unphasedMessages: new Map(),
       needsResume: false,
-      canReplaceEmptyThread: !("remoteSessionId" in input),
+      workspaceSandboxPolicy: workspaceSandboxFromResponse(response.sandbox),
       rolloutPath: stringValue(response.thread.path)?.trim() || undefined,
       turnCount: "remoteSessionId" in input ? undefined : 0,
       knownTurnIds: new Set(),
@@ -1600,10 +1681,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);
@@ -1616,6 +1725,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;
@@ -1642,6 +1752,7 @@ interface ThreadResponse {
   modelProvider?: string;
   model?: string;
   reasoningEffort?: string | null;
+  sandbox?: unknown;
 }
 
 interface ThreadReadResponse {
@@ -2010,13 +2121,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)) {