@keyou007/agent-bot 0.1.20-alpha.0 → 0.1.20

package/dist/proxy/ProxySessionController.js

@@ -3,6 +3,8 @@ import { promises as fs } from "node:fs";
 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 { SystemThreadWriterProcessController, } from "../codex/ThreadWriterProcess.js";
 import { resolveUserPath } from "../config/paths.js";
 import { DEFAULT_GROUP_NAME_FORMAT, } from "../config/schema.js";
@@ -50,6 +52,22 @@ const FORWARD_ATTACHMENT_WINDOW_MS = 800;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
 const TURN_STOP_REQUESTED_MESSAGE = "已发送停止信号，任务会自动停止。";
+const TURN_RESET_STARTED_MESSAGE = "Reset 正在进行，请稍后。期间发送的消息会自动排队。";
+const CREATE_TASK_STARTED_MESSAGE = "正在创建任务，请稍后。";
+const CREATE_GROUP_STARTED_MESSAGE = "正在创建群聊和任务，请稍后。";
+const FORK_TASK_STARTED_MESSAGE = "正在创建分支任务，请稍后。";
+const FORK_GROUP_STARTED_MESSAGE = "正在创建分支群聊，请稍后。";
+const LIST_SESSIONS_STARTED_MESSAGE = "正在读取任务列表，请稍后。";
+const LIST_TURNS_STARTED_MESSAGE = "正在读取历史轮次，请稍后。";
+const SWITCH_TASK_STARTED_MESSAGE = "正在切换任务，请稍后。";
+const STATUS_STARTED_MESSAGE = "正在读取任务状态，请稍后。";
+const GOAL_STARTED_MESSAGE = "正在处理 Goal，请稍后。";
+const ARCHIVE_TASK_STARTED_MESSAGE = "正在归档任务，请稍后。";
+const DISMISS_GROUP_STARTED_MESSAGE = "正在归档任务并解散群聊，请稍后。";
+const SEND_FILE_STARTED_MESSAGE = "正在发送文件，请稍后。";
+const CHANGE_TITLE_STARTED_MESSAGE = "正在修改任务标题，请稍后。";
+const STOP_TASK_STARTED_MESSAGE = "正在停止任务，请稍后。";
+const CLOSE_WRITER_STARTED_MESSAGE = "正在检查并关闭占用进程，请稍后。";
 const REMOTE_SESSION_REFERENCE_PREFIX = "agent-runtime:";
 const WINDOWS_DRIVES_DIRECTORY = "agentbot://windows-drives";
 const IMAGE_FILE_EXTENSIONS = new Set([
@@ -205,6 +223,8 @@ export class ProxySessionController {
     sessionResets = new Map();
     resetHistoryOperations = new Map();
     remoteTurnHistoryRefreshes = new Map();
+    turnHistoryHydrations = new Map();
+    forkHistoryCursors = new Map();
     lastSessionListings = new Map();
     threadInitializations = new Map();
     llmRetryingSessions = new Set();
@@ -282,6 +302,7 @@ export class ProxySessionController {
         catch (error) {
             this.logger.warn({ error, messageId: message.messageId, contextKey: message.contextKey }, "Failed to acknowledge the incoming Feishu message with a reaction.");
         }
+        await this.waitForCurrentSessionReset(message.contextKey);
         if (attachmentReservation && this.completeForwardAttachment(message, attachmentReservation)) {
             this.store.audit(message.contextKey, `${attachmentReservation.sourceKind}_attachment_coalesced`, {
                 messageId: message.messageId,
@@ -478,10 +499,11 @@ export class ProxySessionController {
                 command: command.type,
             }, "Processing Agent Bot command.");
         }
-        // Operational and read-only commands must remain available even if a prompt operation is slow.
+        // Operational and read-only commands bypass the prompt queue, but still wait for a Reset binding change.
         if (isQueueIndependentCommand(command)) {
             await this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
                 try {
+                    await this.waitForCurrentSessionReset(message.contextKey);
                     if (command.type === "prompt")
                         await this.ensureThreadFork(message);
                     await this.execute(message.contextKey, command, message.messageId, replyTarget, localImagePaths, message.userId, message);
@@ -502,45 +524,48 @@ export class ProxySessionController {
             return;
         }
         const previous = this.messageQueues.get(message.contextKey) ?? Promise.resolve();
-        const next = previous.catch(() => undefined).then(() => this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
-            try {
-                let executableCommand = command;
-                let executableImagePaths = localImagePaths;
-                let executableMessage = message;
-                let injectedRootMessageId;
-                if (command.type === "prompt") {
-                    await this.ensureThreadFork(message);
-                    const prepared = await this.prepareTopicRootPrompt(message, command.text, localImagePaths);
-                    executableCommand = { ...command, text: prepared.text };
-                    executableImagePaths = prepared.localImagePaths;
-                    executableMessage = { ...message, displayText: prepared.displayPrompt };
-                    injectedRootMessageId = prepared.injectedRootMessageId;
-                }
-                await this.execute(message.contextKey, executableCommand, message.messageId, replyTarget, executableImagePaths, message.userId, executableMessage);
-                if (injectedRootMessageId) {
-                    const current = this.currentSession(message.contextKey);
-                    if (current) {
-                        this.store.audit(message.contextKey, "topic_root_injected", {
-                            localSessionId: current.localSessionId,
-                            rootMessageId: injectedRootMessageId,
-                            promptMessageId: message.messageId,
-                        });
+        const next = previous.catch(() => undefined).then(async () => {
+            await this.waitForCurrentSessionReset(message.contextKey);
+            return this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
+                try {
+                    let executableCommand = command;
+                    let executableImagePaths = localImagePaths;
+                    let executableMessage = message;
+                    let injectedRootMessageId;
+                    if (command.type === "prompt") {
+                        await this.ensureThreadFork(message);
+                        const prepared = await this.prepareTopicRootPrompt(message, command.text, localImagePaths);
+                        executableCommand = { ...command, text: prepared.text };
+                        executableImagePaths = prepared.localImagePaths;
+                        executableMessage = { ...message, displayText: prepared.displayPrompt };
+                        injectedRootMessageId = prepared.injectedRootMessageId;
+                    }
+                    await this.execute(message.contextKey, executableCommand, message.messageId, replyTarget, executableImagePaths, message.userId, executableMessage);
+                    if (injectedRootMessageId) {
+                        const current = this.currentSession(message.contextKey);
+                        if (current) {
+                            this.store.audit(message.contextKey, "topic_root_injected", {
+                                localSessionId: current.localSessionId,
+                                rootMessageId: injectedRootMessageId,
+                                promptMessageId: message.messageId,
+                            });
+                        }
+                    }
+                    if (!commandDefersReactionFinalization(command)) {
+                        await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
                     }
                 }
-                if (!commandDefersReactionFinalization(command)) {
-                    await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+                catch (error) {
+                    await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
+                    await this.sendError(message.contextKey, error, {
+                        requestId: message.messageId,
+                        messageId: message.messageId,
+                        command: command.type,
+                        phase: "command_execute",
+                    });
                 }
-            }
-            catch (error) {
-                await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-                await this.sendError(message.contextKey, error, {
-                    requestId: message.messageId,
-                    messageId: message.messageId,
-                    command: command.type,
-                    phase: "command_execute",
-                });
-            }
-        }));
+            });
+        });
         this.messageQueues.set(message.contextKey, next);
         await next;
         if (this.messageQueues.get(message.contextKey) === next)
@@ -653,6 +678,7 @@ export class ProxySessionController {
                 else if (kind === "directory_send_file") {
                     const filePath = directoryFileActionPath(scopedAction.value.filePath);
                     await this.assertSendableFile(filePath);
+                    await this.outbound.sendText(contextKey, SEND_FILE_STARTED_MESSAGE);
                     await this.outbound.sendFile(contextKey, filePath);
                 }
                 else if (kind === "directory_new_folder_prompt") {
@@ -704,11 +730,13 @@ export class ProxySessionController {
                 }
                 else if (kind === "session_new") {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
+                    await this.outbound.sendText(contextKey, CREATE_TASK_STARTED_MESSAGE);
                     await this.createProjectSessionFromReference(contextKey, sessionId);
                     await this.refreshSessionsCardFromAction(scopedAction, { page: 0 });
                 }
                 else if (kind === "session_new_group") {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
+                    await this.outbound.sendText(contextKey, CREATE_GROUP_STARTED_MESSAGE);
                     await this.createFeishuGroupFromReference(contextKey, sessionId, scopedAction.userId);
                     await this.refreshSessionsCardFromAction(scopedAction);
                 }
@@ -726,10 +754,12 @@ export class ProxySessionController {
                 }
                 else if (kind === "group_dismiss_confirm") {
                     this.assertDismissGroupRequester(scopedAction);
+                    await this.outbound.sendText(contextKey, DISMISS_GROUP_STARTED_MESSAGE);
                     await this.dismissGroupAndArchiveTask(contextKey, String(scopedAction.value.sessionId ?? ""), "command");
                 }
                 else if (kind === "session_stop") {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
+                    await this.outbound.sendText(contextKey, STOP_TASK_STARTED_MESSAGE);
                     await this.stopSessionReference(contextKey, sessionId);
                     if (scopedAction.value.cardView === "status")
                         await this.refreshStatusCardFromAction(scopedAction, sessionId);
@@ -737,6 +767,7 @@ export class ProxySessionController {
                         await this.refreshSessionsCardFromAction(scopedAction, { forceSwitchTaskId: sessionId });
                 }
                 else if (kind === "session_status") {
+                    await this.outbound.sendText(contextKey, STATUS_STARTED_MESSAGE);
                     await this.status(contextKey, String(scopedAction.value.sessionId ?? ""));
                 }
                 else if (kind === "session_status_refresh") {
@@ -867,6 +898,8 @@ export class ProxySessionController {
         this.sessionResets.clear();
         this.resetHistoryOperations.clear();
         this.remoteTurnHistoryRefreshes.clear();
+        this.forkHistoryCursors.clear();
+        this.turnHistoryHydrations.clear();
         for (const pending of this.pendingMergedForwards.values())
             pending.resolveAttachment(undefined);
         this.pendingMergedForwards.clear();
@@ -930,9 +963,11 @@ export class ProxySessionController {
             const runtime = this.runtimes.forAgent(record.agentName);
             if (runtime.readRemoteSession) {
                 try {
-                    remote = await runtime.readRemoteSession(record.remoteSessionId);
+                    remote = await runtime.readRemoteSession(record.remoteSessionId, "latest-full");
                 }
                 catch (error) {
+                    if (error instanceof CodexVersionError)
+                        throw error;
                     this.logger.warn({ error, sessionId: record.localSessionId }, "Failed to inspect App Server task status for CLI.");
                 }
             }
@@ -1155,10 +1190,14 @@ export class ProxySessionController {
     }
     async controlTaskSettings(localSessionId, setting, value) {
         const record = this.requireControlSession(localSessionId);
-        const loaded = await this.loadSession(record);
         if (setting && !value?.trim())
             throw new Error(`task ${setting} requires a value.`);
         const nextValue = value?.trim();
+        if (setting === "provider" && 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();
@@ -1171,20 +1210,12 @@ export class ProxySessionController {
                 : model.defaultReasoningEffort ?? model.supportedReasoningEfforts[0]?.value;
             if (!effort)
                 throw new Error(`Model ${model.id} has no reasoning effort available for a Provider change.`);
-            if (!loaded.runtime.setExecutionSettings)
-                throw new Error("The current runtime does not support Provider settings.");
-            const updated = await loaded.runtime.setExecutionSettings(record.localSessionId, {
+            await this.changeProviderSettings(loaded, {
                 modelProvider: nextValue,
                 model: model.id,
                 reasoningEffort: effort,
                 permissionMode: loaded.session.permissionMode,
             });
-            this.store.updateRuntimeSession(record.localSessionId, {
-                modelProvider: updated.modelProvider ?? nextValue,
-                model: updated.model ?? model.id,
-                reasoningEffort: updated.reasoningEffort ?? effort,
-                permissionMode: updated.permissionMode,
-            });
         }
         else if (setting === "model" && nextValue) {
             const models = await loaded.runtime.listModels();
@@ -1222,13 +1253,13 @@ export class ProxySessionController {
             this.store.updateRuntimeSession(record.localSessionId, { permissionMode: nextValue });
         }
         const session = this.store.getSession(record.localSessionId) ?? record;
-        if (setting)
+        if (setting && setting !== "provider")
             await this.persistAgentExecutionDefaults(session.localSessionId);
         const models = await loaded.runtime.listModels();
         const currentModel = models.find((candidate) => candidate.id === session.model)
             ?? models.find((candidate) => candidate.isDefault);
         const providers = loaded.runtime.listModelProviders
-            ? await loaded.runtime.listModelProviders()
+            ? await this.modelProviderOptions(loaded)
             : [];
         return {
             session,
@@ -1271,17 +1302,18 @@ export class ProxySessionController {
             }),
         };
     }
-    controlListTaskTurns(localSessionId) {
+    async controlListTaskTurns(localSessionId) {
         const session = this.requireControlSession(localSessionId);
         if (!session.remoteSessionId || !this.isCodexSession(session)) {
             throw new Error("The task is not an App Server task that can be reset.");
         }
-        const rows = this.store.listTaskTurnGraph(session.localSessionId);
+        await this.hydrateTaskTurnHistory(session);
+        const rows = this.store.listTaskTurnGraphIndex(session.localSessionId);
         const graph = buildTurnGraphRows(rows.map((turn) => ({ turnId: turn.turnId, parentTurnId: turn.parentTurnId })));
         return {
             session,
             turns: rows.flatMap((turn, index) => {
-                const snapshot = turnViewSnapshot(turn.snapshot);
+                const snapshot = this.store.getTurnPromptSummary(turn.turnId);
                 if (!snapshot)
                     return [];
                 return [{
@@ -1299,16 +1331,10 @@ export class ProxySessionController {
     async controlResetTaskToTurn(localSessionId, turnId) {
         const record = this.requireControlSession(localSessionId);
         const contextKey = this.controlSessionContextKey(record);
-        const previous = this.sessionResets.get(record.localSessionId) ?? Promise.resolve();
-        const reset = previous.catch(() => undefined).then(() => this.performSessionReset(contextKey, record, turnId, false));
-        this.sessionResets.set(record.localSessionId, reset);
-        try {
-            await reset;
-        }
-        finally {
-            if (this.sessionResets.get(record.localSessionId) === reset)
-                this.sessionResets.delete(record.localSessionId);
-        }
+        await this.runSessionReset(record.localSessionId, async () => {
+            await this.outbound.sendText(contextKey, TURN_RESET_STARTED_MESSAGE);
+            await this.performSessionReset(contextKey, record, turnId, false);
+        });
         return this.store.getSession(record.localSessionId) ?? record;
     }
     controlTaskMute(localSessionId, enabled) {
@@ -1438,6 +1464,7 @@ export class ProxySessionController {
                 if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "app-server") {
                     throw new Error("/new --nodir 仅支持 App Server Agent。");
                 }
+                await this.outbound.sendText(contextKey, CREATE_TASK_STARTED_MESSAGE);
                 await this.createSession(contextKey, context.defaultAgent, command.projectless
                     ? undefined
                     : command.cwd === undefined
@@ -1448,6 +1475,10 @@ export class ProxySessionController {
                 if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "app-server") {
                     throw new Error("/newgroup --nodir 仅支持 App Server Agent。");
                 }
+                if (!userId?.startsWith("ou_")) {
+                    throw new Error("/newgroup 只能由具有 open_id 的飞书用户消息触发。");
+                }
+                await this.outbound.sendText(contextKey, CREATE_GROUP_STARTED_MESSAGE);
                 await this.createFeishuGroup(contextKey, context.defaultAgent, command.title, userId, command.cwd === undefined ? undefined : resolveUserPath(command.cwd), command.projectless === true);
                 return;
             case "forkgroup":
@@ -1466,6 +1497,7 @@ export class ProxySessionController {
                 await this.enqueueNoSteerPrompt(contextKey, command.text, messageId, replyTarget);
                 return;
             case "sessions":
+                await this.outbound.sendText(contextKey, LIST_SESSIONS_STARTED_MESSAGE);
                 await this.listSessions(contextKey, command.searchTerm);
                 return;
             case "switch":
@@ -1491,9 +1523,11 @@ export class ProxySessionController {
                 await this.openDismissGroupCard(contextKey, userId);
                 return;
             case "status":
+                await this.outbound.sendText(contextKey, STATUS_STARTED_MESSAGE);
                 await this.status(contextKey, command.sessionId);
                 return;
             case "goal":
+                await this.outbound.sendText(contextKey, GOAL_STARTED_MESSAGE);
                 await this.goal(contextKey, command);
                 return;
             case "restart":
@@ -1508,6 +1542,7 @@ export class ProxySessionController {
                 await this.setGroupMute(contextKey, command.enabled);
                 return;
             case "turns":
+                await this.outbound.sendText(contextKey, LIST_TURNS_STARTED_MESSAGE);
                 await this.openResetHistory(contextKey);
                 return;
             case "model":
@@ -1747,6 +1782,8 @@ export class ProxySessionController {
                 remote = await runtime.readRemoteSession(session.remoteSessionId);
             }
             catch (error) {
+                if (error instanceof CodexVersionError)
+                    throw error;
                 this.logger.warn({ error, attemptId: attempt.attemptId, remoteSessionId: session.remoteSessionId }, "Failed to read the remote task during startup recovery; treating the old local execution as interrupted.");
             }
         }
@@ -2191,8 +2228,7 @@ export class ProxySessionController {
             return false;
         if (record.lastTurnId === anchor.turnId)
             return true;
-        return this.store.listTaskTurnGraph(record.localSessionId)
-            .some((turn) => turn.turnId === anchor.turnId);
+        return this.store.hasTaskHistoryTurn(record.localSessionId, anchor.turnId);
     }
     async forkThreadSession(message) {
         const { anchor, source, snapshot } = this.resolveThreadForkAnchor(message);
@@ -2285,6 +2321,7 @@ export class ProxySessionController {
         return { anchor, source, snapshot };
     }
     async forkSessionReference(contextKey, reference) {
+        await this.outbound.sendText(contextKey, FORK_TASK_STARTED_MESSAGE);
         const plan = await this.prepareForkSession(contextKey, reference);
         const forked = await this.forkSessionIntoContext(contextKey, plan);
         const forkSourceLabel = plan.forkedFromHistoricalTurn
@@ -2336,32 +2373,22 @@ export class ProxySessionController {
         if (!runtime.readRemoteSession && !source) {
             throw new Error("当前 App Server Agent 不支持读取指定任务。");
         }
-        const persistedCompletedTurns = source ? this.localForkCompletedTurns(source) : [];
+        const persistedCompletedTurnId = source
+            ? this.store.findLatestCompletedTurnId(source.localSessionId)
+            : undefined;
         const sourceLastSnapshot = turnViewSnapshot(source?.lastTurnId ? this.store.getTurnSnapshot(source.lastTurnId) : undefined);
-        const localCompletedTurns = persistedCompletedTurns.length > 0
-            ? persistedCompletedTurns
-            : source?.lastTurnId
+        const localCompletedTurnId = persistedCompletedTurnId
+            ?? (source?.lastTurnId
                 && (source.lastTurnStatus === "completed" || sourceLastSnapshot?.status === "completed")
-                ? [{
-                        id: source.lastTurnId,
-                        prompt: latestUserPromptFromTurnView(sourceLastSnapshot) ?? source.title,
-                        startedAt: sourceLastSnapshot?.startedAt ?? parseIsoTimestamp(source.updatedAt),
-                        completedAt: sourceLastSnapshot?.completedAt
-                            ?? sourceLastSnapshot?.startedAt
-                            ?? parseIsoTimestamp(source.updatedAt),
-                    }]
-                : [];
-        if (!remote && runtime.readRemoteSession && (!source || persistedCompletedTurns.length === 0)) {
-            try {
-                remote = await runtime.readRemoteSession(remoteSessionId);
-            }
-            catch (error) {
-                if (localCompletedTurns.length === 0)
-                    throw error;
-                this.logger.warn({ error, contextKey, remoteSessionId, sourceTurnId: localCompletedTurns.at(-1)?.id }, "Failed to read the complete source task before Fork; using the locally persisted completed Turn.");
-            }
+                ? source.lastTurnId
+                : undefined)
+            ?? (source ? this.store.getForkHistorySource(source.localSessionId)?.sourceTurnId : undefined);
+        if (!remote && !localCompletedTurnId) {
+            remote = runtime.readRemoteForkSource
+                ? await runtime.readRemoteForkSource(remoteSessionId)
+                : await runtime.readRemoteSession?.(remoteSessionId);
         }
-        const latestTurnId = remote?.lastTurnId ?? source?.lastTurnId ?? localCompletedTurns.at(-1)?.id;
+        const latestTurnId = remote?.lastTurnId ?? source?.lastTurnId ?? localCompletedTurnId;
         const latestSnapshot = turnViewSnapshot(latestTurnId ? this.store.getTurnSnapshot(latestTurnId) : undefined);
         const isRunning = remote
             ? isRemoteSessionActive(remote)
@@ -2370,7 +2397,7 @@ export class ProxySessionController {
                 || isTurnStillRunning(latestSnapshot?.status));
         const lastTurnId = remote?.lastCompletedTurnId
             ?? (remote?.lastTurnStatus === "completed" ? remote.lastTurnId : undefined)
-            ?? localCompletedTurns.at(-1)?.id;
+            ?? localCompletedTurnId;
         if (!lastTurnId) {
             if (isRunning) {
                 throw new Error(`${sourceLabel}正在执行，且还没有已完成轮次可供 fork。请等待当前轮次完成后重试。`);
@@ -2379,8 +2406,7 @@ export class ProxySessionController {
         }
         const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(lastTurnId));
         const forkedFromHistoricalTurn = lastTurnId !== latestTurnId;
-        const completedTurn = (remote?.completedTurns ?? localCompletedTurns)
-            .find((turn) => turn.id === lastTurnId);
+        const completedTurn = remote?.completedTurns?.find((turn) => turn.id === lastTurnId);
         const cwd = remote?.cwd || source?.cwd;
         if (!cwd)
             throw new Error("指定的 App Server 任务没有可用的工作目录，暂时不能 fork。");
@@ -2422,27 +2448,10 @@ export class ProxySessionController {
             sourceTurnPrompt,
             sourceTurnStartedAt: snapshot?.startedAt ?? sourceTurnCompletedAt,
             sourceTurnCompletedAt,
-            sourceCompletedTurns: remote?.completedTurns
-                ?? (persistedCompletedTurns.length > 0 ? [] : localCompletedTurns),
             sourceWasRunning: isRunning,
             forkedFromHistoricalTurn,
         };
     }
-    localForkCompletedTurns(source) {
-        return this.store.listTaskTurnGraph(source.localSessionId)
-            .slice()
-            .reverse()
-            .map((record) => {
-            const snapshot = turnViewSnapshot(record.snapshot);
-            const startedAt = snapshot?.startedAt ?? parseIsoTimestamp(record.updatedAt);
-            return {
-                id: record.turnId,
-                prompt: latestUserPromptFromTurnView(snapshot),
-                startedAt,
-                completedAt: snapshot?.completedAt ?? startedAt,
-            };
-        });
-    }
     async prepareForkGroupSession(contextKey, requestedTitle, incomingMessage) {
         if (!incomingMessage?.threadContext) {
             const plan = await this.prepareForkSession(contextKey, undefined, requestedTitle);
@@ -2512,7 +2521,6 @@ export class ProxySessionController {
         };
     }
     async forkSessionIntoContext(contextKey, plan) {
-        const sourceCompletedTurns = await this.resolveForkSourceCompletedTurns(plan);
         const localSessionId = createId("sess");
         const record = this.store.createSession({
             localSessionId,
@@ -2548,7 +2556,6 @@ export class ProxySessionController {
                 lastTurnStatus: plan.lastTurnStatus,
             });
             this.outbound.registerSession(localSessionId, contextKey, forked.title ?? plan.forkTitle, plan.cwd, this.agentLabel(plan.agentName));
-            const sourceTurnHistoryCount = this.persistForkSourceHistory(contextKey, localSessionId, plan, sourceCompletedTurns);
             this.store.audit(contextKey, "session_forked", {
                 sourceLocalSessionId: plan.source?.localSessionId,
                 sourceRemoteSessionId: plan.remoteSessionId,
@@ -2556,7 +2563,6 @@ export class ProxySessionController {
                 sourceTurnPrompt: plan.sourceTurnPrompt,
                 sourceTurnStartedAt: plan.sourceTurnStartedAt,
                 sourceTurnCompletedAt: plan.sourceTurnCompletedAt,
-                sourceTurnHistoryCount,
                 sourceWasRunning: plan.sourceWasRunning,
                 forkedLocalSessionId: localSessionId,
                 forkedRemoteSessionId: forked.remoteSessionId,
@@ -2572,42 +2578,6 @@ export class ProxySessionController {
             throw error;
         }
     }
-    async resolveForkSourceCompletedTurns(plan) {
-        let completedTurns = plan.sourceCompletedTurns;
-        if (completedTurns === undefined && plan.runtime.readRemoteSession) {
-            try {
-                completedTurns = (await plan.runtime.readRemoteSession(plan.remoteSessionId)).completedTurns ?? [];
-            }
-            catch (error) {
-                this.logger.warn({ error, remoteSessionId: plan.remoteSessionId, sourceTurnId: plan.lastTurnId }, "Failed to read the source task Turn history before Fork; keeping the Fork anchor fallback.");
-            }
-        }
-        if (!completedTurns?.length)
-            return [];
-        const anchorIndex = completedTurns.findIndex((turn) => turn.id === plan.lastTurnId);
-        if (anchorIndex < 0) {
-            this.logger.warn({ remoteSessionId: plan.remoteSessionId, sourceTurnId: plan.lastTurnId }, "The source task Turn history did not include the Fork anchor; keeping the Fork anchor fallback.");
-            return [];
-        }
-        return completedTurns.slice(0, anchorIndex + 1);
-    }
-    persistForkSourceHistory(contextKey, forkedLocalSessionId, plan, completedTurns) {
-        if (completedTurns.length === 0)
-            return 0;
-        const localSessionId = plan.source?.localSessionId ?? forkedLocalSessionId;
-        const historyContextKey = plan.source?.contextKey ?? contextKey;
-        const fallbackStart = plan.sourceTurnStartedAt
-            ?? plan.sourceTurnCompletedAt
-            ?? Date.now() - completedTurns.length;
-        return this.persistCompletedTurnHistory({
-            localSessionId,
-            contextKey: historyContextKey,
-            agentName: plan.agentName,
-            remoteSessionId: plan.remoteSessionId,
-            completedTurns,
-            fallbackStart,
-        });
-    }
     persistCompletedTurnHistory(input) {
         try {
             this.store.importCompletedTurnHistory({
@@ -2615,6 +2585,7 @@ export class ProxySessionController {
                 contextKey: input.contextKey,
                 agentName: input.agentName,
                 remoteSessionId: input.remoteSessionId,
+                replaceParents: input.replaceParents,
                 turns: input.completedTurns.map((turn, index) => {
                     const startedAt = turn.startedAt ?? input.fallbackStart + index;
                     const completedAt = turn.completedAt ?? startedAt;
@@ -2645,80 +2616,198 @@ export class ProxySessionController {
             return 0;
         }
     }
-    async hydrateLegacyForkTurnHistory(contextKey, current) {
-        const source = this.store.getForkHistorySource(current.localSessionId);
-        if (!source || source.sourceTurnHistoryCount !== undefined
-            || this.store.hasImportedForkTurnHistory(current.localSessionId))
-            return;
+    async hydrateTaskTurnHistory(current, requiredCount = RESET_HISTORY_PAGE_SIZE) {
+        const existing = this.turnHistoryHydrations.get(current.localSessionId);
+        if (existing)
+            await existing;
+        const hydration = (async () => {
+            if (this.store.getForkHistorySource(current.localSessionId)) {
+                return this.hydrateForkTurnHistory(current.contextKey, current, requiredCount);
+            }
+            return this.hydrateRemoteTurnHistory(current.contextKey, current, requiredCount);
+        })();
+        this.turnHistoryHydrations.set(current.localSessionId, hydration);
+        try {
+            return await hydration;
+        }
+        finally {
+            if (this.turnHistoryHydrations.get(current.localSessionId) === hydration) {
+                this.turnHistoryHydrations.delete(current.localSessionId);
+            }
+        }
+    }
+    async hydrateForkTurnHistory(contextKey, current, requiredCount, visited = new Set()) {
+        if (visited.has(current.localSessionId))
+            return false;
+        visited.add(current.localSessionId);
+        let source = this.store.getForkHistorySource(current.localSessionId);
+        if (!source)
+            return false;
+        const completedHead = current.lastTurnStatus === "completed"
+            ? current.lastTurnId
+            : this.store.findLatestCompletedTurnId(current.localSessionId);
+        if (completedHead && completedHead !== source.sourceTurnId && current.remoteSessionId) {
+            // Once the branch has its own completed work, its remote history is the
+            // authority for missing local turns, including work continued in Desktop.
+            source = {
+                sourceLocalSessionId: current.localSessionId,
+                sourceRemoteSessionId: current.remoteSessionId,
+                sourceTurnId: completedHead,
+                createdAt: current.createdAt,
+            };
+        }
+        if (this.store.hasImportedForkTurnHistory(current.localSessionId, source.sourceRemoteSessionId, source.sourceTurnId))
+            return false;
+        const localTurns = this.store.listTaskTurnGraphIndex(current.localSessionId);
+        const availableCount = localTurns.length;
+        const key = JSON.stringify([current.agentName, source.sourceRemoteSessionId, source.sourceTurnId]);
+        let state = this.forkHistoryCursors.get(key) ?? { anchorFound: false, complete: false };
+        const localAnchorIndex = localTurns.findIndex((turn) => turn.turnId === source.sourceTurnId);
+        const ownTurnCount = source.sourceLocalSessionId === current.localSessionId
+            ? Math.max(0, localAnchorIndex)
+            : localAnchorIndex >= 0 ? localAnchorIndex : availableCount;
+        const neededInheritedCount = Math.max(0, requiredCount - ownTurnCount);
+        if (localAnchorIndex >= 0 && availableCount >= requiredCount
+            && (!state.anchorFound || (state.loadedCount ?? 0) >= neededInheritedCount))
+            return !state.complete;
+        const sourceSession = source.sourceLocalSessionId
+            ? this.store.getSession(source.sourceLocalSessionId)
+            : undefined;
+        // A branch with no new turns can reuse its ancestor's history, even before
+        // the Agent materializes that intermediate branch.
+        if (sourceSession && sourceSession.localSessionId !== current.localSessionId
+            && this.store.getForkHistorySource(sourceSession.localSessionId)?.sourceTurnId === source.sourceTurnId) {
+            const hasMore = await this.hydrateForkTurnHistory(sourceSession.contextKey, sourceSession, this.store.listTaskTurnGraphIndex(sourceSession.localSessionId).length + requiredCount - availableCount, visited);
+            if (!hasMore && this.store.hasImportedForkTurnHistory(sourceSession.localSessionId)) {
+                this.store.audit(contextKey, "fork_turn_history_imported", {
+                    forkedLocalSessionId: current.localSessionId,
+                    sourceRemoteSessionId: source.sourceRemoteSessionId,
+                    sourceTurnId: source.sourceTurnId,
+                    reusedLocalSessionId: sourceSession.localSessionId,
+                });
+            }
+            return hasMore;
+        }
         if (!source.sourceRemoteSessionId)
-            return;
+            return false;
         const runtime = this.runtimes.forAgent(current.agentName);
-        if (runtime.kind !== "codex" || !runtime.readRemoteSession)
-            return;
+        if (runtime.kind !== "codex" || !runtime.listRemoteTurnSummaries)
+            return false;
+        const seenCursors = new Set();
         try {
-            const remote = await runtime.readRemoteSession(source.sourceRemoteSessionId);
-            const completedTurns = remote.completedTurns ?? [];
-            const anchorIndex = completedTurns.findIndex((turn) => turn.id === source.sourceTurnId);
-            if (anchorIndex < 0)
-                return;
-            const inheritedTurns = completedTurns.slice(0, anchorIndex + 1);
-            const sourceSession = source.sourceLocalSessionId
-                ? this.store.getSession(source.sourceLocalSessionId)
-                : undefined;
-            const imported = this.persistCompletedTurnHistory({
-                localSessionId: sourceSession?.localSessionId ?? current.localSessionId,
-                contextKey: sourceSession?.contextKey ?? contextKey,
-                agentName: current.agentName,
-                remoteSessionId: source.sourceRemoteSessionId,
-                completedTurns: inheritedTurns,
-                fallbackStart: source.sourceTurnStartedAt
-                    ?? source.sourceTurnCompletedAt
-                    ?? Date.now() - inheritedTurns.length,
-            });
-            if (imported > 0) {
+            while (!state.complete && (state.loadedCount ?? 0) < neededInheritedCount) {
+                const remaining = neededInheritedCount - (state.loadedCount ?? 0);
+                const page = await runtime.listRemoteTurnSummaries(source.sourceRemoteSessionId, {
+                    cursor: state.cursor, limit: Math.min(RESET_HISTORY_PAGE_SIZE, remaining),
+                });
+                if (page.nextCursor && (page.nextCursor === state.cursor || seenCursors.has(page.nextCursor))) {
+                    throw new Error("App Server repeated a Turn history cursor.");
+                }
+                const anchorIndex = state.anchorFound ? 0 : page.turns.findIndex((turn) => turn.id === source.sourceTurnId);
+                const inheritedTurns = anchorIndex >= 0 ? page.turns.slice(anchorIndex) : [];
+                const anchorFound = state.anchorFound || anchorIndex >= 0;
+                if (!anchorFound && !page.nextCursor) {
+                    this.forkHistoryCursors.delete(key);
+                    throw new Error("The Fork source Turn was not found in the available history.");
+                }
+                if (inheritedTurns.length > 0) {
+                    const ownerId = sourceSession?.localSessionId ?? current.localSessionId;
+                    const imported = this.persistCompletedTurnHistory({
+                        localSessionId: ownerId,
+                        contextKey: sourceSession?.contextKey ?? contextKey,
+                        agentName: current.agentName,
+                        remoteSessionId: source.sourceRemoteSessionId,
+                        completedTurns: inheritedTurns.slice().reverse(),
+                        // Adjacent remote summaries repair gaps in locally inferred ancestry.
+                        replaceParents: true,
+                        fallbackStart: (source.sourceTurnStartedAt ?? source.sourceTurnCompletedAt
+                            ?? parseIsoTimestamp(source.createdAt) ?? 0) - (state.loadedCount ?? 0) - inheritedTurns.length,
+                    });
+                    if (imported === 0)
+                        throw new Error("Failed to persist the requested Turn history page.");
+                    if (state.tailTurnId) {
+                        this.store.saveTurnParent(state.tailTurnId, ownerId, inheritedTurns[0].id, true);
+                    }
+                }
+                state = {
+                    cursor: page.nextCursor,
+                    anchorFound,
+                    tailTurnId: inheritedTurns.at(-1)?.id ?? state.tailTurnId,
+                    loadedCount: (state.loadedCount ?? 0) + inheritedTurns.length,
+                    complete: !page.nextCursor,
+                };
+                this.forkHistoryCursors.set(key, state);
+                if (page.nextCursor)
+                    seenCursors.add(page.nextCursor);
+            }
+            if (state.complete) {
                 this.store.audit(contextKey, "fork_turn_history_imported", {
                     forkedLocalSessionId: current.localSessionId,
                     sourceRemoteSessionId: source.sourceRemoteSessionId,
                     sourceTurnId: source.sourceTurnId,
-                    importedTurnCount: imported,
                 });
             }
+            return !state.complete;
         }
         catch (error) {
-            this.logger.warn({ error, localSessionId: current.localSessionId, sourceRemoteSessionId: source.sourceRemoteSessionId }, "Failed to hydrate legacy Fork Turn history; rendering the locally available history.");
+            if (error instanceof CodexVersionError)
+                throw error;
+            this.logger.warn({ error, localSessionId: current.localSessionId, sourceRemoteSessionId: source.sourceRemoteSessionId }, "Failed to load the requested Fork Turn history page; rendering the locally available history.");
         }
+        return true;
     }
-    async hydrateRemoteTurnHistory(contextKey, current) {
+    async hydrateRemoteTurnHistory(contextKey, current, requiredCount) {
         if (!current.remoteSessionId)
-            return;
+            return false;
+        const key = JSON.stringify([current.agentName, current.remoteSessionId, "turn-card"]);
         const refreshedAt = this.remoteTurnHistoryRefreshes.get(current.localSessionId);
-        if (refreshedAt !== undefined && Date.now() - refreshedAt < REMOTE_TURN_HISTORY_REFRESH_INTERVAL_MS)
-            return;
-        const forkSource = this.store.getForkHistorySource(current.localSessionId);
-        if (forkSource?.sourceTurnId === current.lastTurnId
-            && this.store.hasImportedForkTurnHistory(current.localSessionId))
-            return;
+        let state = this.forkHistoryCursors.get(key);
+        if (refreshedAt === undefined || Date.now() - refreshedAt >= REMOTE_TURN_HISTORY_REFRESH_INTERVAL_MS)
+            state = undefined;
+        state ??= { anchorFound: true, complete: false };
         const runtime = this.runtimes.forAgent(current.agentName);
-        if (runtime.kind !== "codex" || !runtime.readRemoteSession)
-            return;
+        if (runtime.kind !== "codex" || !runtime.listRemoteTurnSummaries)
+            return false;
+        const seen = new Set();
         try {
-            const remote = await runtime.readRemoteSession(current.remoteSessionId);
-            this.remoteTurnHistoryRefreshes.set(current.localSessionId, Date.now());
-            const completedTurns = remote.completedTurns ?? [];
-            if (completedTurns.length === 0)
-                return;
-            this.persistCompletedTurnHistory({
-                localSessionId: current.localSessionId,
-                contextKey,
-                agentName: current.agentName,
-                remoteSessionId: current.remoteSessionId,
-                completedTurns,
-                fallbackStart: parseIsoTimestamp(current.createdAt) ?? Date.now() - completedTurns.length,
-            });
+            while (!state.complete && (state.loadedCount ?? 0) < requiredCount) {
+                const page = await runtime.listRemoteTurnSummaries(current.remoteSessionId, {
+                    cursor: state.cursor,
+                    limit: Math.min(RESET_HISTORY_PAGE_SIZE, requiredCount - (state.loadedCount ?? 0)),
+                });
+                if (page.nextCursor && (page.nextCursor === state.cursor || seen.has(page.nextCursor))) {
+                    throw new Error("App Server repeated a Turn history cursor.");
+                }
+                if (page.turns.length) {
+                    const imported = this.persistCompletedTurnHistory({
+                        localSessionId: current.localSessionId, contextKey, agentName: current.agentName,
+                        remoteSessionId: current.remoteSessionId,
+                        completedTurns: page.turns.slice().reverse(), replaceParents: true,
+                        fallbackStart: (parseIsoTimestamp(current.createdAt) ?? 0) - (state.loadedCount ?? 0) - page.turns.length,
+                    });
+                    if (!imported)
+                        throw new Error("Failed to persist the requested Turn history page.");
+                    if (state.tailTurnId)
+                        this.store.saveTurnParent(state.tailTurnId, current.localSessionId, page.turns[0].id, true);
+                }
+                state = {
+                    anchorFound: true, cursor: page.nextCursor, complete: !page.nextCursor,
+                    loadedCount: (state.loadedCount ?? 0) + page.turns.length,
+                    tailTurnId: page.turns.at(-1)?.id ?? state.tailTurnId,
+                };
+                this.forkHistoryCursors.set(key, state);
+                this.remoteTurnHistoryRefreshes.set(current.localSessionId, Date.now());
+                if (page.nextCursor)
+                    seen.add(page.nextCursor);
+            }
+            return !state.complete;
         }
         catch (error) {
+            if (error instanceof CodexVersionError)
+                throw error;
             this.logger.warn({ error, localSessionId: current.localSessionId, remoteSessionId: current.remoteSessionId }, "Failed to hydrate App Server Turn history; rendering the locally available history.");
         }
+        return true;
     }
     async createProjectSessionFromReference(contextKey, reference) {
         const resolved = await this.resolveProjectSessionReference(contextKey, reference);
@@ -2750,7 +2839,7 @@ export class ProxySessionController {
             runtime = this.runtimes.forAgent(agentName);
         }
         else {
-            const resolved = await this.resolveRemoteCodexSession(taskId);
+            const resolved = await this.resolveRemoteCodexSession(taskId, { view: "metadata" });
             agentName = resolved.agentName;
             runtime = resolved.runtime;
             remote = resolved.remote;
@@ -2758,10 +2847,10 @@ export class ProxySessionController {
         const remoteSessionId = source?.remoteSessionId ?? remote?.id ?? taskId;
         if (!remote && runtime.readRemoteSession && remoteSessionId) {
             try {
-                remote = await runtime.readRemoteSession(remoteSessionId);
+                remote = await runtime.readRemoteSession(remoteSessionId, "metadata");
             }
             catch (error) {
-                if (!source)
+                if (!source || error instanceof CodexVersionError)
                     throw error;
                 this.logger.warn({ error, contextKey, taskId: remoteSessionId }, "Failed to refresh the source task before creating a project task; using the local project path.");
             }
@@ -2992,6 +3081,7 @@ export class ProxySessionController {
         if (!userId?.startsWith("ou_")) {
             throw new Error("/forkgroup 只能由具有 open_id 的飞书用户消息触发。");
         }
+        await this.outbound.sendText(sourceContextKey, FORK_GROUP_STARTED_MESSAGE);
         const prepared = await this.prepareForkGroupSession(sourceContextKey, requestedTitle, incomingMessage);
         await this.forkPreparedSessionToFeishuGroup(sourceContextKey, prepared, userId, incomingMessage?.threadContext ? prepared.sourceDescription : "当前任务");
     }
@@ -2999,6 +3089,7 @@ export class ProxySessionController {
         if (!userId?.startsWith("ou_")) {
             throw new Error("ForkGroup 只能由具有 open_id 的飞书用户触发。");
         }
+        await this.outbound.sendText(sourceContextKey, FORK_GROUP_STARTED_MESSAGE);
         const plan = await this.prepareForkSession(sourceContextKey, reference);
         await this.forkPreparedSessionToFeishuGroup(sourceContextKey, {
             plan,
@@ -3107,7 +3198,8 @@ export class ProxySessionController {
                 catch (error) {
                     if (activeWriterThreadId(error))
                         throw error;
-                    if (!(agent.kind === "app-server" && !record.lastTurnId && isMissingRolloutError(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({
@@ -3522,6 +3614,7 @@ export class ProxySessionController {
     }
     async cancel(contextKey) {
         const record = this.requireCurrentSession(contextKey);
+        await this.outbound.sendText(contextKey, STOP_TASK_STARTED_MESSAGE);
         await this.cancelSession(record);
     }
     async cancelSession(record) {
@@ -3536,6 +3629,8 @@ export class ProxySessionController {
                         await runtime.setGoal(record.localSessionId, { status: "paused" });
                 }
                 catch (error) {
+                    if (error instanceof CodexVersionError)
+                        throw error;
                     this.logger.warn({ error, sessionId: record.localSessionId }, "Failed to pause the active Agent goal before interrupting its turn.");
                 }
             }
@@ -3548,6 +3643,8 @@ export class ProxySessionController {
                         : undefined;
                 }
                 catch (error) {
+                    if (error instanceof CodexVersionError)
+                        throw error;
                     this.logger.warn({ error, sessionId: record.localSessionId, remoteSessionId: record.remoteSessionId }, "Failed to inspect the current App Server turn before interrupting; using the locally tracked turn.");
                 }
             }
@@ -3591,8 +3688,14 @@ export class ProxySessionController {
     async resetCurrentSessionToTurn(contextKey, sessionId, turnId) {
         if (!sessionId || !turnId)
             throw new Error("无效的 Reset 请求。请使用最新的思考卡片重试。");
+        await this.runSessionReset(sessionId, async () => {
+            await this.outbound.sendText(contextKey, TURN_RESET_STARTED_MESSAGE);
+            await this.performCurrentSessionReset(contextKey, sessionId, turnId);
+        });
+    }
+    async runSessionReset(sessionId, operation) {
         const previous = this.sessionResets.get(sessionId) ?? Promise.resolve();
-        const reset = previous.catch(() => undefined).then(() => this.performCurrentSessionReset(contextKey, sessionId, turnId));
+        const reset = previous.catch(() => undefined).then(operation);
         this.sessionResets.set(sessionId, reset);
         try {
             await reset;
@@ -3602,6 +3705,19 @@ export class ProxySessionController {
                 this.sessionResets.delete(sessionId);
         }
     }
+    async waitForCurrentSessionReset(contextKey) {
+        const sessionId = this.currentSession(contextKey)?.localSessionId;
+        if (!sessionId)
+            return;
+        let reset = this.sessionResets.get(sessionId);
+        while (reset) {
+            await reset.catch(() => undefined);
+            const next = this.sessionResets.get(sessionId);
+            if (!next || next === reset)
+                return;
+            reset = next;
+        }
+    }
     async resetFromHistoryCard(contextKey, sessionId, turnId, updateMessageId, page) {
         if (!sessionId || !turnId)
             throw new Error("无效的 Reset 请求。请使用最新的历史轮次卡片重试。");
@@ -3612,16 +3728,11 @@ export class ProxySessionController {
         }
         this.resetHistoryOperations.set(sessionId, turnId);
         try {
-            await this.openResetHistory(contextKey, { expectedSessionId: sessionId, updateMessageId, page });
-        }
-        catch (error) {
-            if (this.resetHistoryOperations.get(sessionId) === turnId) {
-                this.resetHistoryOperations.delete(sessionId);
-            }
-            throw error;
-        }
-        try {
-            await this.resetCurrentSessionToTurn(contextKey, sessionId, turnId);
+            await this.runSessionReset(sessionId, async () => {
+                await this.outbound.sendText(contextKey, TURN_RESET_STARTED_MESSAGE);
+                await this.openResetHistory(contextKey, { expectedSessionId: sessionId, updateMessageId, page });
+                await this.performCurrentSessionReset(contextKey, sessionId, turnId);
+            });
         }
         catch (error) {
             if (this.resetHistoryOperations.get(sessionId) === turnId) {
@@ -3651,9 +3762,9 @@ export class ProxySessionController {
         if (!current.remoteSessionId || !this.isCodexSession(current)) {
             throw new Error("当前任务不是可 Reset 的 App Server 任务。");
         }
-        const historyTurn = this.store.listTaskTurnGraph(current.localSessionId)
+        const historyTurn = this.store.listTaskTurnGraphIndex(current.localSessionId)
             .find((turn) => turn.turnId === turnId);
-        const snapshot = turnViewSnapshot(historyTurn?.snapshot);
+        const snapshot = historyTurn ? this.store.getTurnPromptSummary(turnId) : undefined;
         if (!snapshot || snapshot.status !== "completed") {
             throw new Error("只能将当前任务 Reset 到已成功完成的轮次。");
         }
@@ -3809,6 +3920,7 @@ export class ProxySessionController {
         const record = options.sessionId
             ? this.requireSession(contextKey, options.sessionId)
             : this.requireCurrentSession(contextKey);
+        await this.outbound.sendText(contextKey, `正在切换到 Provider ${modelProvider}，请稍后。`);
         const loaded = await this.loadSession(record);
         await this.assertModelProvider(loaded, modelProvider);
         const models = await loaded.runtime.listModels();
@@ -3826,7 +3938,7 @@ export class ProxySessionController {
             model: model.id,
             effort,
             mode: loaded.session.permissionMode,
-        }, options);
+        }, options, false);
     }
     async openProviderSelector(contextKey, options = {}) {
         await this.openExecutionSettings(contextKey, "provider", options);
@@ -3881,28 +3993,21 @@ export class ProxySessionController {
             currentMode: permissionMode,
         }));
     }
-    async applyProviderSettings(contextKey, settings, options = {}) {
+    async applyProviderSettings(contextKey, settings, options = {}, announceStart = true) {
         const record = options.sessionId
             ? this.requireSession(contextKey, options.sessionId)
             : this.requireCurrentSession(contextKey);
+        if (announceStart) {
+            await this.outbound.sendText(contextKey, `正在切换到 Provider ${settings.provider}，请稍后。`);
+        }
         const loaded = await this.loadSession(record);
         await this.assertProviderModelSettings(loaded, settings.provider, settings.model, settings.effort);
-        if (!loaded.runtime.setExecutionSettings) {
-            throw new Error("当前运行时不支持 Provider 设置。");
-        }
-        const session = await loaded.runtime.setExecutionSettings(loaded.record.localSessionId, {
+        const session = await this.changeProviderSettings(loaded, {
             modelProvider: settings.provider,
             model: settings.model,
             reasoningEffort: settings.effort,
             permissionMode: settings.mode,
         });
-        this.store.updateRuntimeSession(loaded.record.localSessionId, {
-            modelProvider: session.modelProvider ?? settings.provider,
-            model: session.model ?? settings.model,
-            reasoningEffort: session.reasoningEffort ?? settings.effort,
-            permissionMode: session.permissionMode,
-        });
-        await this.persistAgentExecutionDefaults(loaded.record.localSessionId);
         const notice = [
             `Provider 已切换为 ${cardCode(session.modelProvider ?? settings.provider)}`,
             `模型 ${cardCode(session.model ?? settings.model)}`,
@@ -3921,6 +4026,31 @@ export class ProxySessionController {
             await this.outbound.sendText(contextKey, notice.replaceAll("`", ""));
         }
     }
+    async changeProviderSettings(loaded, settings) {
+        if (!loaded.runtime.setExecutionSettings)
+            throw new Error("当前运行时不支持 Provider 设置。");
+        const persist = async (candidate) => {
+            assertProviderSettingsApplied(candidate, settings);
+            const agent = this.ensureAgent(loaded.record.agentName);
+            const previousDefaults = agent.defaults;
+            await this.persistAgentExecutionDefaults(loaded.record.localSessionId, candidate);
+            try {
+                this.store.updateRuntimeSession(loaded.record.localSessionId, {
+                    remoteSessionId: candidate.remoteSessionId,
+                    modelProvider: candidate.modelProvider,
+                    model: candidate.model,
+                    reasoningEffort: candidate.reasoningEffort,
+                    permissionMode: candidate.permissionMode,
+                });
+            }
+            catch (error) {
+                await this.lifecycle?.persistAgentExecutionDefaults?.(loaded.record.agentName, previousDefaults ?? {});
+                agent.defaults = previousDefaults;
+                throw error;
+            }
+        };
+        return loaded.runtime.setExecutionSettings(loaded.record.localSessionId, settings, persist);
+    }
     async assertProviderModelSettings(loaded, modelProvider, model, effort) {
         await this.assertModelProvider(loaded, modelProvider);
         const selected = (await loaded.runtime.listModels()).find((candidate) => candidate.id === model);
@@ -4283,7 +4413,9 @@ export class ProxySessionController {
         const normalizedTitle = normalizeTaskTitle(title);
         if (!normalizedTitle)
             throw new Error("任务标题不能为空。");
-        const loaded = await this.loadSession(this.requireCurrentSession(contextKey));
+        const current = this.requireCurrentSession(contextKey);
+        await this.outbound.sendText(contextKey, CHANGE_TITLE_STARTED_MESSAGE);
+        const loaded = await this.loadSession(current);
         if (loaded.runtime.setTitle)
             await loaded.runtime.setTitle(loaded.record.localSessionId, normalizedTitle);
         else
@@ -4403,9 +4535,9 @@ export class ProxySessionController {
         if (!current.remoteSessionId || !this.isCodexSession(current)) {
             throw new Error("当前任务不是可 Reset 的 App Server 任务。");
         }
-        await this.hydrateLegacyForkTurnHistory(contextKey, current);
-        await this.hydrateRemoteTurnHistory(contextKey, current);
-        const completedTurns = this.store.listTaskTurnGraph(current.localSessionId);
+        const requestedPage = Math.max(0, Math.trunc(options.page ?? 0));
+        const hasMoreHistory = await this.hydrateTaskTurnHistory(current, (requestedPage + 1) * RESET_HISTORY_PAGE_SIZE);
+        const completedTurns = this.store.listTaskTurnGraphIndex(current.localSessionId);
         const completedTurnIds = new Set(completedTurns.map((turn) => turn.turnId));
         const runningTurnId = current.lastTurnStatus === "running" && current.lastTurnId
             && !completedTurnIds.has(current.lastTurnId)
@@ -4447,13 +4579,13 @@ export class ProxySessionController {
             parentTurnId: turn.parentTurnId,
         })));
         const total = allTurns.length;
-        const totalPages = Math.max(1, Math.ceil(total / RESET_HISTORY_PAGE_SIZE));
+        const totalPages = Math.max(1, Math.ceil(total / RESET_HISTORY_PAGE_SIZE)) + (hasMoreHistory ? 1 : 0);
         const page = Math.max(0, Math.min(Math.trunc(options.page ?? 0), totalPages - 1));
         const offset = page * RESET_HISTORY_PAGE_SIZE;
         const turns = allTurns.slice(offset, offset + RESET_HISTORY_PAGE_SIZE);
         const resettingTurnId = this.resetHistoryOperations.get(current.localSessionId);
         const entries = turns.flatMap((turn, index) => {
-            const snapshot = turnViewSnapshot(turn.snapshot);
+            const snapshot = turn.turnId === runningTurnId ? runningSnapshot : this.store.getTurnPromptSummary(turn.turnId);
             if (!snapshot)
                 return [];
             const graph = graphRows[offset + index];
@@ -4506,9 +4638,11 @@ export class ProxySessionController {
         const card = this.cardRenderer.renderResetHistoryCard({
             entries,
             footerLines: [
-                runningTurn
-                    ? `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个 turn（${completedTurns.length} 个已完成，1 个运行中）`
-                    : `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个已完成 turn`,
+                hasMoreHistory
+                    ? `第 ${page + 1} 页 · 已加载 ${total} 个 turn`
+                    : runningTurn
+                        ? `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个 turn（${completedTurns.length} 个已完成，1 个运行中）`
+                        : `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个已完成 turn`,
                 ...(resettingTurnId ? ["正在 Reset 到所选轮次，请稍候…"] : []),
             ],
             pageActions,
@@ -4707,6 +4841,7 @@ export class ProxySessionController {
         const record = this.requireCurrentSession(contextKey);
         const filePath = resolveUserPath(requestedFilePath, record.cwd);
         await this.assertSendableFile(filePath);
+        await this.outbound.sendText(contextKey, SEND_FILE_STARTED_MESSAGE);
         await this.outbound.sendFile(contextKey, filePath);
     }
     async listSessions(contextKey, searchTerm, options = {}) {
@@ -4997,7 +5132,7 @@ export class ProxySessionController {
                 runtime,
                 remote: options.forFork && runtime.readRemoteForkSource
                     ? await runtime.readRemoteForkSource(remoteSessionId)
-                    : await runtime.readRemoteSession(remoteSessionId),
+                    : await runtime.readRemoteSession(remoteSessionId, options.view ?? "latest"),
             };
         }));
         const matches = reads
@@ -5023,6 +5158,7 @@ export class ProxySessionController {
         if (direct?.status === "closed") {
             throw new Error(`找不到任务：${taskId}`);
         }
+        await this.outbound.sendText(contextKey, SWITCH_TASK_STARTED_MESSAGE);
         const existing = direct ?? this.findStoredSessionByReference(taskId);
         if (existing) {
             const runtime = this.runtimes.forAgent(existing.agentName);
@@ -5107,6 +5243,9 @@ export class ProxySessionController {
         if (local && this.store.countQueuedPrompts(local.localSessionId) > 0) {
             throw new Error("任务仍有排队消息，无法归档。请先处理或取消排队消息。");
         }
+        if (options.source !== "dismiss") {
+            await this.outbound.sendText(contextKey, ARCHIVE_TASK_STARTED_MESSAGE);
+        }
         const remoteReference = local
             ? remoteSessionReference(local.agentName, local.remoteSessionId)
             : taskId;
@@ -5314,28 +5453,32 @@ export class ProxySessionController {
         else {
             current = context.currentSessionId ? this.store.getSession(context.currentSessionId) : undefined;
         }
-        if (current && current.status === "running") {
-            try {
-                const runtime = this.runtimes.forAgent(current.agentName);
-                if (runtime.getSession(current.localSessionId)) {
-                    await runtime.synchronizeSession(current.localSessionId);
+        let remote;
+        if (current?.status === "running") {
+            const runtime = this.runtimes.forAgent(current.agentName);
+            if (runtime.getSession(current.localSessionId)) {
+                try {
+                    remote = (await runtime.synchronizeSession(current.localSessionId)).remoteSummary;
                     current = this.store.getSession(current.localSessionId) ?? current;
                 }
-            }
-            catch (error) {
-                this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to synchronize task status.");
+                catch (error) {
+                    if (error instanceof CodexVersionError)
+                        throw error;
+                    this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to synchronize task status.");
+                }
             }
         }
         const localCurrent = current;
-        let remote;
         let goal;
         if (current?.remoteSessionId) {
             const runtime = this.runtimes.forAgent(current.agentName);
-            if (runtime.readRemoteSession) {
+            if (!remote && runtime.readRemoteSession) {
                 try {
-                    remote = await runtime.readRemoteSession(current.remoteSessionId);
+                    remote = await runtime.readRemoteSession(current.remoteSessionId, "latest-full");
                 }
                 catch (error) {
+                    if (error instanceof CodexVersionError)
+                        throw error;
                     this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect App Server task status.");
                 }
             }
@@ -5431,7 +5574,7 @@ export class ProxySessionController {
             await this.outbound.sendInteractiveCard(contextKey, card);
     }
     async statusForCodexTask(contextKey, reference, options = {}) {
-        const { agentName, remote } = await this.resolveRemoteCodexSession(reference);
+        const { agentName, remote } = await this.resolveRemoteCodexSession(reference, { view: "latest-full" });
         const actionReference = remoteSessionReference(agentName, remote.id);
         const sections = [
             {
@@ -5562,10 +5705,11 @@ export class ProxySessionController {
             throw new Error(`未知 agent：${agentName}`);
         return agent;
     }
-    async persistAgentExecutionDefaults(localSessionId) {
-        const session = this.store.getSession(localSessionId);
-        if (!session)
+    async persistAgentExecutionDefaults(localSessionId, candidate) {
+        const record = this.store.getSession(localSessionId);
+        if (!record)
             throw new Error(`找不到任务：${localSessionId}`);
+        const session = candidate ?? record;
         const agent = this.ensureAgent(session.agentName);
         const observed = {
             ...(session.modelProvider?.trim() ? { modelProvider: session.modelProvider } : {}),
@@ -5935,6 +6079,7 @@ export class ProxySessionController {
         const lockPath = runtime.getThreadWriterLockPath?.(threadId);
         if (!lockPath)
             throw new Error("当前 Agent 不支持自动关闭占用程序。");
+        await this.outbound.sendText(contextKey, CLOSE_WRITER_STARTED_MESSAGE);
         let owners = await this.threadWriterProcesses.inspect(lockPath);
         const expectedOwner = owners.length === 1 && threadWriterMatches(owners[0], expectedWriterPid, expectedWriterStartedAt, expectedApplicationPid, expectedApplicationStartedAt) ? owners[0] : undefined;
         if (!expectedOwner) {
@@ -6260,10 +6405,6 @@ function bindSessionCardAction(action, bindings) {
 function runtimeErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function isMissingRolloutError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /no rollout found|rollout[^\n]*(?:not found|missing)|thread\/resume failed/i.test(message);
-}
 function isUnmaterializedCodexThreadError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /thread\/read failed:[^\n]*(?:not materialized|not loaded|includeTurns is unavailable before first user message)/i.test(message);