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

package/dist/proxy/ProxySessionController.js

@@ -4,7 +4,7 @@ import os from "node:os";
 import path from "node:path";
 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, } from "../codex/ThreadWriterProcess.js";
 import { resolveUserPath } from "../config/paths.js";
 import { DEFAULT_GROUP_NAME_FORMAT, } from "../config/schema.js";
@@ -22,6 +22,7 @@ import { errorLogValue } from "../logging/errorLogValue.js";
 import { createTurnViewState, hydrateTurnViewState } from "../presentation/TurnStateReducer.js";
 import { buildTurnGraphRows } from "../presentation/turnGraph.js";
 import { isActiveShellCommandJob, ShellCommandJobManager, } from "../shell/ShellCommandJobManager.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";
@@ -48,11 +49,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 = "已发送停止信号，任务会自动停止。";
@@ -226,9 +228,14 @@ export class ProxySessionController {
     messageQueues = new Map();
     switchGroupOperations = new Set();
     sessionLoads = new Map();
+    settingsOnlySessions = new Set();
     queuedPromptStarts = new Map();
     queuedPromptCards = new Map();
     queuedPromptCardWrites = new Map();
+    settingsOperations = new SessionOperationQueue();
+    // Loads may run inside settingsOperations; never acquire that queue while hydrating.
+    sessionHydrationOperations = new SessionOperationQueue();
+    agentDefaultsOperations = new SessionOperationQueue();
     sessionResets = new Map();
     resetHistoryOperations = new Map();
     remoteTurnHistoryRefreshes = new Map();
@@ -238,9 +245,13 @@ export class ProxySessionController {
     lastSessionListings = new Map();
     threadInitializations = new Map();
     llmRetryingSessions = new Set();
+    planHandoffs = new Map();
     retriedFailureTurnIds = new Set();
     queuedPromptRetryTimers = new Map();
     recoveryRetryTimers = new Map();
+    recoveryRetryStartedAt = new Map();
+    recoveredLiveAttempts = new Set();
+    recoveryClosed = false;
     pendingMergedForwards = new Map();
     pendingResourceForwards = new Map();
     relatedReactionMessageIds = new Map();
@@ -300,7 +311,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 {
@@ -338,7 +349,9 @@ export class ProxySessionController {
             const attachment = await this.waitForForwardAttachment(message.messageId, pendingResourceForward, this.pendingResourceForwards);
             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,
@@ -350,7 +363,7 @@ export class ProxySessionController {
                 }));
                 message = {
                     ...attachment,
-                    text: instruction,
+                    text: sourceText ? referencedMessagePrompt(instruction, sourceText) : instruction,
                     displayText: instruction,
                 };
                 this.relatedReactionMessageIds.set(message.messageId, [resourceMessage.messageId]);
@@ -619,7 +632,12 @@ 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);
@@ -812,7 +830,7 @@ export class ProxySessionController {
                     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") {
@@ -838,9 +856,11 @@ export class ProxySessionController {
                     await this.refreshStatusCardFromAction(scopedAction);
                 }
                 else if (kind === "settings_tab_open") {
+                    const sessionId = String(scopedAction.value.sessionId ?? "");
                     await this.openExecutionSettings(contextKey, executionSettingsTabValue(scopedAction.value.tab), {
-                        sessionId: String(scopedAction.value.sessionId ?? ""),
-                        updateMessageId: scopedAction.messageId,
+                        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") {
@@ -857,12 +877,14 @@ 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 ?? ""),
@@ -887,6 +909,7 @@ export class ProxySessionController {
                     await this.model(contextKey, undefined, {
                         sessionId,
                         updateMessageId: scopedAction.messageId,
+                        modelPage: modelCardPageValue(scopedAction.value.page),
                     });
                 }
                 else if (kind === "reasoning_select") {
@@ -906,7 +929,7 @@ export class ProxySessionController {
                     });
                 }
                 else if (kind === "provider_select" || kind === "provider_model_open") {
-                    await this.openProviderModelSelector(contextKey, String(scopedAction.value.provider ?? ""), permissionModeValue(scopedAction.value.permissionMode), String(scopedAction.value.sessionId ?? ""), requiredCardMessageId(scopedAction.messageId));
+                    await this.openProviderModelSelector(contextKey, String(scopedAction.value.provider ?? ""), 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(contextKey, String(scopedAction.value.provider ?? ""), String(scopedAction.value.model ?? ""), permissionModeValue(scopedAction.value.permissionMode), String(scopedAction.value.sessionId ?? ""), requiredCardMessageId(scopedAction.messageId));
@@ -953,6 +976,7 @@ export class ProxySessionController {
         }
     }
     close() {
+        this.recoveryClosed = true;
         for (const unsubscribe of this.unsubscribe)
             unsubscribe();
         this.unsubscribe.length = 0;
@@ -960,6 +984,7 @@ export class ProxySessionController {
         this.queuedPromptCards.clear();
         this.queuedPromptCardWrites.clear();
         this.sessionResets.clear();
+        this.planHandoffs.clear();
         this.resetHistoryOperations.clear();
         this.remoteTurnHistoryRefreshes.clear();
         this.forkHistoryCursors.clear();
@@ -977,6 +1002,8 @@ export class ProxySessionController {
         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);
@@ -1263,78 +1290,43 @@ export class ProxySessionController {
         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(localSessionId, action, objective) {
         const record = this.requireControlSession(localSessionId);
@@ -1727,14 +1719,21 @@ export class ProxySessionController {
             }
             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();
     }
     async finishPersistedCancellationRequests() {
@@ -1815,22 +1814,36 @@ export class ProxySessionController {
             });
         }
     }
-    async expireStaleTurnAttempt(attempt) {
-        const session = this.store.getSession(attempt.localSessionId);
+    async expireStaleTurnAttempt(attempt, message = "执行中断已超过 10 分钟，未自动恢复。") {
+        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 分钟，未自动恢复。").catch((error) => {
+            await this.outbound.interruptTurnForRecovery(session.localSessionId, attempt.contextKey, oldCardTurnId, message).catch((error) => {
                 this.logger.warn({ error, attemptId: attempt.attemptId, turnId: oldCardTurnId }, "Failed to close an expired interrupted thinking card.");
             });
         }
-        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) => {
@@ -1838,6 +1851,47 @@ export class ProxySessionController {
             });
         }
     }
+    async handleRecoveryError(attemptId, error, activeTurnId) {
+        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 } : 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);
+    }
     persistActiveTurnHeartbeats() {
         for (const attempt of this.store.listIncompleteTurnAttempts()) {
             if (!attempt.turnId)
@@ -1851,6 +1905,8 @@ export class ProxySessionController {
         }
     }
     async recoverTurnAttempt(attempt, announce = true) {
+        if (this.recoveryClosed)
+            return;
         const session = this.store.getSession(attempt.localSessionId);
         if (!session || session.status === "closed") {
             this.store.updateTurnAttempt(attempt.attemptId, { status: "interrupted" });
@@ -1879,9 +1935,9 @@ export class ProxySessionController {
                 remote = await runtime.readRemoteSession(session.remoteSessionId);
             }
             catch (error) {
-                if (error instanceof CodexVersionError)
+                // A failed activity check is not proof of interruption. Do not replay a prompt blindly.
+                if (sourceTurnId || !isUnmaterializedCodexThreadError(error))
                     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.");
             }
         }
         const remoteTurnBelongsToAttempt = remoteTurnMatchesAttempt(remote, attempt);
@@ -1927,14 +1983,22 @@ export class ProxySessionController {
             this.scheduleRecoveryRetry(attempt.attemptId, synchronized.activeTurnId);
     }
     scheduleRecoveryRetry(attemptId, activeTurnId) {
-        if (this.recoveryRetryTimers.has(attemptId))
+        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))
+            if (!attempt || !isIncompleteTurnAttemptStatus(attempt.status)) {
+                this.recoveryRetryStartedAt.delete(attemptId);
+                this.recoveredLiveAttempts.delete(attemptId);
                 return;
+            }
             const retry = async () => {
+                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);
@@ -1942,6 +2006,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;
                         }
@@ -1952,16 +2018,38 @@ export class ProxySessionController {
                     }
                 }
                 await this.recoverTurnAttempt(recoveryAttempt, false);
