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

package/src/proxy/ProxySessionController.ts

@@ -5,7 +5,7 @@ import path from "node:path";
 import type { Logger } from "pino";
 import { createProjectlessWorkspace, detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
 import { CodexVersionError } from "../codex/CodexVersion.js";
-import { assertProviderSettingsApplied, isMissingRolloutError } from "../codex/ProviderSwitch.js";
+import { assertProviderSettingsApplied, ProviderSwitchError } from "../codex/ProviderSwitch.js";
 import {
   SystemThreadWriterProcessController,
   type ThreadWriterProcess,
@@ -90,11 +90,13 @@ import {
   type MessageReactionRecord,
   type MessageReactionStatus,
   type QueuedPromptRecord,
+  type PendingProviderSettings,
   type SessionRecord,
   type TurnAttemptRecord,
   type TurnAnchorRecord,
   type TurnRuntimeOriginRecord,
 } from "../state/StateStore.js";
+import { SessionOperationQueue } from "./SessionOperationQueue.js";
 import { createId } from "../utils/id.js";
 import { formatStorageSize } from "../utils/formatStorageSize.js";
 import { truncateMiddle, truncateText } from "../utils/markdown.js";
@@ -117,10 +119,12 @@ interface StartTurnOptions {
   messageId?: string;
   displayPrompt?: string;
   preserveAttemptOnFailure?: boolean;
+  approvedPlanTurnId?: string;
 }
 
 interface PendingForwardAttachment {
   contextKey: string;
+  userId?: string;
   attachmentMessageId?: string;
   attachmentPromise: Promise<IncomingMessage | undefined>;
   resolveAttachment: (message: IncomingMessage | undefined) => void;
@@ -193,11 +197,12 @@ const REMOTE_TURN_HISTORY_REFRESH_INTERVAL_MS = 30_000;
 const MAX_LLM_TURN_RETRIES = 3;
 const QUEUED_PROMPT_RETRY_DELAY_MS = 5_000;
 const RECOVERY_ACTIVITY_WINDOW_MS = 10 * 60 * 1_000;
+const RECOVERY_RETRY_WINDOW_MS = 60_000;
 const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
 const SHELL_COMMAND_JOB_POLL_INTERVAL_MS = 1_000;
 const SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS = 5_000;
 const APP_SERVER_RELEASE_POLL_INTERVAL_MS = 500;
-const FORWARD_ATTACHMENT_WINDOW_MS = 800;
+const FORWARD_ATTACHMENT_WINDOW_MS = 1_500;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
 const TURN_STOP_REQUESTED_MESSAGE = "已发送停止信号，任务会自动停止。";
@@ -383,7 +388,6 @@ interface AgentRemoteSessionSummary {
 
 interface SessionsCardOptions {
   updateMessageId?: string;
-  forceSwitchTaskId?: string;
   page?: number;
 }
 
@@ -406,6 +410,8 @@ interface ResetHistoryCardOptions {
 }
 
 interface ModelCardOptions {
+  modelPage?: number;
+  expectedProvider?: string;
   sessionId?: string;
   updateMessageId?: string;
 }
@@ -416,6 +422,7 @@ interface ThinkingCardOptions extends ModelCardOptions {
 
 interface ExecutionSettingsCardOptions extends ModelCardOptions {
   notice?: string;
+  warning?: string;
 }
 
 type SessionExecutionSettings = AgentExecutionDefaults;
@@ -506,6 +513,8 @@ export interface ControlTaskReleaseResult {
 }
 
 export interface ProxyLifecycle {
+  terminalUrl?(jobId: string): string | undefined;
+  authorizeTerminal?(action: CardAction): Promise<string>;
   supervised?: boolean;
   restart(contextKey: string, force: boolean, replyTarget?: MessageReplyTarget): Promise<void>;
   cancelSafeRestart?(scheduleId: number): Promise<boolean>;
@@ -539,9 +548,14 @@ export class ProxySessionController {
   private readonly messageQueues = new Map<string, Promise<void>>();
   private readonly switchGroupOperations = new Set<string>();
   private readonly sessionLoads = new Map<string, Promise<LoadedSession>>();
+  private readonly settingsOnlySessions = new Set<string>();
   private readonly queuedPromptStarts = new Map<string, Promise<void>>();
   private readonly queuedPromptCards = new Map<string, Map<string, string>>();
   private readonly queuedPromptCardWrites = new Map<string, Promise<void>>();
+  private readonly settingsOperations = new SessionOperationQueue();
+  // Loads may run inside settingsOperations; never acquire that queue while hydrating.
+  private readonly sessionHydrationOperations = new SessionOperationQueue();
+  private readonly agentDefaultsOperations = new SessionOperationQueue();
   private readonly sessionResets = new Map<string, Promise<void>>();
   private readonly resetHistoryOperations = new Map<string, string>();
   private readonly remoteTurnHistoryRefreshes = new Map<string, number>();
@@ -551,9 +565,13 @@ export class ProxySessionController {
   private readonly lastSessionListings = new Map<string, string[]>();
   private readonly threadInitializations = new Map<string, Promise<void>>();
   private readonly llmRetryingSessions = new Set<string>();
+  private readonly planHandoffs = new Map<string, string>();
   private readonly retriedFailureTurnIds = new Set<string>();
   private readonly queuedPromptRetryTimers = new Map<string, NodeJS.Timeout>();
   private readonly recoveryRetryTimers = new Map<string, NodeJS.Timeout>();
+  private readonly recoveryRetryStartedAt = new Map<string, number>();
+  private readonly recoveredLiveAttempts = new Set<string>();
+  private recoveryClosed = false;
   private readonly pendingMergedForwards = new Map<string, PendingForwardAttachment>();
   private readonly pendingResourceForwards = new Map<string, PendingForwardAttachment>();
   private readonly relatedReactionMessageIds = new Map<string, string[]>();
@@ -630,7 +648,7 @@ export class ProxySessionController {
     const pendingMergedForward = message.mergedForwardMessageId
       ? this.registerPendingForwardAttachment(message, this.pendingMergedForwards)
       : undefined;
-    const pendingResourceForward = !attachmentReservation && isStandaloneResourceMessage(message)
+    const pendingResourceForward = !attachmentReservation && isForwardAttachmentSource(message)
       ? this.registerPendingForwardAttachment(message, this.pendingResourceForwards)
       : undefined;
     try {
@@ -680,7 +698,9 @@ export class ProxySessionController {
       );
       if (attachment) {
         coalescedForwardAttachment = true;
-        const instruction = normalizeFeishuPostText(attachment.text) || defaultResourcePrompt(resourceMessage);
+        const sourceText = resourceMessage.text.trim();
+        const instruction = normalizeFeishuPostText(attachment.text)
+          || (sourceText ? DEFAULT_REFERENCED_MESSAGE_INSTRUCTION : defaultResourcePrompt(resourceMessage));
         forwardedImages = (resourceMessage.images ?? []).map((image) => ({
           messageId: resourceMessage.messageId,
           imageKey: image.imageKey,
@@ -692,7 +712,7 @@ export class ProxySessionController {
         }));
         message = {
           ...attachment,
-          text: instruction,
+          text: sourceText ? referencedMessagePrompt(instruction, sourceText) : instruction,
           displayText: instruction,
         };
         this.relatedReactionMessageIds.set(message.messageId, [resourceMessage.messageId]);
@@ -1012,7 +1032,10 @@ export class ProxySessionController {
     await this.outbound.withReplyTarget(contextKey, replyTarget, async () => {
       try {
         const kind = String(scopedAction.value.action ?? "");
-        if (kind === "agentbot_update_cancel") {
+        if (kind === "terminal_authorize") {
+          if (!this.lifecycle?.authorizeTerminal) throw new Error("网页终端未启用。");
+          await this.outbound.sendText(contextKey, await this.lifecycle.authorizeTerminal(scopedAction));
+        } else if (kind === "agentbot_update_cancel") {
           if (!this.lifecycle?.cancelAutomaticUpdate) throw new Error("自动更新功能未启用。");
           await this.lifecycle.cancelAutomaticUpdate(scopedAction);
         } else if (kind === "agentbot_update_select") {
@@ -1208,7 +1231,7 @@ export class ProxySessionController {
           await this.stopSessionReference(contextKey, sessionId);
           if (scopedAction.value.cardView === "status") await this.refreshStatusCardFromAction(scopedAction, sessionId);
           else if (scopedAction.value.cardView !== "safe_restart") {
-            await this.refreshSessionsCardFromAction(scopedAction, { forceSwitchTaskId: sessionId });
+            await this.refreshSessionsCardFromAction(scopedAction);
           }
         } else if (kind === "session_turns" || kind === "session_turns_page") {
           const sessionReference = String(scopedAction.value.sessionId ?? "").trim();
@@ -1228,10 +1251,14 @@ export class ProxySessionController {
         } else if (kind === "session_status_refresh") {
           await this.refreshStatusCardFromAction(scopedAction);
         } else if (kind === "settings_tab_open") {
-          await this.openExecutionSettings(contextKey, executionSettingsTabValue(scopedAction.value.tab), {
-            sessionId: String(scopedAction.value.sessionId ?? ""),
-            updateMessageId: scopedAction.messageId,
-          });
+          const sessionId = String(scopedAction.value.sessionId ?? "");
+          await this.openExecutionSettings(
+            contextKey, executionSettingsTabValue(scopedAction.value.tab), {
+              sessionId, updateMessageId: scopedAction.messageId,
+              modelPage: modelCardPageValue(scopedAction.value.page),
+              expectedProvider: typeof scopedAction.value.provider === "string" ? scopedAction.value.provider : undefined,
+            },
+          );
         } else if (kind === "settings_agent_select") {
           await this.setDefaultAgent(contextKey, String(scopedAction.value.agent ?? ""), {
             sessionId: String(scopedAction.value.sessionId ?? ""),
@@ -1244,11 +1271,13 @@ export class ProxySessionController {
           });
         } else if (kind === "settings_model_select") {
           await this.model(contextKey, String(scopedAction.value.model ?? ""), {
+            expectedProvider: String(scopedAction.value.provider ?? ""),
             sessionId: String(scopedAction.value.sessionId ?? ""),
             updateMessageId: scopedAction.messageId,
           });
         } else if (kind === "settings_thinking_select") {
           await this.thinking(contextKey, String(scopedAction.value.effort ?? ""), {
+            expectedProvider: String(scopedAction.value.provider ?? ""),
             sessionId: String(scopedAction.value.sessionId ?? ""),
             updateMessageId: scopedAction.messageId,
             expectedModel: String(scopedAction.value.model ?? ""),
@@ -1270,6 +1299,7 @@ export class ProxySessionController {
           await this.model(contextKey, undefined, {
             sessionId,
             updateMessageId: scopedAction.messageId,
+            modelPage: modelCardPageValue(scopedAction.value.page),
           });
         } else if (kind === "reasoning_select") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
@@ -1292,6 +1322,7 @@ export class ProxySessionController {
             permissionModeValue(scopedAction.value.permissionMode),
             String(scopedAction.value.sessionId ?? ""),
             requiredCardMessageId(scopedAction.messageId),
+            modelCardPageValue(scopedAction.value.page),
           );
         } else if (kind === "provider_model_select" || kind === "provider_reasoning_open") {
           await this.openProviderReasoningSelector(
@@ -1353,12 +1384,14 @@ export class ProxySessionController {
   }
 
   close(): void {
+    this.recoveryClosed = true;
     for (const unsubscribe of this.unsubscribe) unsubscribe();
     this.unsubscribe.length = 0;
     this.lastSessionListings.clear();
     this.queuedPromptCards.clear();
     this.queuedPromptCardWrites.clear();
     this.sessionResets.clear();
+    this.planHandoffs.clear();
     this.resetHistoryOperations.clear();
     this.remoteTurnHistoryRefreshes.clear();
     this.forkHistoryCursors.clear();
@@ -1372,6 +1405,8 @@ export class ProxySessionController {
     this.queuedPromptRetryTimers.clear();
     for (const timer of this.recoveryRetryTimers.values()) clearTimeout(timer);
     this.recoveryRetryTimers.clear();
+    this.recoveryRetryStartedAt.clear();
+    this.recoveredLiveAttempts.clear();
     for (const schedule of this.appServerReleaseSchedules.values()) {
       if (schedule.timer) clearTimeout(schedule.timer);
     }
@@ -1760,79 +1795,44 @@ export class ProxySessionController {
     models: Awaited<ReturnType<AgentRuntime["listModels"]>>;
     reasoningOptions: Awaited<ReturnType<AgentRuntime["listModels"]>>[number]["supportedReasoningEfforts"];
     permissionModes: PermissionMode[];
+    pendingProvider?: PendingProviderSettings;
   }> {
     const record = this.requireControlSession(localSessionId);
     if (setting && !value?.trim()) throw new Error(`task ${setting} requires a value.`);
     const nextValue = value?.trim();
-    if (setting === "provider" && nextValue) {
+    if (setting && nextValue) {
       const contextKey = this.controlSessionContextKey(record);
-      await this.outbound.withReplyTarget(
-        contextKey,
-        this.controlSessionReplyTarget(record),
-        () => this.outbound.sendText(contextKey, `正在切换到 Provider ${nextValue}，请稍后。`),
-      );
-    }
-    const loaded = await this.loadSession(record);
-    if (setting === "provider" && nextValue) {
-      await this.assertModelProvider(loaded, nextValue);
-      const models = await loaded.runtime.listModels(nextValue, loaded.session.model);
-      const model = selectProviderModel(models, loaded.session.model);
-      if (!model) throw new Error("The current runtime has no model available for a Provider change.");
-      const effort = selectProviderReasoningEffort(model, loaded.session.reasoningEffort);
-      await this.changeProviderSettings(loaded, {
-        modelProvider: nextValue,
-        model: model.id,
-        reasoningEffort: effort,
-        permissionMode: loaded.session.permissionMode,
+      await this.outbound.withReplyTarget(contextKey, this.controlSessionReplyTarget(record), async () => {
+        const options = { sessionId: record.localSessionId };
+        if (setting === "provider") await this.selectProvider(contextKey, nextValue, options);
+        else if (setting === "model") await this.model(contextKey, nextValue, options);
+        else if (setting === "thinking") await this.thinking(contextKey, nextValue, options);
+        else {
+          if (nextValue !== "auto" && nextValue !== "confirm") throw new Error("task permissions accepts auto or confirm.");
+          await this.permissions(contextKey, nextValue, options);
+        }
       });
-    } else if (setting === "model" && nextValue) {
-      const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
-      const selected = models.find((candidate) => candidate.id === nextValue);
-      if (!selected) throw new Error(`Unknown model: ${nextValue}`);
-      const currentEffort = loaded.session.reasoningEffort;
-      const nextEffort = currentEffort && (selected.supportedReasoningEfforts.length === 0
-        || selected.supportedReasoningEfforts.some((candidate) => candidate.value === currentEffort))
-        ? currentEffort
-        : selected.defaultReasoningEffort;
-      await loaded.runtime.setModel(record.localSessionId, nextValue);
-      if (nextEffort && nextEffort !== currentEffort) {
-        await loaded.runtime.setReasoningEffort(record.localSessionId, nextEffort);
-      }
-      this.store.updateRuntimeSession(record.localSessionId, { model: nextValue, reasoningEffort: nextEffort });
-      this.outbound.updateSessionModel(record.localSessionId, nextValue, loaded.session.modelProvider);
-    } else if (setting === "thinking" && nextValue) {
-      const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
-      const currentModel = models.find((candidate) => candidate.id === loaded.session.model)
+    }
+    return this.settingsOperations.run(localSessionId, async () => {
+      const loaded = await this.loadSession(this.store.getSession(localSessionId) ?? record, true);
+      const session = this.store.getSession(record.localSessionId) ?? record;
+      const pending = this.store.getPendingProviderSettings(record.localSessionId);
+      const selected = pending?.settings ?? session;
+      const models = await loaded.runtime.listModels(selected.modelProvider, selected.model);
+      const currentModel = models.find((candidate) => candidate.id === selected.model)
         ?? models.find((candidate) => candidate.isDefault);
-      if (!currentModel) throw new Error("The current runtime has no model with configurable reasoning effort.");
-      if (!currentModel.supportedReasoningEfforts.some((candidate) => candidate.value === nextValue)) {
-        const supported = currentModel.supportedReasoningEfforts.map((candidate) => candidate.value).join(", ") || "none";
-        throw new Error(`Unsupported reasoning effort: ${nextValue}. Supported values: ${supported}.`);
-      }
-      await loaded.runtime.setReasoningEffort(record.localSessionId, nextValue);
-      this.store.updateRuntimeSession(record.localSessionId, { reasoningEffort: nextValue });
-    } else if (setting === "permissions" && nextValue) {
-      if (nextValue !== "auto" && nextValue !== "confirm") {
-        throw new Error("task permissions accepts auto or confirm.");
-      }
-      await loaded.runtime.setPermissionMode(record.localSessionId, nextValue);
-      this.store.updateRuntimeSession(record.localSessionId, { permissionMode: nextValue });
-    }
-    const session = this.store.getSession(record.localSessionId) ?? record;
-    if (setting && setting !== "provider") await this.persistAgentExecutionDefaults(session.localSessionId);
-    const models = await loaded.runtime.listModels(session.modelProvider, session.model);
-    const currentModel = models.find((candidate) => candidate.id === session.model)
-      ?? models.find((candidate) => candidate.isDefault);
-    const providers = loaded.runtime.listModelProviders
-      ? await this.modelProviderOptions(loaded)
-      : [];
-    return {
-      session,
-      providers,
-      models,
-      reasoningOptions: currentModel?.supportedReasoningEfforts ?? [],
-      permissionModes: ["auto", "confirm"],
-    };
+      const providers = loaded.runtime.listModelProviders
+        ? await this.modelProviderOptions(loaded)
+        : [];
+      return {
+        session,
+        pendingProvider: pending,
+        providers,
+        models,
+        reasoningOptions: currentModel?.supportedReasoningEfforts ?? [],
+        permissionModes: ["auto", "confirm"],
+      };
+    });
   }
 
   async controlTaskGoal(
@@ -2294,16 +2294,18 @@ export class ProxySessionController {
         continue;
       }
       if (!this.outbound.canRoute(attempt.contextKey)) continue;
+      this.recoveryRetryStartedAt.set(attempt.attemptId, Date.now());
       try {
         await this.recoverTurnAttempt(attempt);
       } catch (error) {
-        this.logger.error(
-          { error, attemptId: attempt.attemptId, sessionId: attempt.localSessionId },
-          "Failed to recover an unfinished task; it will be retried while the server is running.",
-        );
-        this.scheduleRecoveryRetry(attempt.attemptId);
+        await this.handleRecoveryError(attempt.attemptId, error);
+      } finally {
+        if (!this.recoveryRetryTimers.has(attempt.attemptId)) this.recoveryRetryStartedAt.delete(attempt.attemptId);
       }
     }
+    for (const pending of this.store.listPendingProviderSettings()) {
+      await this.applyPendingProviderWhenIdle(pending.localSessionId);
+    }
     this.restorePersistedQueuedPrompts();
   }
 
@@ -2394,15 +2396,23 @@ export class ProxySessionController {
     }
   }
 
-  private async expireStaleTurnAttempt(attempt: TurnAttemptRecord): Promise<void> {
-    const session = this.store.getSession(attempt.localSessionId);
+  private async expireStaleTurnAttempt(
+    attempt: TurnAttemptRecord,
+    message = "执行中断已超过 10 分钟，未自动恢复。",
+  ): Promise<void> {
+    clearTimeout(this.recoveryRetryTimers.get(attempt.attemptId));
+    this.recoveryRetryTimers.delete(attempt.attemptId);
+    this.recoveryRetryStartedAt.delete(attempt.attemptId);
+    this.recoveredLiveAttempts.delete(attempt.attemptId);
+    let session = this.store.getSession(attempt.localSessionId);
+    this.store.updateTurnAttempt(attempt.attemptId, { status: "interrupted" });
     const oldCardTurnId = attempt.pendingTurnId ?? attempt.turnId;
     if (session && oldCardTurnId && this.outbound.canRoute(attempt.contextKey)) {
       await this.outbound.interruptTurnForRecovery(
         session.localSessionId,
         attempt.contextKey,
         oldCardTurnId,
-        "执行中断已超过 10 分钟，未自动恢复。",
+        message,
       ).catch((error: unknown) => {
         this.logger.warn(
           { error, attemptId: attempt.attemptId, turnId: oldCardTurnId },
@@ -2410,13 +2420,21 @@ export class ProxySessionController {
         );
       });
     }
-    this.store.updateTurnAttempt(attempt.attemptId, { status: "interrupted" });
+    session = this.store.getSession(attempt.localSessionId);
     if (!session || session.status === "closed") return;
-    if (attempt.turnId && session.lastTurnId === attempt.turnId) {
+    const runtime = this.runtimes.forAgent(session.agentName);
+    const activeTurnId = runtime.getSession(session.localSessionId)?.activeTurnId;
+    const sameTurn = session.lastTurnId === attempt.turnId
+      || session.lastTurnId === attempt.recoveredFromTurnId
+      || !session.lastTurnId;
+    if (sameTurn && session.lastTurnStatus !== "completed" && session.lastTurnStatus !== "failed"
+      && (!activeTurnId || activeTurnId === attempt.turnId)) {
+      // Forget monitoring, not the remote task. Never cancel an unknown writer.
+      if (activeTurnId) runtime.forgetSession?.(session.localSessionId);
       this.store.updateRuntimeSession(session.localSessionId, { lastTurnStatus: "cancelled" });
-    }
-    if (session.status === "starting" || session.status === "running") {
-      this.store.updateSession(session.localSessionId, { status: "ready" });
+      if (session.status === "starting" || session.status === "running") {
+        this.store.updateSession(session.localSessionId, { status: "ready" });
+      }
     }
     if (attempt.turnId && this.outbound.canRoute(attempt.contextKey)) {
       await this.finalizeTurnMessageReactions(attempt.turnId, "cancelled").catch((error: unknown) => {
@@ -2428,6 +2446,44 @@ export class ProxySessionController {
     }
   }
 
+  private async handleRecoveryError(attemptId: string, error: unknown, activeTurnId?: string): Promise<void> {
+    if (this.recoveryClosed) return;
+    const attempt = this.store.getTurnAttempt(attemptId);
+    if (!attempt || !isIncompleteTurnAttemptStatus(attempt.status)) return;
+    this.logger.warn({ error, attemptId, sessionId: attempt.localSessionId }, "Task recovery failed.");
+    const session = this.store.getSession(attempt.localSessionId);
+    const writerConflict = session?.remoteSessionId === activeWriterThreadId(error) && Boolean(session?.remoteSessionId);
+    const startedAt = this.recoveryRetryStartedAt.get(attemptId) ?? Date.now();
+    this.recoveryRetryStartedAt.set(attemptId, startedAt);
+    const localActiveTurnId = session ? this.runtimes.forAgent(session.agentName).getSession(session.localSessionId)?.activeTurnId : undefined;
+    const monitoredTurnId = activeTurnId ?? (localActiveTurnId === attempt.turnId ? localActiveTurnId : undefined);
+    // Once a live turn was confirmed, a monitoring outage must not make safe restart
+    // consider it idle. Keep reconciling without cancelling or replaying the prompt.
+    if (monitoredTurnId && this.recoveredLiveAttempts.has(attemptId) && !writerConflict) {
+      this.scheduleRecoveryRetry(attemptId, monitoredTurnId);
+      return;
+    }
+    if (writerConflict || error instanceof CodexVersionError || Date.now() - startedAt >= RECOVERY_RETRY_WINDOW_MS) {
+      const message = writerConflict
+        ? "自动恢复未完成：任务仍被另一个 App Server 占用。已停止自动重试，请确认占用进程后释放任务再继续。"
+        : `自动恢复未完成，已停止自动重试。请检查 Agent 状态后重新发送消息。\n${error instanceof Error ? error.message : String(error)}`;
+      await this.expireStaleTurnAttempt(attempt, message);
+      try {
+        const replyTarget = attempt.replyMessageId
+          ? { messageId: attempt.replyMessageId, replyInThread: true as const } : undefined;
+        await this.outbound.withReplyTarget(attempt.contextKey, replyTarget, async () => {
+          await this.outbound.sendText(attempt.contextKey, message);
+          if (writerConflict && session) await this.presentThreadWriterConflict(session, attempt.contextKey, error, false);
+        });
+      } catch (notificationError) {
+        this.logger.warn({ error: notificationError, attemptId }, "Failed to notify about stopped task recovery.");
+      }
+      return;
+    }
+    this.store.updateTurnAttempt(attemptId, { status: "recovering" });
+    this.scheduleRecoveryRetry(attemptId, monitoredTurnId);
+  }
+
   private persistActiveTurnHeartbeats(): void {
     for (const attempt of this.store.listIncompleteTurnAttempts()) {
       if (!attempt.turnId) continue;
@@ -2439,6 +2495,7 @@ export class ProxySessionController {
   }
 
   private async recoverTurnAttempt(attempt: TurnAttemptRecord, announce = true): Promise<void> {
+    if (this.recoveryClosed) return;
     const session = this.store.getSession(attempt.localSessionId);
     if (!session || session.status === "closed") {
       this.store.updateTurnAttempt(attempt.attemptId, { status: "interrupted" });
@@ -2481,11 +2538,8 @@ export class ProxySessionController {
       try {
         remote = await runtime.readRemoteSession(session.remoteSessionId);
       } catch (error) {
-        if (error instanceof CodexVersionError) throw error;
-        this.logger.warn(
-          { error, attemptId: attempt.attemptId, remoteSessionId: session.remoteSessionId },
-          "Failed to read the remote task during startup recovery; treating the old local execution as interrupted.",
-        );
+        // A failed activity check is not proof of interruption. Do not replay a prompt blindly.
+        if (sourceTurnId || !isUnmaterializedCodexThreadError(error)) throw error;
       }
     }
     const remoteTurnBelongsToAttempt = remoteTurnMatchesAttempt(remote, attempt);
@@ -2538,12 +2592,20 @@ export class ProxySessionController {
   }
 
   private scheduleRecoveryRetry(attemptId: string, activeTurnId?: string): void {
-    if (this.recoveryRetryTimers.has(attemptId)) return;
+    if (this.recoveryClosed || this.recoveryRetryTimers.has(attemptId)) return;
+    if (!this.recoveryRetryStartedAt.has(attemptId)) this.recoveryRetryStartedAt.set(attemptId, Date.now());
     const timer = setTimeout(() => {
       this.recoveryRetryTimers.delete(attemptId);
       const attempt = this.store.getTurnAttempt(attemptId);
-      if (!attempt || !isIncompleteTurnAttemptStatus(attempt.status)) return;
+      if (!attempt || !isIncompleteTurnAttemptStatus(attempt.status)) {
+        this.recoveryRetryStartedAt.delete(attemptId);
+        this.recoveredLiveAttempts.delete(attemptId);
+        return;
+      }
       const retry = async (): Promise<void> => {
+        if (!activeTurnId && Date.now() - this.recoveryRetryStartedAt.get(attemptId)! >= RECOVERY_RETRY_WINDOW_MS) {
+          throw new Error("等待恢复超过 1 分钟，尚未确认执行已恢复。");
+        }
         let recoveryAttempt = attempt;
         if (activeTurnId) {
           const session = this.store.getSession(attempt.localSessionId);
@@ -2551,6 +2613,8 @@ export class ProxySessionController {
             const runtime = this.runtimes.forAgent(session.agentName);
             const synchronized = await runtime.synchronizeSession(session.localSessionId);
             if (synchronized.activeTurnId === activeTurnId) {
+              this.recoveredLiveAttempts.add(attemptId);
+              this.recoveryRetryStartedAt.delete(attemptId);
               this.scheduleRecoveryRetry(attemptId, activeTurnId);
               return;
             }
@@ -2560,13 +2624,12 @@ export class ProxySessionController {
           }
         }
         await this.recoverTurnAttempt(recoveryAttempt, false);
+        if (!this.recoveryRetryTimers.has(attemptId)) this.recoveryRetryStartedAt.delete(attemptId);
       };
       void retry().catch((error: unknown) => {
-        this.logger.warn(
-          { error, attemptId, sessionId: attempt.localSessionId },
-          "Failed to retry an unfinished task recovery.",
-        );
-        this.scheduleRecoveryRetry(attemptId, activeTurnId);
+        return this.handleRecoveryError(attemptId, error, activeTurnId);
+      }).catch((error: unknown) => {
+        this.logger.error({ error, attemptId }, "Failed to finalize task recovery.");
       });
     }, 5_000);
     timer.unref?.();
@@ -2579,6 +2642,23 @@ export class ProxySessionController {
     turnId: string,
     replyTarget?: MessageReplyTarget,
   ): Promise<void> {
+    // Confirm resume before replacing the old card or announcing a running turn.
+    const current = this.store.getSession(session.localSessionId) ?? session;
+    const loaded = await this.loadSession({
+      ...current, contextKey: attempt.contextKey, status: "running", lastTurnId: turnId, lastTurnStatus: "running",
+    });
+    const pendingAttempt = this.store.getTurnAttempt(attempt.attemptId);
+    if (!pendingAttempt || !isIncompleteTurnAttemptStatus(pendingAttempt.status)) return;
+    const continued = turnViewSnapshot(this.store.getTurnSnapshot(turnId));
+    if (continued?.continuedFromTurnId && this.store.getTurnDelivery(turnId)?.progressMessageId) {
+      this.store.updateTurnAttempt(attempt.attemptId, { pendingTurnId: null, turnId, status: "running" });
+      await this.outbound.onEvent({ type: "turn_started", sessionId: session.localSessionId,
+        turnId, startedAt: continued.startedAt });
+      const synchronized = await loaded.runtime.synchronizeSession(session.localSessionId);
+      this.recoveryRetryStartedAt.delete(attempt.attemptId);
+      if (synchronized.activeTurnId) this.recoveredLiveAttempts.add(attempt.attemptId);
+      return;
+    }
     const oldCardTurnId = attempt.pendingTurnId ?? attempt.turnId;
     if (oldCardTurnId) {
       await this.outbound.interruptTurnForRecovery(
@@ -2607,16 +2687,12 @@ export class ProxySessionController {
       startedAt: Date.now(),
     });
     this.store.updateTurnAttempt(attempt.attemptId, { pendingTurnId: null });
-    const current = this.store.getSession(session.localSessionId) ?? session;
-    const loaded = await this.loadSession({
-      ...current,
-      contextKey: attempt.contextKey,
-      status: "running",
-      lastTurnId: turnId,
-      lastTurnStatus: "running",
-    });
     const synchronized = await loaded.runtime.synchronizeSession(session.localSessionId);
-    if (synchronized.activeTurnId) this.scheduleRecoveryRetry(attempt.attemptId, synchronized.activeTurnId);
+    this.recoveryRetryStartedAt.delete(attempt.attemptId);
+    if (synchronized.activeTurnId) {
+      this.recoveredLiveAttempts.add(attempt.attemptId);
+      this.scheduleRecoveryRetry(attempt.attemptId, synchronized.activeTurnId);
+    }
   }
 
   private async continueInterruptedAttempt(
@@ -2648,7 +2724,8 @@ export class ProxySessionController {
       });
     }
     const current = this.store.getSession(session.localSessionId) ?? session;
-    const loaded = await this.loadSession({ ...current, contextKey: attempt.contextKey });
+    const loaded = await this.loadSession({ ...current, contextKey: attempt.contextKey },
+      Boolean(this.store.getPendingProviderSettings(current.localSessionId)));
     const recoveryText = recoveryRuntimePrompt(attempt.promptText);
     const turnId = await this.startTurn(
       loaded,
@@ -2715,7 +2792,7 @@ export class ProxySessionController {
     localImagePaths?: string[],
     displayPrompt?: string,
   ): Promise<void> {
-    if (this.llmRetryingSessions.has(record.localSessionId)) {
+    if (this.llmRetryingSessions.has(record.localSessionId) || this.planHandoffs.has(record.localSessionId)) {
       const queued = this.persistQueuedPrompt(record.localSessionId, contextKey, text, {
         localImagePaths,
         messageId,
@@ -2751,7 +2828,7 @@ export class ProxySessionController {
     }
     let loaded: LoadedSession;
     try {
-      loaded = await this.loadSession(record);
+      loaded = await this.loadSession(record, Boolean(this.store.getPendingProviderSettings(record.localSessionId)));
     } catch (error) {
       if (await this.presentThreadWriterConflict(record, contextKey, error, true)) {
         throw new PresentedRequestError(error);
@@ -3891,6 +3968,25 @@ export class ProxySessionController {
   }
 
   private async startTurn(
+    loaded: LoadedSession, text: string, replyTarget?: MessageReplyTarget,
+    localImagePaths?: string[], options: StartTurnOptions = {},
+  ): Promise<string> {
+    return this.settingsOperations.run(loaded.record.localSessionId, async () => {
+      try {
+        await this.applyPendingProviderSettings(loaded);
+      } catch (error) {
+        await this.outbound.failPendingTurn(loaded.record.localSessionId, runtimeErrorMessage(error));
+        throw error;
+      }
+      if (this.store.getPendingProviderSettings(loaded.record.localSessionId)) {
+        throw new Error("Provider 切换尚未完成，请稍后重试。");
+      }
+      loaded.session = loaded.runtime.getSession(loaded.record.localSessionId) ?? loaded.session;
+      return this.startTurnNow(loaded, text, replyTarget, localImagePaths, options);
+    });
+  }
+
+  private async startTurnNow(
     loaded: LoadedSession,
     text: string,
     replyTarget?: MessageReplyTarget,
@@ -3946,9 +4042,15 @@ export class ProxySessionController {
         this.store.updateTurnAttempt(attemptId, { pendingTurnId: pendingTurnId ?? null });
 
         try {
+          if (options.approvedPlanTurnId && (this.planHandoffs.get(loaded.record.localSessionId) !== options.approvedPlanTurnId
+            || this.sessionResets.has(loaded.record.localSessionId))) {
+            throw new Error("方案执行已取消。");
+          }
           turnId = await loaded.runtime.startTurn(
             loaded.record.localSessionId,
-            runtimePrompt(runtimeText, localImagePaths),
+            options.approvedPlanTurnId
+              ? { text: runtimeText, collaborationMode: "default" }
+              : runtimePrompt(runtimeText, localImagePaths),
           );
           break;
         } catch (error) {
@@ -4521,18 +4623,27 @@ export class ProxySessionController {
     return { chatId: group.chatId, contextKey: groupContextKey, name: group.name };
   }
 
-  private async loadSession(record: SessionRecord): Promise<LoadedSession> {
+  private async loadSession(record: SessionRecord, forSettings = false): Promise<LoadedSession> {
     const agent = this.ensureAgent(record.agentName);
     const runtime = this.runtimes.forAgent(record.agentName);
     const existing = runtime.getSession(record.localSessionId);
-    if (existing) return { record, runtime, session: existing };
+    if (existing && (forSettings || !this.settingsOnlySessions.has(record.localSessionId))) {
+      return { record, runtime, session: existing };
+    }
     const pending = this.sessionLoads.get(record.localSessionId);
     if (pending) {
-      const loaded = await pending;
-      return {
-        ...loaded,
-        record: { ...loaded.record, contextKey: record.contextKey },
-      };
+      try {
+        const loaded = await pending;
+        if (!forSettings && this.settingsOnlySessions.has(record.localSessionId)) {
+          if (this.sessionLoads.get(record.localSessionId) === pending) this.sessionLoads.delete(record.localSessionId);
+          return this.loadSession(this.store.getSession(record.localSessionId) ?? record);
+        }
+        return { ...loaded, record: { ...loaded.record, contextKey: record.contextKey } };
+      } catch (error) {
+        if (!forSettings || !runtime.prepareSessionForSettings) throw error;
+        if (this.sessionLoads.get(record.localSessionId) === pending) this.sessionLoads.delete(record.localSessionId);
+        return this.loadSession(record, forSettings);
+      }
     }
 
     this.outbound.registerSession(
@@ -4544,7 +4655,16 @@ export class ProxySessionController {
       record.model,
       record.modelProvider,
     );
-    const loading = (async (): Promise<LoadedSession> => {
+    const loading = this.sessionHydrationOperations.run(record.localSessionId, async (): Promise<LoadedSession> => {
+      const latest = this.store.getSession(record.localSessionId);
+      if (latest) record = {
+        ...record, modelProvider: latest.modelProvider, model: latest.model,
+        reasoningEffort: latest.reasoningEffort, permissionMode: latest.permissionMode,
+      };
+      const current = runtime.getSession(record.localSessionId);
+      if (current && (forSettings || !this.settingsOnlySessions.has(record.localSessionId))) {
+        return { record, runtime, session: current };
+      }
       if (record.lastTurnId) {
         try {
           await this.outbound.resumeDelivery(record.localSessionId, record.contextKey, record.lastTurnId);
@@ -4556,41 +4676,30 @@ export class ProxySessionController {
         }
       }
       const permissionMode = record.permissionMode ?? "auto";
-      if (record.remoteSessionId) await this.assertSessionTurnOwnership(record, runtime);
+      const prepare = forSettings && record.remoteSessionId && runtime.prepareSessionForSettings;
+      if (record.remoteSessionId && !prepare) await this.assertSessionTurnOwnership(record, runtime);
       let session: RuntimeSession;
       if (record.remoteSessionId) {
-        try {
-          session = await runtime.resumeSession({
-            localSessionId: record.localSessionId,
-            remoteSessionId: record.remoteSessionId,
-            agentName: record.agentName,
-            cwd: record.cwd,
-            title: record.title,
-            modelProvider: record.modelProvider,
-            model: record.model,
-            reasoningEffort: record.reasoningEffort,
-            permissionMode,
-            activeTurnId: agent.kind === "app-server" && record.status === "running" && record.lastTurnStatus === "running"
-              ? record.lastTurnId
-              : undefined,
-            lastTurnId: record.lastTurnId,
-            lastTurnStatus: record.lastTurnStatus,
-          });
-        } catch (error) {
-          if (activeWriterThreadId(error)) throw error;
-          if (!(agent.kind === "app-server" && !record.lastTurnId
-            && !this.store.getForkHistorySource(record.localSessionId) && isMissingRolloutError(error))) throw error;
-          this.logger.warn({ error, sessionId: record.localSessionId }, "App Server task has no rollout; creating a replacement task.");
-          session = await runtime.createSession({
-            localSessionId: record.localSessionId,
-            agentName: record.agentName,
-            cwd: record.cwd,
-            title: record.title,
-            modelProvider: record.modelProvider,
-            model: record.model,
-            reasoningEffort: record.reasoningEffort,
-            permissionMode,
-          });
+        const input = {
+          localSessionId: record.localSessionId,
+          remoteSessionId: record.remoteSessionId,
+          agentName: record.agentName,
+          cwd: record.cwd,
+          title: record.title,
+          modelProvider: record.modelProvider,
+          model: record.model,
+          reasoningEffort: record.reasoningEffort,
+          permissionMode,
+          activeTurnId: agent.kind === "app-server" && record.status === "running" && record.lastTurnStatus === "running"
+            ? record.lastTurnId
+            : undefined,
+          lastTurnId: record.lastTurnId,
+          lastTurnStatus: record.lastTurnStatus,
+        };
+        if (prepare) this.settingsOnlySessions.add(record.localSessionId);
+        session = prepare ? await prepare.call(runtime, input) : await runtime.resumeSession(input);
+        if (session.remoteSessionId !== record.remoteSessionId) {
+          throw new Error("加载设置返回了不同的任务 ID，不允许替换任务或更改历史。");
         }
       } else {
         session = await runtime.createSession({
@@ -4604,19 +4713,22 @@ export class ProxySessionController {
           permissionMode,
         });
       }
-      this.persistRuntimeSession(record, session, session.activeTurnId ? "running" : "ready");
+      if (!prepare) {
+        this.settingsOnlySessions.delete(record.localSessionId);
+        this.persistRuntimeSession(record, session, session.activeTurnId ? "running" : "ready");
+      }
       const saved = this.store.getSession(record.localSessionId) ?? record;
       return {
         record: { ...saved, contextKey: record.contextKey },
         runtime,
         session,
       };
-    })();
+    });
     this.sessionLoads.set(record.localSessionId, loading);
     try {
       return await loading;
     } finally {
-      this.sessionLoads.delete(record.localSessionId);
+      if (this.sessionLoads.get(record.localSessionId) === loading) this.sessionLoads.delete(record.localSessionId);
     }
   }
 
@@ -4638,6 +4750,11 @@ export class ProxySessionController {
 
   private async handleRuntimeEvent(event: RuntimeEvent): Promise<void> {
     if ("turnId" in event) {
+      const recoveryAttempt = this.recoveryRetryStartedAt.size > 0
+        ? this.store.findIncompleteTurnAttemptByTurnId(event.turnId) : undefined;
+      if (recoveryAttempt && this.recoveryRetryStartedAt.has(recoveryAttempt.attemptId)) {
+        this.recoveredLiveAttempts.add(recoveryAttempt.attemptId);
+      }
       this.store.touchTurnAttempt(event.turnId);
       const source = this.store.getSession(event.sessionId);
       if (source?.remoteSessionId && this.isCodexSession(source)) {
@@ -4660,6 +4777,14 @@ export class ProxySessionController {
         );
       }
     }
+    if (event.type === "turn_completed" && event.approvedPlan) {
+      if (this.planHandoffs.get(event.sessionId) === event.turnId) return;
+      const attempt = this.store.findIncompleteTurnAttemptByTurnId(event.turnId);
+      if (attempt) {
+        await this.continueApprovedPlan(event, attempt);
+        return;
+      }
+    }
     const failedAttempt = event.type === "turn_failed"
       ? this.store.findIncompleteTurnAttemptByTurnId(event.turnId)
       : undefined;
@@ -4683,6 +4808,13 @@ export class ProxySessionController {
       this.store.updateSession(event.sessionId, { status: "running" });
       this.store.updateRuntimeSession(event.sessionId, { lastTurnId: event.turnId, lastTurnStatus: "running" });
     } else if (event.type === "turn_completed" || event.type === "turn_cancelled" || event.type === "turn_failed") {
+      const attempt = this.store.findIncompleteTurnAttemptByTurnId(event.turnId);
+      if (attempt) {
+        clearTimeout(this.recoveryRetryTimers.get(attempt.attemptId));
+        this.recoveryRetryTimers.delete(attempt.attemptId);
+        this.recoveryRetryStartedAt.delete(attempt.attemptId);
+        this.recoveredLiveAttempts.delete(attempt.attemptId);
+      }
       this.store.markTurnAttemptTerminal(
         event.turnId,
         event.type === "turn_completed" ? "completed" : event.type === "turn_cancelled" ? "cancelled" : "failed",
@@ -4698,7 +4830,7 @@ export class ProxySessionController {
           ...event,
           turnCount: event.turnCount ?? this.store.countTaskTurns(event.sessionId),
         }
-      : event;
+      : event.type === "turn_completed" && event.approvedPlan ? { ...event, approvedPlan: false } : event;
     const presentationEvent = event.type === "turn_failed"
       && isRetryableLlmTurnFailure(event.message)
       && (failedAttempt?.retryCount ?? 0) >= MAX_LLM_TURN_RETRIES
@@ -4736,6 +4868,7 @@ export class ProxySessionController {
         : undefined;
       if (latest?.lastTurnId === event.turnId && !activeTurnId) {
         this.store.updateSession(event.sessionId, { status: event.type === "turn_failed" ? "failed" : "ready" });
+        await this.applyPendingProviderWhenIdle(event.sessionId);
         await this.scheduleNextQueuedPrompt(event.sessionId);
       }
     }
@@ -4743,6 +4876,80 @@ export class ProxySessionController {
     if (presentationError) throw presentationError;
   }
 
+  private async continueApprovedPlan(
+    event: Extract<RuntimeEvent, { type: "turn_completed" }>,
+    attempt: TurnAttemptRecord,
+  ): Promise<void> {
+    const { sessionId, turnId } = event;
+    const source = this.store.getSession(sessionId);
+    if (!source || source.status === "closed" || source.lastTurnId !== turnId) return;
+    this.planHandoffs.set(sessionId, turnId);
+    this.store.markTurnAttemptTerminal(turnId, "completed");
+    this.store.updateRuntimeSession(sessionId, { lastTurnId: turnId, lastTurnStatus: "completed" });
+    let continued = false;
+    let failed = false;
+    try {
+      try {
+        await this.outbound.onEvent(event);
+      } catch (error) {
+        this.logger.warn({ error, sessionId, turnId }, "Failed to finalize the approved plan card.");
+      }
+      await this.settingsOperations.run(sessionId, async () => {
+        const current = this.store.getSessionForContext(sessionId, attempt.contextKey);
+        if (this.planHandoffs.get(sessionId) !== turnId || this.sessionResets.has(sessionId)
+          || !current || current.status === "closed" || current.remoteSessionId !== source.remoteSessionId) return;
+        const loaded = await this.loadSession(current);
+        await this.assertSessionTurnOwnership(current, loaded.runtime);
+        if (this.planHandoffs.get(sessionId) !== turnId || this.sessionResets.has(sessionId)) return;
+        // Another client may already have started the implementation.
+        let nextTurnId = loaded.session.activeTurnId;
+        if (!nextTurnId) {
+          if (current.lastTurnId !== turnId) return;
+          await this.applyPendingProviderSettings(loaded);
+          if (this.store.getPendingProviderSettings(sessionId)) throw new Error("Provider 切换尚未完成。");
+          if (this.planHandoffs.get(sessionId) !== turnId || this.sessionResets.has(sessionId)) return;
+          nextTurnId = await this.startTurnNow(
+            loaded,
+            "The proposed plan has been approved. Continue in the current task and workspace without asking for plan approval again; preserve the existing conversation and completed work. Implement the plan unless the user explicitly requested discussion or planning only, or prohibited implementation; those constraints still apply.",
+            attempt.replyMessageId ? { messageId: attempt.replyMessageId, replyInThread: true } : undefined,
+            undefined,
+            { messageId: attempt.messageId, displayPrompt: "方案已确认，继续执行", approvedPlanTurnId: turnId },
+          );
+        }
+        continued = true;
+        this.store.rebindPendingTurnMessages(sessionId, turnId, nextTurnId);
+        const latest = this.store.getSession(sessionId);
+        if (latest?.lastTurnId === nextTurnId && (latest.lastTurnStatus === "completed"
+          || latest.lastTurnStatus === "failed" || latest.lastTurnStatus === "cancelled")) {
+          await this.finalizeTurnMessageReactions(nextTurnId, latest.lastTurnStatus);
+        }
+        this.store.audit(attempt.contextKey, "approved_plan_continued", { sessionId, turnId, nextTurnId });
+      });
+    } catch (error) {
+      failed = true;
+      this.logger.error({ error, sessionId, turnId }, "Failed to continue an approved plan.");
+      await this.outbound.sendText(attempt.contextKey,
+        "方案已确认，但后续执行启动失败：" + runtimeErrorMessage(error) + "。请发送消息继续。");
+    } finally {
+      if (this.planHandoffs.get(sessionId) === turnId) this.planHandoffs.delete(sessionId);
+      if (!continued) {
+        try {
+          await this.outbound.onEvent(failed
+            ? { type: "turn_failed", sessionId, turnId, message: "方案已确认，但后续执行未能启动。" }
+            : { type: "turn_cancelled", sessionId, turnId });
+        } catch (error) {
+          this.logger.warn({ error, sessionId, turnId }, "Failed to finish the plan handoff card.");
+        }
+        await this.finalizeTurnMessageReactions(turnId, failed ? "failed" : "cancelled");
+      }
+      const latest = this.store.getSession(sessionId);
+      if (latest?.lastTurnId === turnId && latest.status !== "closed") {
+        this.store.updateSession(sessionId, { status: failed ? "failed" : "ready" });
+      }
+      await this.scheduleNextQueuedPrompt(sessionId);
+    }
+  }
+
   private async retryFailedLlmTurn(
     event: Extract<RuntimeEvent, { type: "turn_failed" }>,
     attempt: TurnAttemptRecord,
@@ -4784,7 +4991,7 @@ export class ProxySessionController {
       : undefined;
     try {
       const current = this.store.getSession(session.localSessionId) ?? session;
-      const loaded = await this.loadSession(current);
+      const loaded = await this.loadSession(current, Boolean(this.store.getPendingProviderSettings(current.localSessionId)));
       const retryTurnId = await this.startTurn(
         loaded,
         llmRetryRuntimePrompt(attempt.promptText, retryNumber),
@@ -4832,6 +5039,7 @@ export class ProxySessionController {
   }
 
   private scheduleQueuedPromptRetry(sessionId: string): void {
+    if (this.store.getPendingProviderSettings(sessionId)?.error) return;
     if (this.queuedPromptRetryTimers.has(sessionId)) return;
     if (this.store.countQueuedPrompts(sessionId) === 0) return;
     const timer = setTimeout(() => {
@@ -4849,24 +5057,31 @@ export class ProxySessionController {
   }
 
   private async startNextQueuedPromptIfIdle(sessionId: string): Promise<void> {
+    return this.settingsOperations.run(sessionId, () => this.startNextQueuedPromptIfIdleNow(sessionId));
+  }
+
+  private async startNextQueuedPromptIfIdleNow(sessionId: string): Promise<void> {
+    if (this.planHandoffs.has(sessionId) || this.sessionResets.has(sessionId)) return;
     if (this.store.countQueuedPrompts(sessionId) === 0) return;
     const baseRecord = this.store.getSession(sessionId);
     if (!baseRecord || baseRecord.status === "closed") return;
     let prompt: QueuedPromptRecord | undefined;
     try {
-      let loaded = await this.loadSession(baseRecord);
+      let loaded = await this.loadSession(baseRecord, Boolean(this.store.getPendingProviderSettings(sessionId)));
       const remoteActivity = await this.assertSessionTurnOwnership(loaded.record, loaded.runtime);
       if (needsFullSessionSynchronization(loaded.record, loaded.session, remoteActivity)) {
         loaded = { ...loaded, session: await loaded.runtime.synchronizeSession(sessionId) };
       }
       if (loaded.session.activeTurnId) return;
 
+      await this.applyPendingProviderSettings(loaded);
+      if (this.store.getPendingProviderSettings(sessionId)) return;
       prompt = this.store.takeNextQueuedPrompt(sessionId);
       if (!prompt) return;
       const record = this.store.getSessionForContext(sessionId, prompt.contextKey) ?? baseRecord;
       loaded = { ...loaded, record };
       await this.refreshPromptQueueCards(sessionId);
-      const turnId = await this.startTurn(
+      const turnId = await this.startTurnNow(
         loaded,
         prompt.text,
         prompt.replyMessageId ? { messageId: prompt.replyMessageId, replyInThread: true } : undefined,
@@ -4937,6 +5152,7 @@ export class ProxySessionController {
     });
     const pending = {
       contextKey: message.contextKey,
+      userId: message.userId,
       attachmentPromise,
       resolveAttachment,
     };
@@ -4945,14 +5161,15 @@ export class ProxySessionController {
   }
 
   private reserveForwardAttachment(message: IncomingMessage): ForwardAttachmentReservation | undefined {
-    if (!message.parentMessageId) return undefined;
+    if (!message.parentMessageId || isCommandMessage(message)) return undefined;
     const candidates = [
       { sourceKind: "merged_forward" as const, registry: this.pendingMergedForwards },
       { sourceKind: "resource" as const, registry: this.pendingResourceForwards },
     ];
     for (const candidate of candidates) {
       const pending = candidate.registry.get(message.parentMessageId);
-      if (!pending || pending.contextKey !== message.contextKey || pending.attachmentMessageId) continue;
+      if (!pending || pending.contextKey !== message.contextKey
+        || pending.userId !== message.userId || pending.attachmentMessageId) continue;
       pending.attachmentMessageId = message.messageId;
       return {
         sourceMessageId: message.parentMessageId,
@@ -4981,15 +5198,17 @@ export class ProxySessionController {
     pending: PendingForwardAttachment,
     registry: Map<string, PendingForwardAttachment>,
   ): Promise<IncomingMessage | undefined> {
-    let timer: NodeJS.Timeout | undefined;
-    const timeout = new Promise<undefined>((resolve) => {
-      timer = setTimeout(() => resolve(undefined), FORWARD_ATTACHMENT_WINDOW_MS);
-      timer.unref?.();
-    });
+    const timer = setTimeout(() => {
+      // Arrival reserves the pair before acknowledgement. A slow Reaction must not split it.
+      if (pending.attachmentMessageId) return;
+      if (registry.get(messageId) === pending) registry.delete(messageId);
+      pending.resolveAttachment(undefined);
+    }, FORWARD_ATTACHMENT_WINDOW_MS);
+    timer.unref?.();
     try {
-      return await Promise.race([pending.attachmentPromise, timeout]);
+      return await pending.attachmentPromise;
     } finally {
-      if (timer) clearTimeout(timer);
+      clearTimeout(timer);
       if (registry.get(messageId) === pending) {
         registry.delete(messageId);
       }
@@ -5068,6 +5287,7 @@ export class ProxySessionController {
   }
 
   private async cancelSession(record: SessionRecord): Promise<void> {
+    this.planHandoffs.delete(record.localSessionId);
     const runtime = this.runtimes.forAgent(record.agentName);
     if (runtime.kind === "codex" && record.remoteSessionId && runtime.interruptRemoteTurn) {
       if (runtime.getGoal && runtime.setGoal) {
@@ -5146,6 +5366,7 @@ export class ProxySessionController {
   }
 
   private async runSessionReset(sessionId: string, operation: () => Promise<void>): Promise<void> {
+    this.planHandoffs.delete(sessionId);
     const previous = this.sessionResets.get(sessionId) ?? Promise.resolve();
     const reset = previous.catch(() => undefined).then(operation);
     this.sessionResets.set(sessionId, reset);
@@ -5329,6 +5550,20 @@ export class ProxySessionController {
     contextKey: string,
     activeTab: ExecutionSettingsTab,
     options: ExecutionSettingsCardOptions = {},
+  ): Promise<void> {
+    const record = options.sessionId
+      ? this.requireSession(contextKey, options.sessionId)
+      : this.currentSession(contextKey);
+    if (!record) return this.openExecutionSettingsNow(contextKey, activeTab, options);
+    return this.settingsOperations.run(record.localSessionId, () => this.openExecutionSettingsNow(
+      contextKey, activeTab, { ...options, sessionId: record.localSessionId },
+    ));
+  }
+
+  private async openExecutionSettingsNow(
+    contextKey: string,
+    activeTab: ExecutionSettingsTab,
+    options: ExecutionSettingsCardOptions = {},
   ): Promise<void> {
     const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent!);
     const record = options.sessionId
@@ -5349,24 +5584,33 @@ export class ProxySessionController {
         reasoningOptions: [],
       };
     if (record) {
-      const loaded = await this.loadSession(record);
+      const loaded = await this.loadSession(record, true);
+      const pending = this.store.getPendingProviderSettings(record.localSessionId);
+      const selected = pending?.settings ?? loaded.session;
+      if (pending && options.updateMessageId) {
+        this.store.savePendingProviderSettings({
+          ...pending, contextKey, messageId: options.updateMessageId, replyMessageId: options.updateMessageId, activeTab,
+        });
+      }
       const providerSupported = loaded.runtime.kind === "codex" && Boolean(loaded.runtime.listModelProviders);
       const providers = providerSupported ? await this.modelProviderOptions(loaded) : [];
-      const currentProvider = loaded.session.modelProvider ?? providers.find((provider) => provider.isDefault)?.id;
-      const { models, warning } = await this.modelOptions(loaded.runtime, currentProvider, loaded.session.model);
-      const currentModel = models.find((model) => model.id === loaded.session.model)
+      const currentProvider = selected.modelProvider ?? providers.find((provider) => provider.isDefault)?.id;
+      const { models, warning } = await this.modelOptions(loaded.runtime, currentProvider, selected.model);
+      const currentModel = models.find((model) => model.id === selected.model)
         ?? models.find((model) => model.isDefault)
         ?? models[0];
       const currentEffort = currentModel?.supportedReasoningEfforts.some(
-        (option) => option.value === loaded.session.reasoningEffort,
+        (option) => option.value === selected.reasoningEffort,
       )
-        ? loaded.session.reasoningEffort
-        : currentModel?.defaultReasoningEffort ?? loaded.session.reasoningEffort;
+        ? selected.reasoningEffort
+        : currentModel?.defaultReasoningEffort ?? selected.reasoningEffort;
       runtimeSettings = {
+        pendingNotice: pending ? this.pendingProviderNotice(pending) : undefined,
+        pendingFailed: Boolean(pending?.error),
         currentProvider,
-        currentModel: currentModel?.id ?? loaded.session.model,
+        currentModel: pending?.settings.model ?? currentModel?.id ?? selected.model,
         currentEffort,
-        currentPermissionMode: loaded.session.permissionMode,
+        currentPermissionMode: selected.permissionMode,
         providers,
         providerSupported,
         models,
@@ -5382,7 +5626,10 @@ export class ProxySessionController {
       agents,
       runtimeSettingsAvailable: Boolean(record),
       ...runtimeSettings,
+      modelPage: options.expectedProvider !== undefined && options.expectedProvider !== (runtimeSettings.currentProvider ?? "")
+        ? undefined : options.modelPage,
       notice: options.notice,
+      warning: [runtimeSettings.warning, options.warning].filter(Boolean).join("\n") || undefined,
     });
     if (options.updateMessageId) {
       await this.outbound.updateInteractiveCard(contextKey, options.updateMessageId, card);
@@ -5400,7 +5647,12 @@ export class ProxySessionController {
     await this.openExecutionSettings(contextKey, "agent");
   }
 
-  private async selectProvider(
+  private async selectProvider(contextKey: string, modelProvider: string, options: ModelCardOptions = {}): Promise<void> {
+    const record = options.sessionId ? this.requireSession(contextKey, options.sessionId) : this.requireCurrentSession(contextKey);
+    return this.settingsOperations.run(record.localSessionId, () => this.selectProviderNow(contextKey, modelProvider, { ...options, sessionId: record.localSessionId }));
+  }
+
+  private async selectProviderNow(
     contextKey: string,
     modelProvider: string,
     options: ModelCardOptions = {},
@@ -5408,19 +5660,19 @@ export class ProxySessionController {
     const record = options.sessionId
       ? this.requireSession(contextKey, options.sessionId)
       : this.requireCurrentSession(contextKey);
-    await this.outbound.sendText(contextKey, `正在切换到 Provider ${modelProvider}，请稍后。`);
-    const loaded = await this.loadSession(record);
+    const loaded = await this.loadSession(record, true);
+    const selected = this.store.getPendingProviderSettings(record.localSessionId)?.settings ?? loaded.session;
     await this.assertModelProvider(loaded, modelProvider);
-    const models = await loaded.runtime.listModels(modelProvider, loaded.session.model);
-    const model = selectProviderModel(models, loaded.session.model);
+    const models = await loaded.runtime.listModels(modelProvider, selected.model);
+    const model = selectProviderModel(models, selected.model);
     if (!model) throw new Error("当前运行时没有可用于 Provider 切换的模型。");
-    const effort = selectProviderReasoningEffort(model, loaded.session.reasoningEffort);
-    await this.applyProviderSettings(contextKey, {
+    const effort = selectProviderReasoningEffort(model, selected.reasoningEffort);
+    await this.applyProviderSettingsNow(contextKey, {
       provider: modelProvider,
       model: model.id,
       effort,
-      mode: loaded.session.permissionMode,
-    }, options, false);
+      mode: selected.permissionMode,
+    }, options);
   }
 
   private async openProviderSelector(
@@ -5436,14 +5688,16 @@ export class ProxySessionController {
     permissionMode: PermissionMode,
     sessionId: string,
     updateMessageId: string,
+    modelPage?: number,
   ): Promise<void> {
-    const loaded = await this.loadSession(this.requireSession(contextKey, sessionId));
+    const loaded = await this.loadSession(this.requireSession(contextKey, sessionId), true);
     await this.assertModelProvider(loaded, modelProvider);
     const { models, warning } = await this.modelOptions(loaded.runtime, modelProvider, loaded.session.model);
     const card = this.cardRenderer.renderModelSelector({
       sessionId,
       contextKey,
       currentModel: selectProviderModel(models, loaded.session.model)?.id,
+      modelPage,
       reasoningEffort: loaded.session.reasoningEffort,
       models,
       warning,
@@ -5462,7 +5716,7 @@ export class ProxySessionController {
     sessionId: string,
     updateMessageId: string,
   ): Promise<void> {
-    const loaded = await this.loadSession(this.requireSession(contextKey, sessionId));
+    const loaded = await this.loadSession(this.requireSession(contextKey, sessionId), true);
     await this.assertModelProvider(loaded, modelProvider);
     const { models, warning } = await this.modelOptions(loaded.runtime, modelProvider, model);
     const selected = models.find((candidate) => candidate.id === model);
@@ -5498,7 +5752,7 @@ export class ProxySessionController {
     sessionId: string,
     updateMessageId: string,
   ): Promise<void> {
-    const loaded = await this.loadSession(this.requireSession(contextKey, sessionId));
+    const loaded = await this.loadSession(this.requireSession(contextKey, sessionId), true);
     await this.assertProviderModelSettings(loaded, modelProvider, model, effort);
     await this.outbound.updateInteractiveCard(
       contextKey,
@@ -5514,7 +5768,12 @@ export class ProxySessionController {
     );
   }
 
-  private async applyProviderSettings(
+  private async applyProviderSettings(contextKey: string, settings: { provider: string; model: string; effort: string; mode: PermissionMode }, options: ModelCardOptions = {}, announceStart = true): Promise<void> {
+    const record = options.sessionId ? this.requireSession(contextKey, options.sessionId) : this.requireCurrentSession(contextKey);
+    return this.settingsOperations.run(record.localSessionId, () => this.applyProviderSettingsNow(contextKey, settings, { ...options, sessionId: record.localSessionId }, announceStart));
+  }
+
+  private async applyProviderSettingsNow(
     contextKey: string,
     settings: { provider: string; model: string; effort: string; mode: PermissionMode },
     options: ModelCardOptions = {},
@@ -5523,17 +5782,38 @@ export class ProxySessionController {
     const record = options.sessionId
       ? this.requireSession(contextKey, options.sessionId)
       : this.requireCurrentSession(contextKey);
-    if (announceStart) {
-      await this.outbound.sendText(contextKey, `正在切换到 Provider ${settings.provider}，请稍后。`);
-    }
-    const loaded = await this.loadSession(record);
+    const loaded = await this.loadSession(record, true);
     const warning = await this.assertProviderModelSettings(loaded, settings.provider, settings.model, settings.effort);
-    const session = await this.changeProviderSettings(loaded, {
-      modelProvider: settings.provider,
-      model: settings.model,
-      reasoningEffort: settings.effort,
-      permissionMode: settings.mode,
-    });
+    const next: RuntimeExecutionSettings = {
+      modelProvider: settings.provider, model: settings.model,
+      reasoningEffort: settings.effort, permissionMode: settings.mode,
+    };
+    await this.reconcilePreparedSettingsSession(loaded);
+    if (loaded.session.activeTurnId || this.store.getPendingProviderSettings(record.localSessionId)) {
+      await this.savePendingProviderSelection(loaded, next, contextKey, options, "provider");
+      return;
+    }
+    if (announceStart) await this.outbound.sendText(contextKey, `正在切换到 Provider ${settings.provider}，请稍后。`);
+    const previous = { ...loaded.session };
+    let session: RuntimeSession;
+    try {
+      session = await this.changeProviderSettings(loaded, next);
+    } catch (error) {
+      if (!this.providerSettingsRestored(loaded, previous, error)) {
+        this.store.savePendingProviderSettings({
+          localSessionId: record.localSessionId, contextKey, settings: next, activeTab: "provider",
+          messageId: options.updateMessageId,
+          replyMessageId: options.updateMessageId ?? this.controlSessionReplyTarget(record)?.messageId,
+          error: runtimeErrorMessage(error),
+        });
+        if (options.updateMessageId) {
+          await this.openExecutionSettingsNow(contextKey, "provider", options).catch((presentationError: unknown) => {
+            this.logger.warn({ error: presentationError, sessionId: record.localSessionId }, "Failed to refresh rejected Provider selection.");
+          });
+        }
+      }
+      throw error;
+    }
     const notice = [
       `Provider 已切换为 ${cardCode(session.modelProvider ?? settings.provider)}`,
       `模型 ${cardCode(session.model ?? settings.model)}`,
@@ -5542,7 +5822,7 @@ export class ProxySessionController {
       `并已保存为 ${cardCode(loaded.record.agentName)} Agent 的默认设置，从下一次请求生效。`,
     ].join("，");
     if (options.updateMessageId) {
-      await this.openProviderSelector(contextKey, {
+      await this.openExecutionSettingsNow(contextKey, "provider", {
         sessionId: loaded.record.localSessionId,
         updateMessageId: options.updateMessageId,
         notice,
@@ -5553,15 +5833,23 @@ export class ProxySessionController {
   }
 
   private async changeProviderSettings(loaded: LoadedSession, settings: RuntimeExecutionSettings): Promise<RuntimeSession> {
+    return this.sessionHydrationOperations.run(loaded.record.localSessionId, () => this.changeProviderSettingsNow(loaded, settings));
+  }
+
+  private async changeProviderSettingsNow(loaded: LoadedSession, settings: RuntimeExecutionSettings): Promise<RuntimeSession> {
     if (!loaded.runtime.setExecutionSettings) throw new Error("当前运行时不支持 Provider 设置。");
-    const persist = async (candidate: RuntimeSession): Promise<void> => {
+    loaded.session = loaded.runtime.getSession(loaded.record.localSessionId) ?? loaded.session;
+    const remoteSessionId = loaded.session.remoteSessionId;
+    const persist = (candidate: RuntimeSession): Promise<void> => this.agentDefaultsOperations.run(loaded.record.agentName, async () => {
+      if (candidate.remoteSessionId !== remoteSessionId) {
+        throw new Error("设置切换返回了不同的任务 ID，未保存设置；不允许替换任务或更改历史。");
+      }
       assertProviderSettingsApplied(candidate, settings);
       const agent = this.ensureAgent(loaded.record.agentName);
       const previousDefaults = agent.defaults;
-      await this.persistAgentExecutionDefaults(loaded.record.localSessionId, candidate);
+      await this.persistAgentExecutionDefaultsNow(loaded.record.localSessionId, candidate);
       try {
         this.store.updateRuntimeSession(loaded.record.localSessionId, {
-          remoteSessionId: candidate.remoteSessionId,
           modelProvider: candidate.modelProvider,
           model: candidate.model,
           reasoningEffort: candidate.reasoningEffort,
@@ -5572,12 +5860,145 @@ export class ProxySessionController {
         agent.defaults = previousDefaults;
         throw error;
       }
-    };
+    });
     const session = await loaded.runtime.setExecutionSettings(loaded.record.localSessionId, settings, persist);
+    this.settingsOnlySessions.delete(loaded.record.localSessionId);
     this.outbound.updateSessionModel(loaded.record.localSessionId, session.model, session.modelProvider);
     return session;
   }
 
+  private async reconcilePreparedSettingsSession(loaded: LoadedSession): Promise<void> {
+    if (!this.settingsOnlySessions.has(loaded.record.localSessionId) || !loaded.session.activeTurnId) return;
+    const activity = await this.assertSessionTurnOwnership(loaded.record, loaded.runtime);
+    if (activity && !activity.active) {
+      loaded.session = await loaded.runtime.synchronizeSession(loaded.record.localSessionId);
+    }
+  }
+
+  private providerSettingsRestored(loaded: LoadedSession, previous: RuntimeSession, error: unknown): boolean {
+    const restored = loaded.runtime.getSession(loaded.record.localSessionId);
+    const saved = this.store.getSession(loaded.record.localSessionId);
+    const keys = ["remoteSessionId", "modelProvider", "model", "reasoningEffort", "permissionMode"] as const;
+    return error instanceof ProviderSwitchError && error.previousSettingsRestored
+      && Boolean(restored && saved && keys.every((key) => restored[key] === previous[key] && saved[key] === previous[key]));
+  }
+
+  private pendingProviderNotice(pending: PendingProviderSettings): string {
+    const target = `Provider ${cardCode(pending.settings.modelProvider)}，模型 ${cardCode(pending.settings.model)}`;
+    return pending.error
+      ? `切换失败：${pending.error}。目标为 ${target}；后续轮次已暂停，请重新选择 Provider 或模型重试。`
+      : `待生效：当前轮次不变，结束后切换到 ${target}。可继续选择模型，以最后选择为准。`;
+  }
+
+  private async savePendingProviderSelection(
+    loaded: LoadedSession, settings: RuntimeExecutionSettings, contextKey: string,
+    options: ModelCardOptions, activeTab: ExecutionSettingsTab,
+  ): Promise<void> {
+    const previous = this.store.getPendingProviderSettings(loaded.record.localSessionId);
+    const pending: PendingProviderSettings = {
+      localSessionId: loaded.record.localSessionId, contextKey, settings, activeTab,
+      messageId: options.updateMessageId ?? previous?.messageId,
+      replyMessageId: options.updateMessageId ?? previous?.replyMessageId
+        ?? this.controlSessionReplyTarget(loaded.record)?.messageId,
+    };
+    this.store.savePendingProviderSettings(pending);
+    await this.reconcilePreparedSettingsSession(loaded);
+    if (!loaded.session.activeTurnId) {
+      await this.applyPendingProviderSettings(loaded);
+      void this.scheduleNextQueuedPrompt(loaded.record.localSessionId).catch((error: unknown) => {
+        this.logger.warn({ error }, "Failed to resume queue after Provider selection.");
+      });
+      return;
+    }
+    if (options.updateMessageId) {
+      await this.openExecutionSettingsNow(contextKey, activeTab, options);
+    } else {
+      await this.outbound.sendText(contextKey, this.pendingProviderNotice(pending).replaceAll("`", ""));
+    }
+  }
+
+  // Caller holds settingsOperations; only a verified rollback can unblock the next turn.
+  private async applyPendingProviderSettings(loaded: LoadedSession): Promise<void> {
+    const pending = this.store.getPendingProviderSettings(loaded.record.localSessionId);
+    if (!pending) return;
+    await this.reconcilePreparedSettingsSession(loaded);
+    if (loaded.runtime.getSession(loaded.record.localSessionId)?.activeTurnId) return;
+    if (pending.error) throw new Error(this.pendingProviderNotice(pending));
+    const previous = { ...(loaded.runtime.getSession(loaded.record.localSessionId) ?? loaded.session) };
+    let notice: string;
+    let failure: unknown;
+    let rolledBack = false;
+    try {
+      loaded.session = await this.changeProviderSettings(loaded, pending.settings);
+      this.store.deletePendingProviderSettings(pending.localSessionId);
+      notice = `Provider 已切换为 ${cardCode(pending.settings.modelProvider)}，模型 ${cardCode(pending.settings.model)}，从下一轮生效。`;
+    } catch (error) {
+      const restored = loaded.runtime.getSession(pending.localSessionId);
+      rolledBack = this.providerSettingsRestored(loaded, previous, error);
+      if (rolledBack) {
+        loaded.session = restored!;
+        this.store.deletePendingProviderSettings(pending.localSessionId);
+        this.outbound.updateSessionModel(pending.localSessionId, previous.model, previous.modelProvider);
+        notice = `切换到 Provider ${cardCode(pending.settings.modelProvider)}、模型 ${cardCode(pending.settings.model)} 失败：${runtimeErrorMessage(error)} 已回退到 Provider ${cardCode(previous.modelProvider ?? "Agent 默认")}、模型 ${cardCode(previous.model ?? "默认")}，后续轮次继续使用原设置。`;
+      } else {
+        failure = error;
+        const failed = { ...pending, error: runtimeErrorMessage(error) };
+        this.store.savePendingProviderSettings(failed);
+        notice = this.pendingProviderNotice(failed);
+      }
+    }
+    try {
+      await this.outbound.withReplyTarget(pending.contextKey, pending.replyMessageId
+        ? { messageId: pending.replyMessageId, replyInThread: true } : undefined, async () => {
+        if (pending.messageId) {
+          try {
+            await this.openExecutionSettingsNow(pending.contextKey, pending.activeTab ?? "provider", {
+              sessionId: pending.localSessionId, updateMessageId: pending.messageId,
+              notice: failure || rolledBack ? undefined : notice,
+              warning: rolledBack ? notice.replaceAll("`", "") : undefined,
+            });
+            return;
+          } catch (error) {
+            this.logger.warn({ error, sessionId: pending.localSessionId }, "Failed to refresh Provider settings card.");
+          }
+        }
+        await this.outbound.sendText(pending.contextKey, notice.replaceAll("`", ""));
+      });
+    } catch (error) {
+      this.logger.warn({ error, sessionId: pending.localSessionId }, "Failed to notify Provider settings result.");
+    }
+    if (failure) throw failure;
+  }
+
+  private async applyPendingProviderWhenIdle(sessionId: string): Promise<void> {
+    await this.settingsOperations.run(sessionId, async () => {
+      if (this.recoveryClosed) return;
+      const pending = this.store.getPendingProviderSettings(sessionId);
+      if (!pending || pending.error) return;
+      const record = this.store.getSession(sessionId);
+      if (!record || record.status === "closed") {
+        this.store.deletePendingProviderSettings(sessionId);
+        return;
+      }
+      try {
+        const loaded = await this.loadSession(record, true);
+        await this.applyPendingProviderSettings(loaded);
+      } catch (error) {
+        this.logger.warn({ error, sessionId }, "Deferred Provider switch could not be applied.");
+        if (!this.store.getPendingProviderSettings(sessionId)?.error) {
+          const failed = { ...pending, error: runtimeErrorMessage(error) };
+          this.store.savePendingProviderSettings(failed);
+          await this.outbound.withReplyTarget(pending.contextKey, pending.replyMessageId
+            ? { messageId: pending.replyMessageId, replyInThread: true } : undefined,
+          () => this.outbound.sendText(pending.contextKey, this.pendingProviderNotice(failed).replaceAll("`", "")))
+            .catch((notificationError: unknown) => {
+              this.logger.warn({ error: notificationError, sessionId }, "Failed to notify Provider recovery failure.");
+            });
+        }
+      }
+    });
+  }
+
   private async assertProviderModelSettings(
     loaded: LoadedSession,
     modelProvider: string,
@@ -5622,36 +6043,52 @@ export class ProxySessionController {
   }
 
   private async model(contextKey: string, model?: string, options: ModelCardOptions = {}): Promise<void> {
+    const record = options.sessionId ? this.requireSession(contextKey, options.sessionId) : this.requireCurrentSession(contextKey);
+    return this.settingsOperations.run(record.localSessionId, () => this.modelNow(contextKey, model, { ...options, sessionId: record.localSessionId }));
+  }
+
+  private async modelNow(contextKey: string, model?: string, options: ModelCardOptions = {}): Promise<void> {
     if (!model) {
-      await this.openExecutionSettings(contextKey, "model", options);
+      await this.openExecutionSettingsNow(contextKey, "model", options);
       return;
     }
     const record = options.sessionId
       ? this.requireSession(contextKey, options.sessionId)
       : this.requireCurrentSession(contextKey);
-    const loaded = await this.loadSession(record);
-    const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
+    const loaded = await this.loadSession(record, true);
+    const pending = this.store.getPendingProviderSettings(record.localSessionId);
+    const selectedSettings = pending?.settings ?? loaded.session;
+    if (options.expectedProvider && options.expectedProvider !== selectedSettings.modelProvider) {
+      throw new Error("Provider 已发生变化，请重新打开运行设置后选择。");
+    }
+    const models = await loaded.runtime.listModels(selectedSettings.modelProvider, selectedSettings.model);
     const selected = models.find((item) => item.id === model);
     if (!selected) throw new Error(`未知模型：${model}`);
-    const currentEffort = loaded.session.reasoningEffort;
+    const currentEffort = selectedSettings.reasoningEffort;
     const compatible = currentEffort
       ? selected.supportedReasoningEfforts.length === 0
         || selected.supportedReasoningEfforts.some((option) => option.value === currentEffort)
       : false;
     const nextEffort = compatible ? currentEffort : selected.defaultReasoningEffort;
 
-    await loaded.runtime.setModel(loaded.record.localSessionId, model);
-    if (nextEffort && nextEffort !== currentEffort) {
-      await loaded.runtime.setReasoningEffort(loaded.record.localSessionId, nextEffort);
+    if (pending) {
+      await this.savePendingProviderSelection(loaded, { ...pending.settings, model, reasoningEffort: selectProviderReasoningEffort(selected, nextEffort) }, contextKey, options, "model");
+      return;
     }
-    this.store.updateRuntimeSession(loaded.record.localSessionId, { model, reasoningEffort: nextEffort });
-    this.outbound.updateSessionModel(loaded.record.localSessionId, model, loaded.session.modelProvider);
-    await this.persistAgentExecutionDefaults(loaded.record.localSessionId);
+    await this.sessionHydrationOperations.run(loaded.record.localSessionId, async () => {
+      await loaded.runtime.setModel(loaded.record.localSessionId, model);
+      if (nextEffort && nextEffort !== currentEffort) {
+        await loaded.runtime.setReasoningEffort(loaded.record.localSessionId, nextEffort);
+      }
+      this.store.updateRuntimeSession(loaded.record.localSessionId, { model, reasoningEffort: nextEffort });
+      this.outbound.updateSessionModel(loaded.record.localSessionId, model, loaded.session.modelProvider);
+      await this.persistAgentExecutionDefaults(loaded.record.localSessionId);
+    });
     const effortMessage = nextEffort && nextEffort !== currentEffort
       ? `，思考强度已自动调整为 ${nextEffort}`
       : "";
     if (options.updateMessageId) {
-      await this.openExecutionSettings(contextKey, "model", {
+      await this.openExecutionSettingsNow(contextKey, "model", {
         sessionId: loaded.record.localSessionId,
         updateMessageId: options.updateMessageId,
         notice: `模型已切换为 ${cardCode(model)}${effortMessage}，并已保存为 ${cardCode(loaded.record.agentName)} Agent 的默认设置，从下一次请求生效。`,
@@ -5827,6 +6264,7 @@ export class ProxySessionController {
     const created = await this.shellCommandJobs.createJob({ contextKey, sourceMessageId, command, cwd });
     let cardMessageId: string | undefined;
     const initialState: ShellCommandCardView = {
+      terminalUrl: this.lifecycle?.terminalUrl?.(created.id),
       jobId: created.id,
       contextKey,
       command,
@@ -5853,7 +6291,7 @@ export class ProxySessionController {
           await this.outbound.updateInteractiveCard(
             contextKey,
             cardMessageId,
-            this.cardRenderer.renderShellCommandCard(shellCommandJobCardView(failed)),
+            this.cardRenderer.renderShellCommandCard({ ...shellCommandJobCardView(failed), terminalUrl: this.lifecycle?.terminalUrl?.(failed.id) }),
           );
           await this.shellCommandJobs.markPresented(created.id);
         } catch (cardError) {
@@ -5911,7 +6349,7 @@ export class ProxySessionController {
   ): void {
     if (!job.cardMessageId || this.shellCommandJobMonitors.has(job.id)) return;
     const scheduler = new CardUpdateScheduler<ShellCommandCardView>({
-      render: (state) => this.cardRenderer.renderShellCommandCard(state),
+      render: (state) => this.cardRenderer.renderShellCommandCard({ ...state, terminalUrl: this.lifecycle?.terminalUrl?.(job.id) }),
       write: (card) => this.outbound.updateInteractiveCard(job.contextKey, job.cardMessageId!, card),
       onError: (error) => this.logger.warn(
         { error, jobId: job.id, contextKey: job.contextKey, messageId: job.cardMessageId },
@@ -6062,16 +6500,26 @@ export class ProxySessionController {
   }
 
   private async thinking(contextKey: string, effort?: string, options: ThinkingCardOptions = {}): Promise<void> {
+    const record = options.sessionId ? this.requireSession(contextKey, options.sessionId) : this.requireCurrentSession(contextKey);
+    return this.settingsOperations.run(record.localSessionId, () => this.thinkingNow(contextKey, effort, { ...options, sessionId: record.localSessionId }));
+  }
+
+  private async thinkingNow(contextKey: string, effort?: string, options: ThinkingCardOptions = {}): Promise<void> {
     if (!effort) {
-      await this.openExecutionSettings(contextKey, "thinking", options);
+      await this.openExecutionSettingsNow(contextKey, "thinking", options);
       return;
     }
     const record = options.sessionId
       ? this.requireSession(contextKey, options.sessionId)
       : this.requireCurrentSession(contextKey);
-    const loaded = await this.loadSession(record);
-    const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
-    const currentModel = models.find((item) => item.id === loaded.session.model)
+    const loaded = await this.loadSession(record, true);
+    const pending = this.store.getPendingProviderSettings(record.localSessionId);
+    const selectedSettings = pending?.settings ?? loaded.session;
+    if (options.expectedProvider && options.expectedProvider !== selectedSettings.modelProvider) {
+      throw new Error("Provider 已发生变化，请重新打开运行设置后选择。");
+    }
+    const models = await loaded.runtime.listModels(selectedSettings.modelProvider, selectedSettings.model);
+    const currentModel = models.find((item) => item.id === selectedSettings.model)
       ?? models.find((item) => item.isDefault);
     if (!currentModel) throw new Error("当前运行时没有可配置思考强度的模型。");
     if (options.expectedModel && currentModel.id !== options.expectedModel) {
@@ -6083,11 +6531,17 @@ export class ProxySessionController {
       const options = supported.map((option) => option.value).join("、") || "无";
       throw new Error(`不支持的思考强度：${effort}。支持的强度：${options}`);
     }
-    await loaded.runtime.setReasoningEffort(loaded.record.localSessionId, effort);
-    this.store.updateRuntimeSession(loaded.record.localSessionId, { reasoningEffort: effort });
-    await this.persistAgentExecutionDefaults(loaded.record.localSessionId);
+    if (pending) {
+      await this.savePendingProviderSelection(loaded, { ...pending.settings, reasoningEffort: effort }, contextKey, options, "thinking");
+      return;
+    }
+    await this.sessionHydrationOperations.run(loaded.record.localSessionId, async () => {
+      await loaded.runtime.setReasoningEffort(loaded.record.localSessionId, effort);
+      this.store.updateRuntimeSession(loaded.record.localSessionId, { reasoningEffort: effort });
+      await this.persistAgentExecutionDefaults(loaded.record.localSessionId);
+    });
     if (options.updateMessageId) {
-      await this.openExecutionSettings(contextKey, "thinking", {
+      await this.openExecutionSettingsNow(contextKey, "thinking", {
         sessionId: loaded.record.localSessionId,
         updateMessageId: options.updateMessageId,
         notice: `思考强度已切换为 ${cardCode(effort)}，并已保存为 ${cardCode(loaded.record.agentName)} Agent 的默认设置，从下一次请求生效。`,
@@ -6100,25 +6554,38 @@ export class ProxySessionController {
     );
   }
 
-  private async permissions(
+  private async permissions(contextKey: string, mode?: PermissionMode, options: ModelCardOptions = {}): Promise<void> {
+    const record = options.sessionId ? this.requireSession(contextKey, options.sessionId) : this.requireCurrentSession(contextKey);
+    return this.settingsOperations.run(record.localSessionId, () => this.permissionsNow(contextKey, mode, { ...options, sessionId: record.localSessionId }));
+  }
+
+  private async permissionsNow(
     contextKey: string,
     mode?: PermissionMode,
     options: ModelCardOptions = {},
   ): Promise<void> {
     if (!mode) {
-      await this.openExecutionSettings(contextKey, "permission", options);
+      await this.openExecutionSettingsNow(contextKey, "permission", options);
       return;
     }
     const record = options.sessionId
       ? this.requireSession(contextKey, options.sessionId)
       : this.requireCurrentSession(contextKey);
-    const loaded = await this.loadSession(record);
-    await loaded.runtime.setPermissionMode(record.localSessionId, mode);
-    loaded.session.permissionMode = mode;
-    this.store.updateRuntimeSession(record.localSessionId, { permissionMode: mode });
-    await this.persistAgentExecutionDefaults(record.localSessionId);
+    const loaded = await this.loadSession(record, true);
+    const pending = this.store.getPendingProviderSettings(record.localSessionId);
+    if (pending) {
+      await this.savePendingProviderSelection(loaded, { ...pending.settings, permissionMode: mode }, contextKey, options, "permission");
+      return;
+    }
+    await this.sessionHydrationOperations.run(record.localSessionId, async () => {
+      await loaded.runtime.setPermissionMode(record.localSessionId, mode);
+      loaded.session = loaded.runtime.getSession(record.localSessionId) ?? loaded.session;
+      loaded.session.permissionMode = mode;
+      this.store.updateRuntimeSession(record.localSessionId, { permissionMode: mode });
+      await this.persistAgentExecutionDefaults(record.localSessionId);
+    });
     if (options.updateMessageId) {
-      await this.openExecutionSettings(contextKey, "permission", {
+      await this.openExecutionSettingsNow(contextKey, "permission", {
         sessionId: loaded.record.localSessionId,
         updateMessageId: options.updateMessageId,
         notice: mode === "auto"
@@ -6163,7 +6630,8 @@ export class ProxySessionController {
     const existing = this.turnDetailHydrations.get(turnId);
     if (existing) return existing;
     const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(turnId));
-    if ((!snapshot || snapshot.previewJournal) && this.store.previews.has(turnId)) return this.store.previews.load(turnId);
+    const previewTurnId = snapshot?.previewTurnId ?? turnId;
+    if ((!snapshot || snapshot.previewJournal) && this.store.previews.has(previewTurnId)) return this.store.previews.load(previewTurnId);
     if (snapshot && !needsHistoricalDetails(snapshot)) return snapshot;
     const origin = !snapshot ? this.store.getTurnRuntimeOrigin(turnId) : undefined;
     if (!snapshot && (!origin || !this.runtimes.forAgent(origin.agentName).readRemoteTurn)) return undefined;
@@ -6189,7 +6657,7 @@ export class ProxySessionController {
     }
     // An Agent Bot turn may have arrived while the read-only request was in flight.
     const latest = turnViewSnapshot(this.store.getTurnSnapshot(origin.turnId));
-    if (latest) return latest.previewJournal ? this.store.previews.load(origin.turnId) ?? latest : latest;
+    if (latest) return latest.previewJournal ? this.store.previews.load(latest.previewTurnId ?? origin.turnId) ?? latest : latest;
     const state = hydrateTurnViewState(createTurnViewState(
       origin.localSessionId, origin.turnId, details.startedAt ?? 0,
       remote?.title, undefined, remote?.cwd, undefined, this.agentLabel(origin.agentName),
@@ -6754,20 +7222,28 @@ export class ProxySessionController {
       const project = taskProjectInfo(entry);
       const projectActionSource = projectActionSources.get(project.key) ?? entry;
       const marker = entry.current ? "✅ " : entry.active ? "🟢 " : "";
-      const showStop = entry.status === "外部执行中"
-        && entry.reference !== options.forceSwitchTaskId
-        && entry.id !== options.forceSwitchTaskId;
-      const actions: TaskListCardAction[] = entry.current ? [] : [bindCardAction({
-        text: showStop ? "Stop" : "Switch",
-        type: showStop ? "danger" as const : "default" as const,
+      const stopAction = entry.active ? bindCardAction({
+        text: "Stop",
+        type: "danger",
         value: {
-          action: showStop ? "session_stop" : "session_switch",
+          action: "session_stop",
           sessionId: entry.reference,
           ...(searchTerm ? { searchTerm } : {}),
           page: String(page),
           contextKey,
         },
-      })];
+      }) : undefined;
+      const actions: TaskListCardAction[] = [];
+      if (!entry.current && entry.status !== "外部执行中") actions.push(bindCardAction({
+        text: "Switch",
+        value: {
+          action: "session_switch",
+          sessionId: entry.reference,
+          ...(searchTerm ? { searchTerm } : {}),
+          page: String(page),
+          contextKey,
+        },
+      }));
       actions.push(bindCardAction({
         text: "SwitchGroup",
         value: {
@@ -6833,7 +7309,7 @@ export class ProxySessionController {
           contextKey,
         },
       }));
-      actions.push(bindCardAction({
+      if (!entry.active) actions.push(bindCardAction({
         text: "Archive",
         value: {
           action: "session_archive",
@@ -6855,6 +7331,7 @@ export class ProxySessionController {
             `**最新 Prompt**：${cardText(lastUserPrompt)}`,
             `<font color='grey'>最近更新：${cardText(entry.updatedLabel)}</font>`,
           ],
+          stopAction,
           actions,
           current: entry.current,
         },
@@ -6884,7 +7361,7 @@ export class ProxySessionController {
         `第 ${page + 1} 页 · 每页 ${SESSION_PAGE_SIZE} 个任务${hasNext ? "" : ` · 当前共 ${entries.length} 个任务`}`,
         "",
         "> 项目菜单：**New** 新建任务，**NewGroup** 新建群。",
-        "> 任务详情：**Switch** 切换，**Stop** 停止，**Fork** / **ForkGroup** 创建分支，**Status** 查看状态，**Archive** 归档。",
+        "> 任务详情：**Switch** 切换，运行中任务可用 **Stop** 发送停止信号，**Fork** / **ForkGroup** 创建分支，**Status** 查看状态，**Archive** 归档。",
       ],
       [
         ...(hasPrevious ? [bindCardAction({
@@ -6959,7 +7436,7 @@ export class ProxySessionController {
 
   private async refreshSessionsCardFromAction(
     action: CardAction,
-    options: { forceSwitchTaskId?: string; page?: number } = {},
+    options: { page?: number } = {},
   ): Promise<void> {
     if (!action.messageId) return;
     const searchTerm = typeof action.value.searchTerm === "string" && action.value.searchTerm.trim()
@@ -6967,7 +7444,6 @@ export class ProxySessionController {
       : undefined;
     await this.listSessions(action.contextKey, searchTerm, {
       updateMessageId: action.messageId,
-      forceSwitchTaskId: options.forceSwitchTaskId,
       page: options.page ?? parseSessionPage(action.value.page),
     });
   }
@@ -7156,7 +7632,7 @@ export class ProxySessionController {
     const remoteReference = local
       ? remoteSessionReference(local.agentName, local.remoteSessionId!)
       : taskId;
-    const { agentName, runtime, remote } = await this.resolveRemoteCodexSession(remoteReference);
+    const { agentName, runtime, remote } = await this.resolveRemoteCodexSession(remoteReference, { view: "metadata" });
     if (isRemoteSessionActive(remote)) {
       throw new Error("任务正在执行，无法归档。请先停止任务或等待本轮完成。");
     }
@@ -7165,7 +7641,11 @@ export class ProxySessionController {
     }
 
     const wasCurrent = Boolean(local && this.store.getUserContext(contextKey)?.currentSessionId === local.localSessionId);
-    await runtime.archiveRemoteSession(remote.id);
+    const allowUnmaterialized = Boolean(local && !local.lastTurnId && !local.lastTurnStatus
+      && !this.store.hasTurnAttemptsForSession(local.localSessionId)
+      && !this.store.getForkHistorySource(local.localSessionId)
+      && this.store.listTaskTurnGraphIndex(local.localSessionId).length === 0);
+    await runtime.archiveRemoteSession(remote.id, { allowUnmaterialized });
     const title = local?.title ?? remote.title ?? remote.preview ?? remote.id;
     if (local) {
       this.store.archiveSession(local.localSessionId);
@@ -7318,6 +7798,7 @@ export class ProxySessionController {
       }
       const localActiveTurnId = runtime.getSession(record.localSessionId)?.activeTurnId;
       const runtimeOwnsActiveTurn = Boolean(localActiveTurnId)
+        && (!this.settingsOnlySessions.has(record.localSessionId) || Boolean(activity.activeTurnId))
         && (!activity.activeTurnId || activity.activeTurnId === localActiveTurnId);
       const persistedTurnMatches = record.status === "running"
         && record.lastTurnStatus === "running"
@@ -7719,6 +8200,12 @@ export class ProxySessionController {
   }
 
   private async persistAgentExecutionDefaults(localSessionId: string, candidate?: RuntimeSession): Promise<void> {
+    const record = this.store.getSession(localSessionId);
+    if (!record) throw new Error(`找不到任务：${localSessionId}`);
+    return this.agentDefaultsOperations.run(record.agentName, () => this.persistAgentExecutionDefaultsNow(localSessionId, candidate));
+  }
+
+  private async persistAgentExecutionDefaultsNow(localSessionId: string, candidate?: RuntimeSession): Promise<void> {
     const record = this.store.getSession(localSessionId);
     if (!record) throw new Error(`找不到任务：${localSessionId}`);
     const session = candidate ?? record;
@@ -8848,6 +9335,13 @@ function executionSettingsTabValue(value: unknown): ExecutionSettingsTab {
   throw new Error("设置卡片的 tab 无效，请重新发送设置命令。");
 }
 
+function modelCardPageValue(value: unknown): number | undefined {
+  if (value === undefined) return undefined;
+  const page = typeof value === "number" || (typeof value === "string" && value.trim()) ? Number(value) : NaN;
+  if (!Number.isSafeInteger(page) || page < 0) throw new Error("模型卡片页码无效，请重新发送 /model。");
+  return page;
+}
+
 function resetHistoryPageValue(value: unknown): number {
   const page = Number(value);
   if (!Number.isSafeInteger(page) || page < 0) throw new Error("历史轮次卡片页码无效，请重新发送 /turns。");
@@ -9255,10 +9749,18 @@ function defaultResourcePromptFromCounts(imageCount: number, fileCount: number):
   return imageCount === 1 ? "请查看这张图片" : "请查看这些图片";
 }
 
-function isStandaloneResourceMessage(message: IncomingMessage): boolean {
+function isCommandMessage(message: IncomingMessage): boolean {
+  const text = normalizeFeishuPostText(message.text).trimStart();
+  return text.startsWith("/") || text.startsWith("!");
+}
+
+function isForwardAttachmentSource(message: IncomingMessage): boolean {
   return !message.mergedForwardMessageId
-    && message.text.trim().length === 0
-    && ((message.images?.length ?? 0) > 0 || (message.files?.length ?? 0) > 0);
+    && !message.parentMessageId
+    && !message.contextKey.startsWith("console:")
+    && !isCommandMessage(message)
+    && (message.messageType === "post"
+      || (message.images?.length ?? 0) > 0 || (message.files?.length ?? 0) > 0);
 }
 
 function deduplicateImageReferences(
@@ -9335,7 +9837,8 @@ function isRetryableLlmTurnFailure(message: string): boolean {
   const normalized = message.trim().toLowerCase();
   if (!normalized) return false;
   const permanentFailure = [
-    /auth(?:entication|orization)?\b|unauthorized|forbidden|invalid api key|incorrect api key/u,
+    /\b(?:auth|authenticat\w*|unauthenticat\w*|authoriz\w*|unauthorized|forbidden)\b|invalid api key|incorrect api key/u,
+    /(?:^|\D)(?:401|403)(?:\D|$)/u,
     /insufficient[_ -]?quota|quota (?:exceeded|exhausted)|usage limit|billing|credit balance/u,
     /context (?:length|window)|maximum context|too many tokens|token limit/u,
     /invalid request|bad request|invalid argument|malformed|unsupported|not supported/u,