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

package/src/proxy/ProxySessionController.ts

@@ -4,6 +4,8 @@ import os from "node:os";
 import path from "node:path";
 import type { Logger } from "pino";
 import { createProjectlessWorkspace, detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
+import { CodexVersionError } from "../codex/CodexVersion.js";
+import { assertProviderSettingsApplied, isMissingRolloutError } from "../codex/ProviderSwitch.js";
 import {
   SystemThreadWriterProcessController,
   type ThreadWriterProcess,
@@ -64,6 +66,7 @@ import type {
   RemoteSessionSummary,
   RuntimeGoal,
   RuntimeEvent,
+  RuntimeExecutionSettings,
   RuntimePrompt,
   RuntimeSession,
 } from "../runtime/types.js";
@@ -187,6 +190,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([
@@ -409,7 +428,6 @@ interface ForkSessionPlan {
   sourceTurnPrompt?: string;
   sourceTurnStartedAt?: number;
   sourceTurnCompletedAt?: number;
-  sourceCompletedTurns?: RemoteCompletedTurnSummary[];
   sourceWasRunning: boolean;
   forkedFromHistoricalTurn: boolean;
 }
@@ -419,6 +437,14 @@ interface ForkSessionResult {
   session: RuntimeSession;
 }
 
+interface ForkHistoryCursor {
+  cursor?: string;
+  anchorFound: boolean;
+  tailTurnId?: string;
+  loadedCount?: number;
+  complete: boolean;
+}
+
 interface ForkGroupSessionPlan {
   plan: ForkSessionPlan;
   sourceDescription: string;
@@ -489,6 +515,8 @@ export class ProxySessionController {
   private readonly sessionResets = new Map<string, Promise<void>>();
   private readonly resetHistoryOperations = new Map<string, string>();
   private readonly remoteTurnHistoryRefreshes = new Map<string, number>();
+  private readonly turnHistoryHydrations = new Map<string, Promise<boolean>>();
+  private readonly forkHistoryCursors = new Map<string, ForkHistoryCursor>();
   private readonly lastSessionListings = new Map<string, string[]>();
   private readonly threadInitializations = new Map<string, Promise<void>>();
   private readonly llmRetryingSessions = new Set<string>();
@@ -589,6 +617,7 @@ export class ProxySessionController {
         "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,
@@ -826,10 +855,11 @@ export class ProxySessionController {
         "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,
@@ -857,8 +887,9 @@ export class ProxySessionController {
     }
 
     const previous = this.messageQueues.get(message.contextKey) ?? Promise.resolve();
-    const next = previous.catch(() => undefined).then(() =>
-      this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
+    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;
@@ -903,8 +934,8 @@ export class ProxySessionController {
             phase: "command_execute",
           });
         }
-      }),
-    );
+      });
+    });
     this.messageQueues.set(message.contextKey, next);
     await next;
     if (this.messageQueues.get(message.contextKey) === next) this.messageQueues.delete(message.contextKey);
@@ -1022,6 +1053,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") {
           const directory = directoryActionPath(scopedAction.value.directory);
@@ -1077,10 +1109,12 @@ export class ProxySessionController {
           await this.refreshSessionsCardFromAction(scopedAction);
         } 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);
         } else if (kind === "session_archive") {
@@ -1099,6 +1133,7 @@ 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 ?? ""),
@@ -1106,10 +1141,12 @@ export class ProxySessionController {
           );
         } 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);
           else 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") {
           await this.refreshStatusCardFromAction(scopedAction);
@@ -1247,6 +1284,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();
     for (const pending of this.pendingResourceForwards.values()) pending.resolveAttachment(undefined);
@@ -1326,8 +1365,9 @@ 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.");
         }
       }