+                if (!this.recoveryRetryTimers.has(attemptId))
+                    this.recoveryRetryStartedAt.delete(attemptId);
             };
             void retry().catch((error) => {
-                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) => {
+                this.logger.error({ error, attemptId }, "Failed to finalize task recovery.");
             });
         }, 5_000);
         timer.unref?.();
         this.recoveryRetryTimers.set(attemptId, timer);
     }
     async reattachActiveRecoveredTurn(attempt, session, turnId, replyTarget) {
+        // 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(session.localSessionId, attempt.contextKey, oldCardTurnId, "Agent Bot 已重启，执行仍在继续；进度已转移到新的思考卡片。");
@@ -1979,17 +2067,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.recoveryRetryStartedAt.delete(attempt.attemptId);
+        if (synchronized.activeTurnId) {
+            this.recoveredLiveAttempts.add(attempt.attemptId);
             this.scheduleRecoveryRetry(attempt.attemptId, synchronized.activeTurnId);
+        }
     }
     async continueInterruptedAttempt(attempt, session, sourceTurnId, replyTarget) {
         const oldCardTurnId = attempt.pendingTurnId ?? sourceTurnId;
@@ -2007,7 +2090,7 @@ 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, recoveryText, replyTarget, attempt.localImagePaths, {
             attemptId: attempt.attemptId,
@@ -2046,7 +2129,7 @@ export class ProxySessionController {
         await this.promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths, displayPrompt);
     }
     async promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths, displayPrompt) {
-        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,
@@ -2067,7 +2150,7 @@ export class ProxySessionController {
         }
         let loaded;
         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)) {
@@ -3043,6 +3126,22 @@ export class ProxySessionController {
         };
     }
     async startTurn(loaded, text, replyTarget, localImagePaths, options = {}) {
+        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);
+        });
+    }
+    async startTurnNow(loaded, text, replyTarget, localImagePaths, options = {}) {
         const currentRecord = this.store.getSession(loaded.record.localSessionId);
         const title = currentRecord?.title ?? normalizeTaskTitle(options.displayPrompt ?? text);
         if (!currentRecord?.title && title)
@@ -3088,7 +3187,13 @@ export class ProxySessionController {
                 }
                 this.store.updateTurnAttempt(attemptId, { pendingTurnId: pendingTurnId ?? null });
                 try {
-                    turnId = await loaded.runtime.startTurn(loaded.record.localSessionId, runtimePrompt(runtimeText, localImagePaths));
+                    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, options.approvedPlanTurnId
+                        ? { text: runtimeText, collaborationMode: "default" }
+                        : runtimePrompt(runtimeText, localImagePaths));
                     break;
                 }
                 catch (error) {
@@ -3503,22 +3608,44 @@ export class ProxySessionController {
             this.store.setBoundProjectCwd(groupContextKey, boundProjectCwd);
         return { chatId: group.chatId, contextKey: groupContextKey, name: group.name };
     }
-    async loadSession(record) {
+    async loadSession(record, forSettings = false) {
         const agent = this.ensureAgent(record.agentName);
         const runtime = this.runtimes.forAgent(record.agentName);
         const existing = runtime.getSession(record.localSessionId);
-        if (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(record.localSessionId, record.contextKey, record.title, record.cwd, this.agentLabel(record.agentName), record.model, record.modelProvider);
-        const loading = (async () => {
+        const loading = this.sessionHydrationOperations.run(record.localSessionId, async () => {
+            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);
@@ -3528,45 +3655,32 @@ export class ProxySessionController {
                 }
             }
             const permissionMode = record.permissionMode ?? "auto";
-            if (record.remoteSessionId)
+            const prepare = forSettings && record.remoteSessionId && runtime.prepareSessionForSettings;
+            if (record.remoteSessionId && !prepare)
                 await this.assertSessionTurnOwnership(record, runtime);
             let session;
             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 {
@@ -3581,20 +3695,24 @@ 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);
         }
     }
     persistRuntimeSession(record, session, status) {
@@ -3614,6 +3732,11 @@ export class ProxySessionController {
     }
     async handleRuntimeEvent(event) {
         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)) {
@@ -3627,6 +3750,15 @@ export class ProxySessionController {
                 this.store.saveTurnParent(event.turnId, event.sessionId, this.completedParentTurnId(source));
             }
         }
+        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;
@@ -3652,6 +3784,13 @@ export class ProxySessionController {
             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");
             this.store.updateRuntimeSession(event.sessionId, {
                 lastTurnId: event.turnId,
@@ -3663,7 +3802,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
@@ -3698,12 +3837,87 @@ 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);
             }
         }
         if (presentationError)
             throw presentationError;
     }
+    async continueApprovedPlan(event, attempt) {
+        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);
+        }
+    }
     async retryFailedLlmTurn(event, attempt) {
         const retryNumber = attempt.retryCount;
         const session = this.store.getSession(event.sessionId);
@@ -3737,7 +3951,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), replyTarget, attempt.localImagePaths, {
                 attemptId: attempt.attemptId,
                 messageId: attempt.messageId,
@@ -3774,6 +3988,8 @@ export class ProxySessionController {
         });
     }
     scheduleQueuedPromptRetry(sessionId) {
+        if (this.store.getPendingProviderSettings(sessionId)?.error)
+            return;
         if (this.queuedPromptRetryTimers.has(sessionId))
             return;
         if (this.store.countQueuedPrompts(sessionId) === 0)
@@ -3789,6 +4005,11 @@ export class ProxySessionController {
         this.queuedPromptRetryTimers.set(sessionId, timer);
     }
     async startNextQueuedPromptIfIdle(sessionId) {
+        return this.settingsOperations.run(sessionId, () => this.startNextQueuedPromptIfIdleNow(sessionId));
+    }
+    async startNextQueuedPromptIfIdleNow(sessionId) {
+        if (this.planHandoffs.has(sessionId) || this.sessionResets.has(sessionId))
+            return;
         if (this.store.countQueuedPrompts(sessionId) === 0)
             return;
         const baseRecord = this.store.getSession(sessionId);
@@ -3796,20 +4017,23 @@ export class ProxySessionController {
             return;
         let prompt;
         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(loaded, prompt.text, prompt.replyMessageId ? { messageId: prompt.replyMessageId, replyInThread: true } : undefined, prompt.localImagePaths, { messageId: prompt.messageId, displayPrompt: prompt.displayPrompt });
+            const turnId = await this.startTurnNow(loaded, prompt.text, prompt.replyMessageId ? { messageId: prompt.replyMessageId, replyInThread: true } : undefined, prompt.localImagePaths, { messageId: prompt.messageId, displayPrompt: prompt.displayPrompt });
             if (prompt.messageId)
                 await this.bindMessageReactionToTurn(prompt.messageId, sessionId, turnId);
         }
@@ -3868,6 +4092,7 @@ export class ProxySessionController {
         });
         const pending = {
             contextKey: message.contextKey,
+            userId: message.userId,
             attachmentPromise,
             resolveAttachment,
         };
@@ -3875,7 +4100,7 @@ export class ProxySessionController {
         return pending;
     }
     reserveForwardAttachment(message) {
-        if (!message.parentMessageId)
+        if (!message.parentMessageId || isCommandMessage(message))
             return undefined;
         const candidates = [
             { sourceKind: "merged_forward", registry: this.pendingMergedForwards },
@@ -3883,7 +4108,8 @@ export class ProxySessionController {
         ];
         for (const candidate of candidates) {
             const pending = candidate.registry.get(message.parentMessageId);
-            if (!pending || pending.contextKey !== message.contextKey || pending.attachmentMessageId)
+            if (!pending || pending.contextKey !== message.contextKey
+                || pending.userId !== message.userId || pending.attachmentMessageId)
                 continue;
             pending.attachmentMessageId = message.messageId;
             return {
@@ -3908,17 +4134,20 @@ export class ProxySessionController {
         return true;
     }
     async waitForForwardAttachment(messageId, pending, registry) {
-        let timer;
-        const timeout = new Promise((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);
             }
@@ -3979,6 +4208,7 @@ export class ProxySessionController {
         await this.cancelSession(record);
     }
     async cancelSession(record) {
+        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) {
@@ -4055,6 +4285,7 @@ export class ProxySessionController {
         });
     }
     async runSessionReset(sessionId, operation) {
+        this.planHandoffs.delete(sessionId);
         const previous = this.sessionResets.get(sessionId) ?? Promise.resolve();
         const reset = previous.catch(() => undefined).then(operation);
         this.sessionResets.set(sessionId, reset);
@@ -4199,6 +4430,14 @@ export class ProxySessionController {
         await loaded.runtime.respondToApproval(sessionId, requestId, decision);
     }
     async openExecutionSettings(contextKey, activeTab, options = {}) {
+        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 }));
+    }
+    async openExecutionSettingsNow(contextKey, activeTab, options = {}) {
         const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent);
         const record = options.sessionId
             ? this.requireSession(contextKey, options.sessionId)
@@ -4217,22 +4456,31 @@ 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)
-                ? loaded.session.reasoningEffort
-                : currentModel?.defaultReasoningEffort ?? loaded.session.reasoningEffort;
+            const currentEffort = currentModel?.supportedReasoningEfforts.some((option) => option.value === selected.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,
@@ -4248,7 +4496,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);
@@ -4266,35 +4517,40 @@ export class ProxySessionController {
         await this.openExecutionSettings(contextKey, "agent");
     }
     async selectProvider(contextKey, modelProvider, options = {}) {
+        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 }));
+    }
+    async selectProviderNow(contextKey, modelProvider, options = {}) {
         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);
     }
     async openProviderSelector(contextKey, options = {}) {
         await this.openExecutionSettings(contextKey, "provider", options);
     }
