@keyou007/agent-bot 0.1.20-alpha.1 → 0.1.21

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,
@@ -57,13 +59,16 @@ import type { AgentRuntimeRegistry } from "../runtime/AgentRuntimeRegistry.js";
 import type {
   AgentRuntime,
   ApprovalDecision,
+  ModelOption,
   PermissionMode,
   RemoteCompletedTurnSummary,
   RemoteSessionActivity,
+  RemoteSessionMetrics,
   RemoteSessionPage,
   RemoteSessionSummary,
   RuntimeGoal,
   RuntimeEvent,
+  RuntimeExecutionSettings,
   RuntimePrompt,
   RuntimeSession,
 } from "../runtime/types.js";
@@ -84,6 +89,7 @@ import {
   type TurnAnchorRecord,
 } from "../state/StateStore.js";
 import { createId } from "../utils/id.js";
+import { formatStorageSize } from "../utils/formatStorageSize.js";
 import { truncateMiddle, truncateText } from "../utils/markdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import {
@@ -187,6 +193,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([
@@ -238,7 +260,7 @@ const HELP_COMMAND_SECTIONS: Array<{
         usage: "[序号或任务 ID]",
         description: "从当前或指定任务最近完成轮次创建分支",
       },
-      { command: "/turns", description: "浏览历史轮次，并可 Reset 对话上下文" },
+      { command: "/turns", usage: "[Turn ID 或序号]", description: "浏览历史轮次，并可 Reset 对话上下文；带参数查看运行详情" },
       {
         command: "/title",
         usage: "&#60;新标题&#62;",
@@ -409,7 +431,6 @@ interface ForkSessionPlan {
   sourceTurnPrompt?: string;
   sourceTurnStartedAt?: number;
   sourceTurnCompletedAt?: number;
-  sourceCompletedTurns?: RemoteCompletedTurnSummary[];
   sourceWasRunning: boolean;
   forkedFromHistoricalTurn: boolean;
 }
@@ -419,6 +440,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 +518,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 +620,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 +858,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 +890,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 +937,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 +1056,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 +1112,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 +1136,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 +1144,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 +1287,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 +1368,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.");
         }
       }
@@ -1393,6 +1436,7 @@ export class ProxySessionController {
         scopedRecord.title,
         scopedRecord.cwd,
         this.agentLabel(scopedRecord.agentName),
+        scopedRecord.model,
       );
       const promptMessageId = await this.outbound.withReplyTarget(
         responseContextKey,
@@ -1627,42 +1671,36 @@ 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();
-      const model = models.find((candidate) => candidate.id === loaded.session.model)
-        ?? models.find((candidate) => candidate.isDefault);
+      const models = await loaded.runtime.listModels(nextValue, loaded.session.model);
+      const model = selectProviderModel(models, loaded.session.model);
       if (!model) throw new Error("The current runtime has no model available for a Provider change.");
-      const effort = model.supportedReasoningEfforts.some(
-        (candidate) => candidate.value === loaded.session.reasoningEffort,
-      )
-        ? 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, {
+      const effort = selectProviderReasoningEffort(model, loaded.session.reasoningEffort);
+      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 models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
       const selected = models.find((candidate) => candidate.id === nextValue);
       if (!selected) throw new Error(`Unknown model: ${nextValue}`);
       const currentEffort = loaded.session.reasoningEffort;
-      const nextEffort = currentEffort && selected.supportedReasoningEfforts.some(
-        (candidate) => candidate.value === currentEffort,
-      )
+      const nextEffort = currentEffort && (selected.supportedReasoningEfforts.length === 0
+        || selected.supportedReasoningEfforts.some((candidate) => candidate.value === currentEffort))
         ? currentEffort
         : selected.defaultReasoningEffort;
       await loaded.runtime.setModel(record.localSessionId, nextValue);
@@ -1671,7 +1709,7 @@ export class ProxySessionController {
       }
       this.store.updateRuntimeSession(record.localSessionId, { model: nextValue, reasoningEffort: nextEffort });
     } else if (setting === "thinking" && nextValue) {
-      const models = await loaded.runtime.listModels();
+      const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
       const currentModel = models.find((candidate) => candidate.id === loaded.session.model)
         ?? models.find((candidate) => candidate.isDefault);
       if (!currentModel) throw new Error("The current runtime has no model with configurable reasoning effort.");
@@ -1689,12 +1727,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);
-    const models = await loaded.runtime.listModels();
+    if (setting && setting !== "provider") await this.persistAgentExecutionDefaults(session.localSessionId);
+    const models = await loaded.runtime.listModels(session.modelProvider, session.model);
     const currentModel = models.find((candidate) => candidate.id === session.model)
       ?? models.find((candidate) => candidate.isDefault);
     const providers = loaded.runtime.listModelProviders
-      ? await loaded.runtime.listModelProviders()
+      ? await this.modelProviderOptions(loaded)
       : [];
     return {
       session,
@@ -1738,7 +1776,7 @@ export class ProxySessionController {
     };
   }
 
-  controlListTaskTurns(localSessionId: string): {
+  async controlListTaskTurns(localSessionId: string): Promise<{
     session: SessionRecord;
     turns: Array<{
       sequence: number;
@@ -1749,17 +1787,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 +1816,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 +1976,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 +1997,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 +2033,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 +2056,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,7 +2074,13 @@ export class ProxySessionController {
         await this.setGroupMute(contextKey, command.enabled);
         return;
       case "turns":
-        await this.openResetHistory(contextKey);
+        if (command.turnReference) {
+          await this.outbound.sendText(contextKey, "正在读取轮次运行信息，请稍后。");
+          await this.openTurnDetails(contextKey, command.turnReference);
+        } else {
+          await this.outbound.sendText(contextKey, LIST_TURNS_STARTED_MESSAGE);
+          await this.openResetHistory(contextKey);
+        }
         return;
       case "model":
         await this.openExecutionSettings(contextKey, "model");
@@ -2070,6 +2118,7 @@ export class ProxySessionController {
         session.title,
         session.cwd,
         this.agentLabel(session.agentName),
+        session.model,
       );
       if (!session.lastTurnId) continue;
       void this.outbound.resumeDelivery(session.localSessionId, turnContextKey, session.lastTurnId).catch((error: unknown) => {
@@ -2156,6 +2205,7 @@ export class ProxySessionController {
           session.title,
           session.cwd,
           this.agentLabel(session.agentName),
+          session.model,
         );
       }
       try {
@@ -2284,6 +2334,7 @@ export class ProxySessionController {
       session.title,
       session.cwd,
       this.agentLabel(session.agentName),
+      session.model,
     );
     if (announce) {
       await this.outbound.withReplyTarget(contextKey, replyTarget, () =>
@@ -2309,6 +2360,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.",
@@ -2564,6 +2616,7 @@ export class ProxySessionController {
         record.title,
         record.cwd,
         this.agentLabel(record.agentName),
+        record.model,
       );
       await this.outbound.startPendingTurn(
         record.localSessionId,
@@ -2922,6 +2975,7 @@ export class ProxySessionController {
       forkTitle,
       source.cwd,
       this.agentLabel(source.agentName),
+      source.model,
     );
 
     try {
@@ -2990,6 +3044,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
@@ -3050,35 +3105,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)
@@ -3089,7 +3133,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。请等待当前轮次完成后重试。`);
@@ -3098,8 +3142,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。");
@@ -3145,29 +3188,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,
@@ -3270,7 +3295,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,
@@ -3312,12 +3336,7 @@ export class ProxySessionController {
         forked.title ?? plan.forkTitle,
         plan.cwd,
         this.agentLabel(plan.agentName),
-      );
-      const sourceTurnHistoryCount = this.persistForkSourceHistory(
-        contextKey,
-        localSessionId,
-        plan,
-        sourceCompletedTurns,
+        plan.model,
       );
       this.store.audit(contextKey, "session_forked", {
         sourceLocalSessionId: plan.source?.localSessionId,
@@ -3326,7 +3345,6 @@ export class ProxySessionController {
         sourceTurnPrompt: plan.sourceTurnPrompt,
         sourceTurnStartedAt: plan.sourceTurnStartedAt,
         sourceTurnCompletedAt: plan.sourceTurnCompletedAt,
-        sourceTurnHistoryCount,
         sourceWasRunning: plan.sourceWasRunning,
         forkedLocalSessionId: localSessionId,
         forkedRemoteSessionId: forked.remoteSessionId,
@@ -3342,54 +3360,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;
@@ -3397,6 +3367,7 @@ export class ProxySessionController {
     remoteSessionId: string;
     completedTurns: RemoteCompletedTurnSummary[];
     fallbackStart: number;
+    replaceParents?: boolean;
   }): number {
     try {
       this.store.importCompletedTurnHistory({
@@ -3404,6 +3375,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;
@@ -3437,82 +3409,210 @@ export class ProxySessionController {
     }
   }
 
-  private async hydrateLegacyForkTurnHistory(
+  private async hydrateTaskTurnHistory(
+    current: SessionRecord,
+    requiredCount = RESET_HISTORY_PAGE_SIZE,
+    targetTurnId?: string,
+  ): 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, new Set(), targetTurnId);
+      }
+      return this.hydrateRemoteTurnHistory(current.contextKey, current, requiredCount, targetTurnId);
+    })();
+    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>(),
+    targetTurnId?: 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 (!targetTurnId && 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,
+        targetTurnId,
+      );
+      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 && (targetTurnId
+        ? !this.store.hasTaskHistoryTurn(current.localSessionId, targetTurnId)
+        : (state.loadedCount ?? 0) < neededInheritedCount)) {
+        const remaining = targetTurnId ? RESET_HISTORY_PAGE_SIZE : 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,
+    targetTurnId?: string,
+  ): 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 && (targetTurnId
+        ? !this.store.hasTaskHistoryTurn(current.localSessionId, targetTurnId)
+        : (state.loadedCount ?? 0) < requiredCount)) {
+        const page = await runtime.listRemoteTurnSummaries(current.remoteSessionId, {
+          cursor: state.cursor,
+          limit: targetTurnId ? RESET_HISTORY_PAGE_SIZE : 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> {
@@ -3559,7 +3659,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;
@@ -3568,9 +3668,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.",
@@ -3754,6 +3854,7 @@ export class ProxySessionController {
       initialTitle,
       sessionCwd,
       this.agentLabel(agentName),
+      resolvedExecutionSettings.model,
     );
     const runtime = this.runtimes.forAgent(agentName);
     try {
@@ -3771,6 +3872,7 @@ export class ProxySessionController {
         permissionMode: resolvedExecutionSettings.permissionMode ?? "auto",
       });
       this.persistRuntimeSession(record, session, session.activeTurnId ? "running" : "ready");
+      this.outbound.updateSessionModel(localSessionId, session.model);
       const saved = this.store.getSession(localSessionId) ?? record;
       if (announce) {
         const task = initialTitle ? `${initialTitle}（${session.remoteSessionId}）` : session.remoteSessionId;
@@ -3907,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 prepared = await this.prepareForkGroupSession(sourceContextKey, requestedTitle, incomingMessage);
     await this.forkPreparedSessionToFeishuGroup(
       sourceContextKey,
@@ -3924,6 +4027,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,
@@ -4041,6 +4145,7 @@ export class ProxySessionController {
       record.title,
       record.cwd,
       this.agentLabel(record.agentName),
+      record.model,
     );
     const loading = (async (): Promise<LoadedSession> => {
       if (record.lastTurnId) {
@@ -4076,7 +4181,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,
@@ -4190,14 +4296,20 @@ export class ProxySessionController {
       });
     }
 
+    const enrichedEvent: RuntimeEvent = event.type === "context_compaction"
+      ? {
+          ...event,
+          turnCount: event.turnCount ?? this.store.countTaskTurns(event.sessionId),
+        }
+      : event;
     const presentationEvent = event.type === "turn_failed"
       && isRetryableLlmTurnFailure(event.message)
       && (failedAttempt?.retryCount ?? 0) >= MAX_LLM_TURN_RETRIES
       ? {
-          ...event,
+          ...enrichedEvent,
           message: `${event.message}\n\n已自动重试 ${MAX_LLM_TURN_RETRIES} 次，仍未成功。`,
         }
-      : event;
+      : enrichedEvent;
     let presentationError: unknown;
     try {
       await this.outbound.onEvent(presentationEvent);
@@ -4554,6 +4666,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);
   }
 
@@ -4566,6 +4679,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.",
@@ -4580,6 +4694,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.",
@@ -4627,9 +4742,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;
@@ -4638,6 +4759,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,
@@ -4654,16 +4788,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);
@@ -4707,9 +4836,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 到已成功完成的轮次。");
     }
@@ -4759,6 +4888,7 @@ export class ProxySessionController {
       forked.title ?? current.title,
       current.cwd,
       this.agentLabel(current.agentName),
+      current.model,
     );
     this.store.audit(contextKey, "session_reset_to_turn", {
       localSessionId: current.localSessionId,
@@ -4822,12 +4952,13 @@ export class ProxySessionController {
       };
     if (record) {
       const loaded = await this.loadSession(record);
-      const models = await loaded.runtime.listModels();
-      const currentModel = models.find((model) => model.id === loaded.session.model)
-        ?? models.find((model) => model.isDefault);
       const providerSupported = loaded.runtime.kind === "codex" && Boolean(loaded.runtime.listModelProviders);
       const providers = providerSupported ? await this.modelProviderOptions(loaded) : [];
       const currentProvider = loaded.session.modelProvider ?? providers.find((provider) => provider.isDefault)?.id;
+      const models = await loaded.runtime.listModels(currentProvider, loaded.session.model);
+      const currentModel = models.find((model) => model.id === loaded.session.model)
+        ?? models.find((model) => model.isDefault)
+        ?? models[0];
       const currentEffort = currentModel?.supportedReasoningEfforts.some(
         (option) => option.value === loaded.session.reasoningEffort,
       )
@@ -4893,24 +5024,19 @@ export class ProxySessionController {
     const record = options.sessionId
       ? this.requireSession(contextKey, options.sessionId)
       : this.requireCurrentSession(contextKey);
+    await this.outbound.sendText(contextKey, `正在切换到 Provider ${modelProvider}，请稍后。`);
     const loaded = await this.loadSession(record);
     await this.assertModelProvider(loaded, modelProvider);
-    const models = await loaded.runtime.listModels();
-    const model = models.find((candidate) => candidate.id === loaded.session.model)
-      ?? models.find((candidate) => candidate.isDefault);
+    const models = await loaded.runtime.listModels(modelProvider, loaded.session.model);
+    const model = selectProviderModel(models, loaded.session.model);
     if (!model) throw new Error("当前运行时没有可用于 Provider 切换的模型。");
-    const effort = model.supportedReasoningEfforts.some(
-      (candidate) => candidate.value === loaded.session.reasoningEffort,
-    )
-      ? loaded.session.reasoningEffort
-      : model.defaultReasoningEffort ?? model.supportedReasoningEfforts[0]?.value;
-    if (!effort) throw new Error(`模型 ${model.id} 没有可用于 Provider 切换的思考强度。`);
+    const effort = selectProviderReasoningEffort(model, loaded.session.reasoningEffort);
     await this.applyProviderSettings(contextKey, {
       provider: modelProvider,
       model: model.id,
       effort,
       mode: loaded.session.permissionMode,
-    }, options);
+    }, options, false);
   }
 
   private async openProviderSelector(
@@ -4929,11 +5055,11 @@ export class ProxySessionController {
   ): Promise<void> {
     const loaded = await this.loadSession(this.requireSession(contextKey, sessionId));
     await this.assertModelProvider(loaded, modelProvider);
-    const models = await loaded.runtime.listModels();
+    const models = await loaded.runtime.listModels(modelProvider, loaded.session.model);
     const card = this.cardRenderer.renderModelSelector({
       sessionId,
       contextKey,
-      currentModel: loaded.session.model ?? models.find((model) => model.isDefault)?.id,
+      currentModel: selectProviderModel(models, loaded.session.model)?.id,
       reasoningEffort: loaded.session.reasoningEffort,
       models,
       modelProvider,
@@ -4953,21 +5079,24 @@ export class ProxySessionController {
   ): Promise<void> {
     const loaded = await this.loadSession(this.requireSession(contextKey, sessionId));
     await this.assertModelProvider(loaded, modelProvider);
-    const models = await loaded.runtime.listModels();
+    const models = await loaded.runtime.listModels(modelProvider, model);
     const selected = models.find((candidate) => candidate.id === model);
     if (!selected) throw new Error(`未知模型：${model}`);
-    const currentEffort = selected.supportedReasoningEfforts.some(
+    const options = selected.supportedReasoningEfforts.length > 0
+      ? selected.supportedReasoningEfforts
+      : [{ value: selectProviderReasoningEffort(selected, loaded.session.reasoningEffort) }];
+    const currentEffort = options.some(
       (option) => option.value === loaded.session.reasoningEffort,
     )
       ? loaded.session.reasoningEffort
-      : selected.defaultReasoningEffort;
+      : selected.defaultReasoningEffort ?? options[0]?.value;
     const card = this.cardRenderer.renderReasoningSelector({
       sessionId,
       contextKey,
       modelProvider,
       model,
       currentEffort,
-      options: selected.supportedReasoningEfforts,
+      options,
       permissionMode,
       unifiedSettings: true,
     });
@@ -5003,28 +5132,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)}`,
@@ -5043,6 +5166,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,
@@ -5050,9 +5197,10 @@ export class ProxySessionController {
     effort: string,
   ): Promise<void> {
     await this.assertModelProvider(loaded, modelProvider);
-    const selected = (await loaded.runtime.listModels()).find((candidate) => candidate.id === model);
+    const selected = (await loaded.runtime.listModels(modelProvider, model)).find((candidate) => candidate.id === model);
     if (!selected) throw new Error(`未知模型：${model}`);
-    if (!selected.supportedReasoningEfforts.some((option) => option.value === effort)) {
+    if (selected.supportedReasoningEfforts.length > 0
+      && !selected.supportedReasoningEfforts.some((option) => option.value === effort)) {
       const supported = selected.supportedReasoningEfforts.map((option) => option.value).join("、") || "无";
       throw new Error(`模型 ${model} 不支持思考强度 ${effort}。支持的强度：${supported}`);
     }
@@ -5086,12 +5234,13 @@ export class ProxySessionController {
       ? this.requireSession(contextKey, options.sessionId)
       : this.requireCurrentSession(contextKey);
     const loaded = await this.loadSession(record);
-    const models = await loaded.runtime.listModels();
+    const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
     const selected = models.find((item) => item.id === model);
     if (!selected) throw new Error(`未知模型：${model}`);
     const currentEffort = loaded.session.reasoningEffort;
     const compatible = currentEffort
-      ? selected.supportedReasoningEfforts.some((option) => option.value === currentEffort)
+      ? selected.supportedReasoningEfforts.length === 0
+        || selected.supportedReasoningEfforts.some((option) => option.value === currentEffort)
       : false;
     const nextEffort = compatible ? currentEffort : selected.defaultReasoningEffort;
 
@@ -5463,7 +5612,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 });
@@ -5520,7 +5671,7 @@ export class ProxySessionController {
       ? this.requireSession(contextKey, options.sessionId)
       : this.requireCurrentSession(contextKey);
     const loaded = await this.loadSession(record);
-    const models = await loaded.runtime.listModels();
+    const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
     const currentModel = models.find((item) => item.id === loaded.session.model)
       ?? models.find((item) => item.isDefault);
     if (!currentModel) throw new Error("当前运行时没有可配置思考强度的模型。");
@@ -5585,6 +5736,71 @@ export class ProxySessionController {
     );
   }
 
+  private taskTurnIds(current: SessionRecord): string[] {
+    const ids = this.store.listTaskTurnGraphIndex(current.localSessionId).map((turn) => turn.turnId);
+    if (current.lastTurnStatus === "running" && current.lastTurnId && !ids.includes(current.lastTurnId)) {
+      ids.unshift(current.lastTurnId);
+    }
+    return ids;
+  }
+
+  private runningTurnSnapshot(current: SessionRecord, turnId: string): TurnViewState {
+    const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(turnId));
+    if (snapshot) return snapshot;
+    const attempt = this.store.findIncompleteTurnAttemptByTurnId(turnId);
+    const startedAt = Date.parse(attempt?.createdAt ?? "");
+    return {
+      sessionId: current.localSessionId,
+      turnId,
+      taskTitle: current.title,
+      prompt: attempt?.promptText ?? current.title,
+      status: "running",
+      startedAt: Number.isFinite(startedAt) ? startedAt : Date.now(),
+      assistantText: "", plan: [], activities: [], completedTools: [], failedTools: [], fileSummary: [],
+    };
+  }
+
+  private async openTurnDetails(contextKey: string, reference: string): Promise<void> {
+    const current = this.requireCurrentSession(contextKey);
+    let turnId: string | undefined;
+    if (/^\d+$/.test(reference)) {
+      const index = Number(reference);
+      const runningCount = current.lastTurnStatus === "running" && current.lastTurnId ? 1 : 0;
+      const hasMore = index > runningCount && this.isCodexSession(current)
+        ? await this.hydrateTaskTurnHistory(current, index - runningCount)
+        : false;
+      turnId = this.taskTurnIds(current)[index - 1];
+      if (!turnId) {
+        throw new Error(hasMore
+          ? "轮次历史暂未加载完成，请稍后重试。"
+          : `未找到序号为 ${reference} 的轮次。请发送 /turn 查看当前轮次序号。`);
+      }
+    } else {
+      const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(reference));
+      if (snapshot && (snapshot.sessionId === current.localSessionId
+        || this.store.hasTaskHistoryTurn(current.localSessionId, reference))) {
+        turnId = reference;
+      } else if (current.lastTurnStatus === "running" && current.lastTurnId === reference) {
+        turnId = reference;
+      } else if (this.isCodexSession(current) && (!snapshot || this.store.getForkHistorySource(current.localSessionId))) {
+        const hasMore = await this.hydrateTaskTurnHistory(current, 0, reference);
+        if (this.store.hasTaskHistoryTurn(current.localSessionId, reference)) turnId = reference;
+        else if (hasMore) throw new Error("轮次历史暂未加载完成，请稍后重试。");
+      }
+      if (!turnId && snapshot) throw new Error("这个 Turn 不属于当前任务的历史。请先切换到对应任务。");
+      if (!turnId) throw new Error(`未找到当前任务的 Turn：${reference}`);
+    }
+
+    if (current.lastTurnStatus === "running" && current.lastTurnId === turnId
+      && !this.store.getTurnPromptSummary(turnId)) {
+      await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderTurnDetails(
+        this.runningTurnSnapshot(current, turnId),
+      ));
+      return;
+    }
+    await this.outbound.showDetails(contextKey, turnId);
+  }
+
   private async openResetHistory(
     contextKey: string,
     options: ResetHistoryCardOptions = {},
@@ -5596,35 +5812,19 @@ 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)
       ? current.lastTurnId
       : undefined;
-    const persistedRunningSnapshot = runningTurnId
-      ? turnViewSnapshot(this.store.getTurnSnapshot(runningTurnId))
-      : undefined;
     const runningAttempt = runningTurnId
       ? this.store.findIncompleteTurnAttemptByTurnId(runningTurnId)
       : undefined;
-    const attemptStartedAt = Date.parse(runningAttempt?.createdAt ?? "");
     const runningSnapshot: TurnViewState | undefined = runningTurnId
-      ? persistedRunningSnapshot ?? {
-          sessionId: current.localSessionId,
-          turnId: runningTurnId,
-          prompt: runningAttempt?.promptText ?? current.title,
-          status: "running",
-          startedAt: Number.isFinite(attemptStartedAt) ? attemptStartedAt : Date.now(),
-          assistantText: "",
-          plan: [],
-          activities: [],
-          completedTools: [],
-          failedTools: [],
-          fileSummary: [],
-        }
+      ? this.runningTurnSnapshot(current, runningTurnId)
       : undefined;
     const runningTurn = runningTurnId && runningSnapshot
       ? {
@@ -5640,13 +5840,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(
@@ -5701,7 +5901,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 到所选轮次，请稍候…"] : []),
@@ -5911,6 +6113,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);
   }
 
@@ -6215,7 +6418,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
@@ -6233,7 +6436,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
@@ -6259,6 +6462,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);
@@ -6271,6 +6475,7 @@ export class ProxySessionController {
         existing.title,
         existing.cwd,
         this.agentLabel(existing.agentName),
+        existing.model,
       );
       await this.outbound.sendText(contextKey, `已切换到任务：${existing.title ?? existing.remoteSessionId ?? taskId}`);
       return;
@@ -6304,6 +6509,7 @@ export class ProxySessionController {
       remote.title ?? remote.preview,
       remote.cwd,
       this.agentLabel(agentName),
+      remote.model,
     );
     await this.outbound.sendText(
       contextKey,
@@ -6367,6 +6573,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;
@@ -6598,27 +6808,29 @@ 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;
+    let metrics: RemoteSessionMetrics | 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.");
         }
       }
@@ -6630,6 +6842,13 @@ export class ProxySessionController {
           this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect Agent goal status.");
         }
       }
+      if (runtime.readRemoteSessionMetrics) {
+        try {
+          metrics = await runtime.readRemoteSessionMetrics(current.remoteSessionId);
+        } catch (error) {
+          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect App Server task metrics.");
+        }
+      }
     }
 
     if (current) current = mergeRemoteTaskStatus(current, remote);
@@ -6664,6 +6883,7 @@ export class ProxySessionController {
         `**Agent**：${cardCode(agent.title)}`,
         `**权限 / 任务范围**：${current.permissionMode === "confirm" ? "执行前确认" : "自动执行"} / ${detectProjectlessWorkspace(current.cwd) ? "未指定项目" : "指定项目"}`,
         `**App Server 任务 ID**：${cardCode(current.remoteSessionId ?? "尚未创建")}`,
+        statusTaskMetricsLine(metrics?.turnCount ?? this.store.countTaskTurns(current.localSessionId), metrics?.storageBytes),
         `**当前执行 / 排队消息**：${activeTurnId ? cardCode(activeTurnId) : "无"} / ${queued} 条`,
         `**创建时间 / 最近活动**：${formatStatusTime(current.createdAt)} / ${formatStatusTime(current.updatedAt)}`,
       );
@@ -6729,7 +6949,16 @@ 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 runtime = this.runtimes.forAgent(agentName);
+    let metrics: RemoteSessionMetrics | undefined;
+    if (runtime.readRemoteSessionMetrics) {
+      try {
+        metrics = await runtime.readRemoteSessionMetrics(remote.id);
+      } catch (error) {
+        this.logger.warn({ error, remoteSessionId: remote.id }, "Failed to inspect App Server task metrics.");
+      }
+    }
     const actionReference = remoteSessionReference(agentName, remote.id);
     const sections: CardSection[] = [
       {
@@ -6740,6 +6969,7 @@ export class ProxySessionController {
           `**状态 / 当前任务**：${remoteSessionDetailStatus(remote)} / 未切换`,
           `**Agent**：${cardCode(agentName)}`,
           `**App Server 任务 ID**：${cardCode(remote.id)}`,
+          statusTaskMetricsLine(metrics?.turnCount, metrics?.storageBytes),
           `**最近回合**：${cardCode(remote.lastTurnId ?? "无")}　${remoteTurnStatusLabel(remote.lastTurnStatus)}`,
           `**创建时间 / 最近活动**：${formatRemoteTime(remote.createdAt)} / ${formatRemoteTime(latestRemoteTimestamp(remote.recencyAt, remote.updatedAt))}`,
         ],
@@ -6891,9 +7121,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 } : {}),
@@ -7328,6 +7559,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],
@@ -7787,11 +8019,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);
@@ -7970,6 +8197,12 @@ function formatDuration(milliseconds: number): string {
   return milliseconds < 1_000 ? `${milliseconds}ms` : `${(milliseconds / 1_000).toFixed(1)}s`;
 }
 
+function statusTaskMetricsLine(turnCount: number | undefined, storageBytes: number | undefined): string {
+  const turns = turnCount === undefined ? "未知" : `${Math.max(0, Math.round(turnCount)).toLocaleString("en-US")} 轮`;
+  const storage = storageBytes === undefined ? "未知" : formatStorageSize(storageBytes);
+  return `**已执行轮次 / 磁盘占用**：${turns} / ${storage}`;
+}
+
 function formatStatusTime(value: string): string {
   const date = new Date(value);
   if (Number.isNaN(date.getTime())) return value;
@@ -8443,6 +8676,23 @@ function deduplicateFileReferences(
   });
 }
 
+function selectProviderModel(models: ModelOption[], previousModel?: string): ModelOption | undefined {
+  return models.find((model) => model.id === previousModel)
+    ?? models.find((model) => model.isDefault)
+    ?? models[0];
+}
+
+function selectProviderReasoningEffort(model: ModelOption, previousEffort?: string): string {
+  if (previousEffort && (model.supportedReasoningEfforts.length === 0
+    || model.supportedReasoningEfforts.some((option) => option.value === previousEffort))) {
+    return previousEffort;
+  }
+  return model.defaultReasoningEffort
+    ?? model.supportedReasoningEfforts[0]?.value
+    ?? previousEffort
+    ?? "medium";
+}
+
 function recoveryCardPrompt(prompt: string): string {
   return `恢复重启前的任务：${prompt}`;
 }