@@ -1627,9 +1667,17 @@ export class ProxySessionController {
     permissionModes: PermissionMode[];
   }> {
     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();
@@ -1642,19 +1690,12 @@ export class ProxySessionController {
         ? loaded.session.reasoningEffort
         : 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();
       const selected = models.find((candidate) => candidate.id === nextValue);
@@ -1689,12 +1730,12 @@ export class ProxySessionController {
       this.store.updateRuntimeSession(record.localSessionId, { permissionMode: nextValue });
     }
     const session = this.store.getSession(record.localSessionId) ?? record;
-    if (setting) await this.persistAgentExecutionDefaults(session.localSessionId);
+    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,
@@ -1738,7 +1779,7 @@ export class ProxySessionController {
     };
   }
 
-  controlListTaskTurns(localSessionId: string): {
+  async controlListTaskTurns(localSessionId: string): Promise<{
     session: SessionRecord;
     turns: Array<{
       sequence: number;
@@ -1749,17 +1790,18 @@ export class ProxySessionController {
       completedAt?: number;
       current: boolean;
     }>;
-  } {
+  }> {
     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 [{
           sequence: graph[index]!.sequence,
@@ -1777,15 +1819,10 @@ export class ProxySessionController {
   async controlResetTaskToTurn(localSessionId: string, turnId: string): Promise<SessionRecord> {
     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;
   }
 
@@ -1942,6 +1979,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,
@@ -1962,6 +2000,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,
@@ -1994,6 +2036,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":
@@ -2016,9 +2059,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":
@@ -2032,6 +2077,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":
@@ -2309,6 +2355,7 @@ export class ProxySessionController {
       try {
         remote = await runtime.readRemoteSession(session.remoteSessionId);
       } catch (error) {
+        if (error instanceof CodexVersionError) throw error;
         this.logger.warn(
           { error, attemptId: attempt.attemptId, remoteSessionId: session.remoteSessionId },
           "Failed to read the remote task during startup recovery; treating the old local execution as interrupted.",
@@ -2884,8 +2931,7 @@ export class ProxySessionController {
     const anchor = this.store.findTurnAnchorByMessageId(messageId);
     if (!anchor) 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);
   }
 
   private async forkThreadSession(message: IncomingMessage): Promise<void> {
@@ -2991,6 +3037,7 @@ export class ProxySessionController {
   }
 
   private async forkSessionReference(contextKey: string, reference?: string): Promise<void> {
+    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
@@ -3051,35 +3098,24 @@ 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)
@@ -3090,7 +3126,7 @@ export class ProxySessionController {
       );
     const lastTurnId = remote?.lastCompletedTurnId
       ?? (remote?.lastTurnStatus === "completed" ? remote.lastTurnId : undefined)
-      ?? localCompletedTurns.at(-1)?.id;
+      ?? localCompletedTurnId;
     if (!lastTurnId) {
       if (isRunning) {
         throw new Error(`${sourceLabel}正在执行，且还没有已完成轮次可供 fork。请等待当前轮次完成后重试。`);
@@ -3099,8 +3135,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。");
@@ -3146,29 +3181,11 @@ export class ProxySessionController {
       sourceTurnPrompt,
       sourceTurnStartedAt: snapshot?.startedAt ?? sourceTurnCompletedAt,
       sourceTurnCompletedAt,
-      sourceCompletedTurns: remote?.completedTurns
-        ?? (persistedCompletedTurns.length > 0 ? [] : localCompletedTurns),
       sourceWasRunning: isRunning,
       forkedFromHistoricalTurn,
     };
   }
 
-  private localForkCompletedTurns(source: SessionRecord): RemoteCompletedTurnSummary[] {
-    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,
-        };
-      });
-  }
-
   private async prepareForkGroupSession(
     contextKey: string,
     requestedTitle: string | undefined,
@@ -3271,7 +3288,6 @@ export class ProxySessionController {
     contextKey: string,
     plan: ForkSessionPlan,
   ): Promise<ForkSessionResult> {
-    const sourceCompletedTurns = await this.resolveForkSourceCompletedTurns(plan);
     const localSessionId = createId("sess");
     const record = this.store.createSession({
       localSessionId,
@@ -3314,12 +3330,6 @@ export class ProxySessionController {
         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,
@@ -3327,7 +3337,6 @@ export class ProxySessionController {
         sourceTurnPrompt: plan.sourceTurnPrompt,
         sourceTurnStartedAt: plan.sourceTurnStartedAt,
         sourceTurnCompletedAt: plan.sourceTurnCompletedAt,
-        sourceTurnHistoryCount,
         sourceWasRunning: plan.sourceWasRunning,
         forkedLocalSessionId: localSessionId,
         forkedRemoteSessionId: forked.remoteSessionId,
@@ -3343,54 +3352,6 @@ export class ProxySessionController {
     }
   }
 
-  private async resolveForkSourceCompletedTurns(
-    plan: ForkSessionPlan,
-  ): Promise<RemoteCompletedTurnSummary[]> {
-    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);
-  }
-
-  private persistForkSourceHistory(
-    contextKey: string,
-    forkedLocalSessionId: string,
-    plan: ForkSessionPlan,
-    completedTurns: RemoteCompletedTurnSummary[],
-  ): number {
-    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,
-    });
-  }
-
   private persistCompletedTurnHistory(input: {
     localSessionId: string;
     contextKey: string;
@@ -3398,6 +3359,7 @@ export class ProxySessionController {
     remoteSessionId: string;
     completedTurns: RemoteCompletedTurnSummary[];
     fallbackStart: number;
+    replaceParents?: boolean;
   }): number {
     try {
       this.store.importCompletedTurnHistory({
@@ -3405,6 +3367,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;
@@ -3438,82 +3401,202 @@ export class ProxySessionController {
     }
   }
 
-  private async hydrateLegacyForkTurnHistory(
+  private async hydrateTaskTurnHistory(
+    current: SessionRecord,
+    requiredCount = RESET_HISTORY_PAGE_SIZE,
+  ): Promise<boolean> {
+    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);
+      }
+    }
+  }
+
+  private async hydrateForkTurnHistory(
     contextKey: string,
     current: SessionRecord,
-  ): Promise<void> {
-    const source = this.store.getForkHistorySource(current.localSessionId);
-    if (!source || source.sourceTurnHistoryCount !== undefined
-      || this.store.hasImportedForkTurnHistory(current.localSessionId)) return;
-    if (!source.sourceRemoteSessionId) return;
+    requiredCount: number,
+    visited = new Set<string>(),
+  ): Promise<boolean> {
+    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 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<string>();
     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) {
+      if (error instanceof CodexVersionError) throw error;
       this.logger.warn(
         { error, localSessionId: current.localSessionId, sourceRemoteSessionId: source.sourceRemoteSessionId },
-        "Failed to hydrate legacy Fork Turn history; rendering the locally available history.",
+        "Failed to load the requested Fork Turn history page; rendering the locally available history.",
       );
     }
+    return true;
   }
 
   private async hydrateRemoteTurnHistory(
     contextKey: string,
     current: SessionRecord,
-  ): Promise<void> {
-    if (!current.remoteSessionId) return;
+    requiredCount: number,
+  ): Promise<boolean> {
+    if (!current.remoteSessionId) 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<string>();
     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;
   }
 
   private async createProjectSessionFromReference(contextKey: string, reference: string): Promise<void> {
@@ -3560,7 +3643,7 @@ export class ProxySessionController {
       agentName = source.agentName;
       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;
@@ -3569,9 +3652,9 @@ 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) throw error;
+        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.",
@@ -3908,6 +3991,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,
@@ -3925,6 +4009,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,
@@ -4077,7 +4162,8 @@ export class ProxySessionController {
           });
         } catch (error) {
           if (activeWriterThreadId(error)) throw error;
-          if (!(agent.kind === "app-server" && !record.lastTurnId && isMissingRolloutError(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,
@@ -4555,6 +4641,7 @@ export class ProxySessionController {
 
   private async cancel(contextKey: string): Promise<void> {
     const record = this.requireCurrentSession(contextKey);
+    await this.outbound.sendText(contextKey, STOP_TASK_STARTED_MESSAGE);
     await this.cancelSession(record);
   }
 
@@ -4567,6 +4654,7 @@ export class ProxySessionController {
           const goal = await runtime.getGoal(record.localSessionId);
           if (goal?.status === "active") 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.",
@@ -4581,6 +4669,7 @@ export class ProxySessionController {
             ? remote.lastTurnId
             : 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.",
@@ -4628,9 +4717,15 @@ export class ProxySessionController {
     turnId: string,
   ): Promise<void> {
     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);
+    });
+  }
+
+  private async runSessionReset(sessionId: string, operation: () => Promise<void>): Promise<void> {
     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;
@@ -4639,6 +4734,19 @@ export class ProxySessionController {
     }
   }
 
+  private async waitForCurrentSessionReset(contextKey: string): Promise<void> {
+    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;
+    }
+  }
+
   private async resetFromHistoryCard(
     contextKey: string,
     sessionId: string,
@@ -4655,16 +4763,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) {
         this.resetHistoryOperations.delete(sessionId);
@@ -4708,9 +4811,9 @@ export class ProxySessionController {
       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 到已成功完成的轮次。");
     }
@@ -4894,6 +4997,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();
@@ -4911,7 +5015,7 @@ export class ProxySessionController {
       model: model.id,
       effort,
       mode: loaded.session.permissionMode,
-    }, options);
+    }, options, false);
   }
 
   private async openProviderSelector(
@@ -5004,28 +5108,22 @@ export class ProxySessionController {
     contextKey: string,
     settings: { provider: string; model: string; effort: string; mode: PermissionMode },
     options: ModelCardOptions = {},
+    announceStart = true,
   ): Promise<void> {
     const record = options.sessionId
       ? this.requireSession(contextKey, options.sessionId)
       : this.requireCurrentSession(contextKey);
+    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)}`,
@@ -5044,6 +5142,30 @@ export class ProxySessionController {
     }
   }
 
+  private async changeProviderSettings(loaded: LoadedSession, settings: RuntimeExecutionSettings): Promise<RuntimeSession> {
+    if (!loaded.runtime.setExecutionSettings) throw new Error("当前运行时不支持 Provider 设置。");
+    const persist = async (candidate: RuntimeSession): Promise<void> => {
+      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);
+  }
+
   private async assertProviderModelSettings(
     loaded: LoadedSession,
     modelProvider: string,
@@ -5464,7 +5586,9 @@ export class ProxySessionController {
   private async setTitle(contextKey: string, title: string): Promise<void> {
     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 loaded.session.title = normalizedTitle;
     this.store.updateRuntimeSession(loaded.record.localSessionId, { title: normalizedTitle });
@@ -5597,9 +5721,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)
@@ -5641,13 +5765,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: ResetHistoryCardEntry[] = 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]!;
       const summary = truncateText(
@@ -5702,7 +5826,9 @@ export class ProxySessionController {
     const card = this.cardRenderer.renderResetHistoryCard({
       entries,
       footerLines: [
-        runningTurn
+        hasMoreHistory
+          ? `第 ${page + 1} 页 · 已加载 ${total} 个 turn`
+          : runningTurn
           ? `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个 turn（${completedTurns.length} 个已完成，1 个运行中）`
           : `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个已完成 turn`,
         ...(resettingTurnId ? ["正在 Reset 到所选轮次，请稍候…"] : []),
@@ -5912,6 +6038,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);
   }
 
@@ -6216,7 +6343,7 @@ export class ProxySessionController {
 
   private async resolveRemoteCodexSession(
     reference: string,
-    options: { forFork?: boolean } = {},
+    options: { forFork?: boolean; view?: "metadata" | "latest" | "latest-full" } = {},
   ): Promise<AgentRemoteSession> {
     const scoped = parseRemoteSessionReference(reference);
     const candidates = scoped
@@ -6234,7 +6361,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"),
       } satisfies AgentRemoteSession;
     }));
     const matches = reads
@@ -6260,6 +6387,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);
@@ -6368,6 +6496,10 @@ export class ProxySessionController {
       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;
@@ -6599,27 +6731,28 @@ export class ProxySessionController {
       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: RemoteSessionSummary | undefined;
+    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) {
+          if (error instanceof CodexVersionError) throw error;
+          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to synchronize task status.");
         }
-      } catch (error) {
-        this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to synchronize task status.");
       }
     }
-
     const localCurrent = current;
-    let remote: RemoteSessionSummary | undefined;
     let goal: RuntimeGoal | undefined;
     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.");
         }
       }
@@ -6730,7 +6863,7 @@ export class ProxySessionController {
     reference: string,
     options: StatusCardOptions = {},
   ): Promise<void> {
-    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: CardSection[] = [
       {
@@ -6892,9 +7025,10 @@ export class ProxySessionController {
     return agent;
   }
 
-  private async persistAgentExecutionDefaults(localSessionId: string): Promise<void> {
-    const session = this.store.getSession(localSessionId);
-    if (!session) throw new Error(`找不到任务：${localSessionId}`);
+  private async persistAgentExecutionDefaults(localSessionId: string, candidate?: RuntimeSession): Promise<void> {
+    const record = this.store.getSession(localSessionId);
+    if (!record) throw new Error(`找不到任务：${localSessionId}`);
+    const session = candidate ?? record;
     const agent = this.ensureAgent(session.agentName);
     const observed: AgentExecutionDefaults = {
       ...(session.modelProvider?.trim() ? { modelProvider: session.modelProvider } : {}),
@@ -7329,6 +7463,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],
@@ -7788,11 +7923,6 @@ function runtimeErrorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-function isMissingRolloutError(error: unknown): boolean {
-  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: unknown): boolean {
   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);