-    async openProviderModelSelector(contextKey, modelProvider, permissionMode, sessionId, updateMessageId) {
-        const loaded = await this.loadSession(this.requireSession(contextKey, sessionId));
+    async openProviderModelSelector(contextKey, modelProvider, permissionMode, sessionId, updateMessageId, modelPage) {
+        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,
@@ -4305,7 +4561,7 @@ export class ProxySessionController {
         await this.outbound.updateInteractiveCard(contextKey, updateMessageId, card);
     }
     async openProviderReasoningSelector(contextKey, modelProvider, model, permissionMode, sessionId, updateMessageId) {
-        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);
@@ -4331,7 +4587,7 @@ export class ProxySessionController {
         await this.outbound.updateInteractiveCard(contextKey, updateMessageId, card);
     }
     async openProviderPermissionSelector(contextKey, modelProvider, model, effort, permissionMode, sessionId, updateMessageId) {
-        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, updateMessageId, this.cardRenderer.renderPermissionSelector({
             sessionId,
@@ -4343,20 +4599,47 @@ export class ProxySessionController {
         }));
     }
     async applyProviderSettings(contextKey, settings, options = {}, announceStart = true) {
+        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));
+    }
+    async applyProviderSettingsNow(contextKey, settings, options = {}, announceStart = true) {
         const record = options.sessionId
             ? this.requireSession(contextKey, options.sessionId)
             : this.requireCurrentSession(contextKey);
-        if (announceStart) {
+        const loaded = await this.loadSession(record, true);
+        const warning = await this.assertProviderModelSettings(loaded, settings.provider, settings.model, settings.effort);
+        const next = {
+            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;
+        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) => {
+                        this.logger.warn({ error: presentationError, sessionId: record.localSessionId }, "Failed to refresh rejected Provider selection.");
+                    });
+                }
+            }
+            throw error;
         }
-        const loaded = await this.loadSession(record);
-        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 notice = [
             `Provider 已切换为 ${cardCode(session.modelProvider ?? settings.provider)}`,
             `模型 ${cardCode(session.model ?? settings.model)}`,
@@ -4365,7 +4648,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,
@@ -4376,16 +4659,23 @@ export class ProxySessionController {
         }
     }
     async changeProviderSettings(loaded, settings) {
+        return this.sessionHydrationOperations.run(loaded.record.localSessionId, () => this.changeProviderSettingsNow(loaded, settings));
+    }
+    async changeProviderSettingsNow(loaded, settings) {
         if (!loaded.runtime.setExecutionSettings)
             throw new Error("当前运行时不支持 Provider 设置。");
-        const persist = async (candidate) => {
+        loaded.session = loaded.runtime.getSession(loaded.record.localSessionId) ?? loaded.session;
+        const remoteSessionId = loaded.session.remoteSessionId;
+        const persist = (candidate) => 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,
@@ -4397,11 +4687,147 @@ 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;
     }
+    async reconcilePreparedSettingsSession(loaded) {
+        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);
+        }
+    }
+    providerSettingsRestored(loaded, previous, error) {
+        const restored = loaded.runtime.getSession(loaded.record.localSessionId);
+        const saved = this.store.getSession(loaded.record.localSessionId);
+        const keys = ["remoteSessionId", "modelProvider", "model", "reasoningEffort", "permissionMode"];
+        return error instanceof ProviderSwitchError && error.previousSettingsRestored
+            && Boolean(restored && saved && keys.every((key) => restored[key] === previous[key] && saved[key] === previous[key]));
+    }
+    pendingProviderNotice(pending) {
+        const target = `Provider ${cardCode(pending.settings.modelProvider)}，模型 ${cardCode(pending.settings.model)}`;
+        return pending.error
+            ? `切换失败：${pending.error}。目标为 ${target}；后续轮次已暂停，请重新选择 Provider 或模型重试。`
+            : `待生效：当前轮次不变，结束后切换到 ${target}。可继续选择模型，以最后选择为准。`;
+    }
+    async savePendingProviderSelection(loaded, settings, contextKey, options, activeTab) {
+        const previous = this.store.getPendingProviderSettings(loaded.record.localSessionId);
+        const pending = {
+            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) => {
+                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.
+    async applyPendingProviderSettings(loaded) {
+        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;
+        let failure;
+        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;
+    }
+    async applyPendingProviderWhenIdle(sessionId) {
+        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) => {
+                        this.logger.warn({ error: notificationError, sessionId }, "Failed to notify Provider recovery failure.");
+                    });
+                }
+            }
+        });
+    }
     async assertProviderModelSettings(loaded, modelProvider, model, effort) {
         await this.assertModelProvider(loaded, modelProvider);
         const { models, warning } = await this.modelOptions(loaded.runtime, modelProvider, model);
@@ -4438,36 +4864,51 @@ export class ProxySessionController {
         return providers;
     }
     async model(contextKey, model, options = {}) {
+        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 }));
+    }
+    async modelNow(contextKey, model, options = {}) {
         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 的默认设置，从下一次请求生效。`,
@@ -4607,6 +5048,7 @@ export class ProxySessionController {
         const created = await this.shellCommandJobs.createJob({ contextKey, sourceMessageId, command, cwd });
         let cardMessageId;
         const initialState = {
+            terminalUrl: this.lifecycle?.terminalUrl?.(created.id),
             jobId: created.id,
             contextKey,
             command,
@@ -4629,7 +5071,7 @@ export class ProxySessionController {
             if (cardMessageId) {
                 try {
                     const failed = await this.shellCommandJobs.readJob(created.id);
-                    await this.outbound.updateInteractiveCard(contextKey, cardMessageId, this.cardRenderer.renderShellCommandCard(shellCommandJobCardView(failed)));
+                    await this.outbound.updateInteractiveCard(contextKey, cardMessageId, this.cardRenderer.renderShellCommandCard({ ...shellCommandJobCardView(failed), terminalUrl: this.lifecycle?.terminalUrl?.(failed.id) }));
                     await this.shellCommandJobs.markPresented(created.id);
                 }
                 catch (cardError) {
@@ -4680,7 +5122,7 @@ export class ProxySessionController {
         if (!job.cardMessageId || this.shellCommandJobMonitors.has(job.id))
             return;
         const scheduler = new CardUpdateScheduler({
-            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 }, "Failed to update a background shell command card."),
         });
@@ -4829,16 +5271,25 @@ export class ProxySessionController {
         });
     }
     async thinking(contextKey, effort, options = {}) {
+        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 }));
+    }
+    async thinkingNow(contextKey, effort, options = {}) {
         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("当前运行时没有可配置思考强度的模型。");
@@ -4850,11 +5301,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 的默认设置，从下一次请求生效。`,
@@ -4864,20 +5321,32 @@ export class ProxySessionController {
         await this.outbound.sendText(contextKey, `思考强度已切换为 ${effort}，并已保存为 ${loaded.record.agentName} Agent 的默认设置，从下一次请求生效。`);
     }
     async permissions(contextKey, mode, options = {}) {
+        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 }));
+    }
+    async permissionsNow(contextKey, mode, options = {}) {
         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"
@@ -4918,8 +5387,9 @@ export class ProxySessionController {
         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;
@@ -4952,7 +5422,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;
+            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)), details);
         // Viewing external work must not create a task, a chat binding or a pending final reply.
         this.store.previews.seed(state);
@@ -5489,20 +5959,29 @@ 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 = entry.current ? [] : [bindCardAction({
-                    text: showStop ? "Stop" : "Switch",
-                    type: showStop ? "danger" : "default",
+            const stopAction = entry.active ? bindCardAction({
+                text: "Stop",
+                type: "danger",
+                value: {
+                    action: "session_stop",
+                    sessionId: entry.reference,
+                    ...(searchTerm ? { searchTerm } : {}),
+                    page: String(page),
+                    contextKey,
+                },
+            }) : undefined;
+            const actions = [];
+            if (!entry.current && entry.status !== "外部执行中")
+                actions.push(bindCardAction({
+                    text: "Switch",
                     value: {
-                        action: showStop ? "session_stop" : "session_switch",
+                        action: "session_switch",
                         sessionId: entry.reference,
                         ...(searchTerm ? { searchTerm } : {}),
                         page: String(page),
                         contextKey,
                     },
-                })];
+                }));
             actions.push(bindCardAction({
                 text: "SwitchGroup",
                 value: {
@@ -5568,16 +6047,17 @@ export class ProxySessionController {
                     contextKey,
                 },
             }));
-            actions.push(bindCardAction({
-                text: "Archive",
-                value: {
-                    action: "session_archive",
-                    sessionId: entry.reference,
-                    ...(searchTerm ? { searchTerm } : {}),
-                    page: String(page),
-                    contextKey,
-                },
-            }));
+            if (!entry.active)
+                actions.push(bindCardAction({
+                    text: "Archive",
+                    value: {
+                        action: "session_archive",
+                        sessionId: entry.reference,
+                        ...(searchTerm ? { searchTerm } : {}),
+                        page: String(page),
+                        contextKey,
+                    },
+                }));
             const title = truncateText(entry.title.replace(/\s+/gu, " ").trim() || "未命名任务", 56);
             const lastUserPrompt = sessionPromptPreview(entry.lastUserPrompt);
             return {
@@ -5590,6 +6070,7 @@ export class ProxySessionController {
                         `**最新 Prompt**：${cardText(lastUserPrompt)}`,
                         `<font color='grey'>最近更新：${cardText(entry.updatedLabel)}</font>`,
                     ],
+                    stopAction,
                     actions,
                     current: entry.current,
                 },
@@ -5616,7 +6097,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({
                     text: "Previous",
@@ -5690,7 +6171,6 @@ export class ProxySessionController {
             : undefined;
         await this.listSessions(action.contextKey, searchTerm, {
             updateMessageId: action.messageId,
-            forceSwitchTaskId: options.forceSwitchTaskId,
             page: options.page ?? parseSessionPage(action.value.page),
         });
     }
@@ -5845,7 +6325,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("任务正在执行，无法归档。请先停止任务或等待本轮完成。");
         }
@@ -5853,7 +6333,11 @@ export class ProxySessionController {
             throw new Error(`Agent ${agentName} 不支持归档任务。`);
         }
         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);
@@ -5991,6 +6475,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"
@@ -6337,6 +6822,12 @@ export class ProxySessionController {
         return agent;
     }
     async persistAgentExecutionDefaults(localSessionId, candidate) {
+        const record = this.store.getSession(localSessionId);
+        if (!record)
+            throw new Error(`找不到任务：${localSessionId}`);
+        return this.agentDefaultsOperations.run(record.agentName, () => this.persistAgentExecutionDefaultsNow(localSessionId, candidate));
+    }
+    async persistAgentExecutionDefaultsNow(localSessionId, candidate) {
         const record = this.store.getSession(localSessionId);
         if (!record)
             throw new Error(`找不到任务：${localSessionId}`);
@@ -7261,6 +7752,14 @@ function executionSettingsTabValue(value) {
         return value;
     throw new Error("设置卡片的 tab 无效，请重新发送设置命令。");
 }
+function modelCardPageValue(value) {
+    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) {
     const page = Number(value);
     if (!Number.isSafeInteger(page) || page < 0)
@@ -7637,10 +8136,17 @@ function defaultResourcePromptFromCounts(imageCount, fileCount) {
         return fileCount === 1 ? "请查看这个文件" : "请查看这些文件";
     return imageCount === 1 ? "请查看这张图片" : "请查看这些图片";
 }
-function isStandaloneResourceMessage(message) {
+function isCommandMessage(message) {
+    const text = normalizeFeishuPostText(message.text).trimStart();
+    return text.startsWith("/") || text.startsWith("!");
+}
+function isForwardAttachmentSource(message) {
     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(images) {
     const seen = new Set();
@@ -7707,7 +8213,8 @@ function isRetryableLlmTurnFailure(message) {
     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,