@keyou007/agent-bot 0.1.12 → 0.1.13-alpha.1

package/src/proxy/ProxySessionController.ts

@@ -17,11 +17,14 @@ import {
   CardRenderer,
   type CardSection,
   type ExecutionSettingsTab,
+  type ResetHistoryCardEntry,
   type TaskListCardAction,
+  type TaskListCardEntry,
 } from "../feishu/CardRenderer.js";
 import { generateGroupAvatarPng, resolveGroupAvatarProjectName } from "../feishu/GroupAvatarGenerator.js";
 import type { OutboundRouter } from "../presentation/OutboundRouter.js";
 import type { TurnActivity, TurnViewState } from "../presentation/turnViewTypes.js";
+import { buildTurnGraphRows } from "../presentation/turnGraph.js";
 import type { AgentRuntimeRegistry } from "../runtime/AgentRuntimeRegistry.js";
 import type {
   AgentRuntime,
@@ -61,6 +64,7 @@ const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
 const MESSAGE_CANCELLED_REACTION = "CrossMark";
 const SESSION_PAGE_SIZE = 5;
+const RESET_HISTORY_PAGE_SIZE = 10;
 const REMOTE_SESSION_REFERENCE_PREFIX = "agent-runtime:";
 
 interface AgentRemoteSession {
@@ -77,7 +81,7 @@ interface AgentRemoteSessionSummary {
 interface SessionsCardOptions {
   updateMessageId?: string;
   forceSwitchTaskId?: string;
-  visibleCount?: number;
+  page?: number;
 }
 
 interface StatusCardOptions {
@@ -85,6 +89,12 @@ interface StatusCardOptions {
   forceSwitchTaskId?: string;
 }
 
+interface ResetHistoryCardOptions {
+  expectedSessionId?: string;
+  updateMessageId?: string;
+  page?: number;
+}
+
 interface ModelCardOptions {
   sessionId?: string;
   updateMessageId?: string;
@@ -167,8 +177,9 @@ export interface ControlTaskGroupResult {
 
 export interface ProxyLifecycle {
   supervised?: boolean;
-  restart(contextKey: string, force: boolean): Promise<void>;
+  restart(contextKey: string, force: boolean, replyTarget?: MessageReplyTarget): Promise<void>;
   cancelSafeRestart?(scheduleId: number): Promise<boolean>;
+  rememberFeishuUserOpenId?(userOpenId: string): Promise<void> | void;
 }
 
 export type ShellCommandExecutor = (command: string, cwd: string) => Promise<ShellCommandResult>;
@@ -181,6 +192,7 @@ export class ProxySessionController {
   private readonly queuedPromptStarts = new Map<string, Promise<void>>();
   private readonly queuedPromptCards = new Map<string, Map<string, string>>();
   private readonly queuedPromptCardWrites = new Map<string, Promise<void>>();
+  private readonly sessionResets = new Map<string, Promise<void>>();
   private readonly lastSessionListings = new Map<string, string[]>();
   private readonly threadInitializations = new Map<string, Promise<void>>();
   private readonly unsubscribe: Array<() => void> = [];
@@ -240,8 +252,20 @@ export class ProxySessionController {
         "Failed to acknowledge the incoming Feishu message with a reaction.",
       );
     }
+    if (message.chatType === "p2p" && message.userId?.startsWith("ou_")) {
+      try {
+        await this.lifecycle?.rememberFeishuUserOpenId?.(message.userId);
+      } catch (error) {
+        this.logger.warn(
+          { error, messageId: message.messageId },
+          "Failed to persist the first private-chat Lark user Open ID.",
+        );
+      }
+    }
     if (message.chatId && message.chatType) {
-      this.store.recordChatContext(baseChatContextKey(message.contextKey), message.chatType);
+      const chatContextKey = baseChatContextKey(message.contextKey);
+      this.store.recordChatContext(chatContextKey, message.chatType);
+      this.store.markChatActive(chatContextKey);
     }
     const replyTarget = message.replyInThread
       ? { messageId: message.messageId, replyInThread: true as const }
@@ -252,9 +276,6 @@ export class ProxySessionController {
       text: message.text,
       ...(imageCount > 0 ? { imageCount } : {}),
     });
-    if (imageCount > 0 && message.chatId && message.chatType) {
-      this.store.markChatActive(baseChatContextKey(message.contextKey));
-    }
     let localImagePaths: string[] | undefined;
     if (imageCount > 0) {
       try {
@@ -284,17 +305,6 @@ export class ProxySessionController {
       );
       return;
     }
-    if (
-      message.chatId
-      && message.chatType
-      && (
-        command.type === "shell"
-        || (command.type === "prompt" && !message.text.trimStart().startsWith("/"))
-      )
-    ) {
-      this.store.markChatActive(baseChatContextKey(message.contextKey));
-    }
-
     // Operational and read-only commands must remain available even if a prompt operation is slow.
     if (isQueueIndependentCommand(command)) {
       await this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
@@ -369,6 +379,26 @@ export class ProxySessionController {
         } else if (kind === "turn_cancel") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.cancelSession(this.requireSession(contextKey, sessionId));
+        } else if (kind === "turn_reset") {
+          const sessionId = String(scopedAction.value.sessionId ?? "");
+          await this.resetCurrentSessionToTurn(
+            contextKey,
+            sessionId,
+            String(scopedAction.value.turnId ?? ""),
+          );
+          if (scopedAction.value.cardView === "reset_history") {
+            await this.openResetHistory(contextKey, {
+              expectedSessionId: sessionId,
+              updateMessageId: requiredCardMessageId(scopedAction.messageId),
+              page: resetHistoryPageValue(scopedAction.value.page),
+            });
+          }
+        } else if (kind === "turn_reset_page") {
+          await this.openResetHistory(contextKey, {
+            expectedSessionId: String(scopedAction.value.sessionId ?? ""),
+            updateMessageId: requiredCardMessageId(scopedAction.messageId),
+            page: resetHistoryPageValue(scopedAction.value.page),
+          });
         } else if (kind === "queued_prompt_cancel") {
           await this.cancelQueuedPrompt(scopedAction);
         } else if (kind === "safe_restart_cancel") {
@@ -383,17 +413,17 @@ export class ProxySessionController {
           if (!cancelled) {
             await this.outbound.sendText(contextKey, "该安全重启计划已失效，请查看最新状态卡片。");
           }
-        } else if (kind === "session_more") {
-          await this.refreshSessionsCardFromAction(scopedAction, undefined, true);
+        } else if (kind === "session_page") {
+          await this.refreshSessionsCardFromAction(scopedAction);
         } else if (kind === "session_switch") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.switchSession(contextKey, sessionId);
           if (scopedAction.value.cardView === "status") await this.refreshStatusCardFromAction(scopedAction);
-          else await this.refreshSessionsCardFromAction(scopedAction);
+          else await this.refreshSessionsCardFromAction(scopedAction, { page: 0 });
         } else if (kind === "session_fork") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.forkSessionReference(contextKey, sessionId);
-          await this.refreshSessionsCardFromAction(scopedAction);
+          await this.refreshSessionsCardFromAction(scopedAction, { page: 0 });
         } else if (kind === "session_fork_group") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.forkSessionReferenceToFeishuGroup(contextKey, sessionId, scopedAction.userId);
@@ -401,7 +431,7 @@ export class ProxySessionController {
         } else if (kind === "session_new") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.createProjectSessionFromReference(contextKey, sessionId);
-          await this.refreshSessionsCardFromAction(scopedAction);
+          await this.refreshSessionsCardFromAction(scopedAction, { page: 0 });
         } else if (kind === "session_new_group") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.createFeishuGroupFromReference(contextKey, sessionId, scopedAction.userId);
@@ -410,7 +440,7 @@ export class ProxySessionController {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.stopSessionReference(contextKey, sessionId);
           if (scopedAction.value.cardView === "status") await this.refreshStatusCardFromAction(scopedAction, sessionId);
-          else await this.refreshSessionsCardFromAction(scopedAction, sessionId);
+          else await this.refreshSessionsCardFromAction(scopedAction, { forceSwitchTaskId: sessionId });
         } else if (kind === "session_status") {
           await this.status(contextKey, String(scopedAction.value.sessionId ?? ""));
         } else if (kind === "session_status_refresh") {
@@ -541,6 +571,7 @@ export class ProxySessionController {
     this.lastSessionListings.clear();
     this.queuedPromptCards.clear();
     this.queuedPromptCardWrites.clear();
+    this.sessionResets.clear();
   }
 
   async controlStopTask(localSessionId: string): Promise<string> {
@@ -564,7 +595,7 @@ export class ProxySessionController {
         try {
           remote = await runtime.readRemoteSession(record.remoteSessionId);
         } catch (error) {
-          this.logger.warn({ error, sessionId: record.localSessionId }, "Failed to inspect Codex task status for CLI.");
+          this.logger.warn({ error, sessionId: record.localSessionId }, "Failed to inspect App Server task status for CLI.");
         }
       }
     }
@@ -668,7 +699,7 @@ export class ProxySessionController {
     const agentName = requestedAgentName?.trim() || source.agentName;
     const agent = this.ensureAgent(agentName);
     if (forceProjectless && agent.kind !== "app-server") {
-      throw new Error("task newgroup --nodir is only available for Codex agents.");
+      throw new Error("task newgroup --nodir is only available for App Server agents.");
     }
     const sourceContextKey = this.outbound.getSessionContextKey(localSessionId) ?? source.contextKey;
     const replyTarget = this.outbound.getSessionReplyTarget(localSessionId);
@@ -831,7 +862,10 @@ export class ProxySessionController {
         return;
       case "restart":
         if (!this.lifecycle) throw new Error("当前运行方式不支持自动重启。");
-        await this.lifecycle.restart(contextKey, command.force === true);
+        await this.lifecycle.restart(contextKey, command.force === true, replyTarget);
+        return;
+      case "turns":
+        await this.openResetHistory(contextKey);
         return;
       case "model":
         await this.openExecutionSettings(contextKey, "model");
@@ -907,7 +941,7 @@ export class ProxySessionController {
     replyTarget?: MessageReplyTarget,
     localImagePaths?: string[],
   ): Promise<void> {
-    if (!text.trim()) throw new Error("请输入要交给 Codex 的内容。");
+    if (!text.trim()) throw new Error("请输入要交给 Agent 的内容。");
     let record = this.currentSession(contextKey);
     if (!record) {
       const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent!);
@@ -981,7 +1015,7 @@ export class ProxySessionController {
         if (messageId) await this.bindMessageReactionToTurn(messageId, record.localSessionId, activeTurnId);
         return;
       } catch (error) {
-        this.logger.debug({ error, sessionId: record.localSessionId, activeTurnId }, "Steering failed; reconciling the Codex thread.");
+        this.logger.debug({ error, sessionId: record.localSessionId, activeTurnId }, "Steering failed; reconciling the App Server thread.");
         let current = loaded.runtime.getSession(record.localSessionId);
         try {
           current = await loaded.runtime.synchronizeSession(record.localSessionId);
@@ -1006,7 +1040,7 @@ export class ProxySessionController {
           } catch (retryError) {
             this.logger.warn(
               { error: retryError, sessionId: record.localSessionId, activeTurnId: current.activeTurnId },
-              "Failed to steer the reconciled Codex turn; queueing prompt.",
+              "Failed to steer the reconciled App Server turn; queueing prompt.",
             );
           }
         }
@@ -1176,7 +1210,7 @@ export class ProxySessionController {
     const agent = this.ensureAgent(source.agentName);
     const runtime = this.runtimes.forAgent(source.agentName);
     if (runtime.kind !== "codex" || !runtime.forkSession) {
-      throw new Error("当前 Codex 运行时不支持 fork 任务。");
+      throw new Error("当前 App Server Agent 不支持 fork 任务。");
     }
 
     const context = this.store.getOrCreateUserContext(message.contextKey, source.agentName);
@@ -1253,14 +1287,14 @@ export class ProxySessionController {
       .map((messageId) => this.store.findTurnAnchorByMessageId(messageId))
       .find((candidate) => candidate !== undefined);
     if (!anchor) {
-      throw new Error("无法确定这个话题对应的 Codex 轮次，因此没有创建分支任务。请从该轮的用户消息、思考卡片或最终回答创建话题。");
+      throw new Error("无法确定这个话题对应的 App Server 轮次，因此没有创建分支任务。请从该轮的用户消息、思考卡片或最终回答创建话题。");
     }
 
     const source = anchor.contextKey
       ? this.store.getSessionForContext(anchor.localSessionId, anchor.contextKey)
       : this.store.getSession(anchor.localSessionId);
     if (!source || !source.remoteSessionId || !this.isCodexSession(source)) {
-      throw new Error("这个话题的来源不是可 fork 的 Codex 任务。");
+      throw new Error("这个话题的来源不是可 fork 的 App Server 任务。");
     }
     if (baseChatContextKey(anchor.contextKey ?? source.contextKey) !== `chat_id:${message.chatId}`) {
       throw new Error("话题来源任务不属于当前会话，已拒绝创建分支。");
@@ -1269,7 +1303,7 @@ export class ProxySessionController {
     const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(anchor.turnId));
     if (isTurnStillRunning(snapshot?.status)
       || (source.lastTurnId === anchor.turnId && source.lastTurnStatus === "running")) {
-      throw new Error("话题对应的轮次仍在执行，Codex 暂时不能从这一轮 fork。请等待该轮完成后再在话题中发送消息。");
+      throw new Error("话题对应的轮次仍在执行，App Server 暂时不能从这一轮 fork。请等待该轮完成后再在话题中发送消息。");
     }
 
     return { anchor, source, snapshot };
@@ -1311,7 +1345,7 @@ export class ProxySessionController {
     }
 
     if (source && (!source.remoteSessionId || !this.isCodexSession(source))) {
-      throw new Error(`${sourceLabel}不是可 fork 的 Codex 任务。`);
+      throw new Error(`${sourceLabel}不是可 fork 的 App Server 任务。`);
     }
 
     let runtime: AgentRuntime;
@@ -1321,20 +1355,20 @@ export class ProxySessionController {
       agentName = source.agentName;
       runtime = this.runtimes.forAgent(agentName);
     } else {
-      if (!taskId) throw new Error("缺少要 fork 的 Codex 任务 ID。");
+      if (!taskId) throw new Error("缺少要 fork 的 App Server 任务 ID。");
       const resolved = await this.resolveRemoteCodexSession(taskId);
       agentName = resolved.agentName;
       runtime = resolved.runtime;
       remote = resolved.remote;
     }
     if (runtime.kind !== "codex" || !runtime.forkSession) {
-      throw new Error("当前 Codex 运行时不支持 fork 任务。");
+      throw new Error("当前 App Server Agent 不支持 fork 任务。");
     }
 
     const remoteSessionId = source?.remoteSessionId ?? remote?.id ?? taskId;
-    if (!remoteSessionId) throw new Error("当前任务尚未创建 Codex 任务 ID，暂时不能 fork。");
+    if (!remoteSessionId) throw new Error("当前任务尚未创建 App Server 任务 ID，暂时不能 fork。");
     if (!runtime.readRemoteSession && !source) {
-      throw new Error("当前 Codex 运行时不支持读取指定任务。");
+      throw new Error("当前 App Server Agent 不支持读取指定任务。");
     }
     remote ??= runtime.readRemoteSession
       ? await runtime.readRemoteSession(remoteSessionId)
@@ -1359,7 +1393,7 @@ export class ProxySessionController {
     const forkedFromHistoricalTurn = isRunning && lastTurnId !== latestTurnId;
 
     const cwd = remote?.cwd || source?.cwd;
-    if (!cwd) throw new Error("指定的 Codex 任务没有可用的工作目录，暂时不能 fork。");
+    if (!cwd) throw new Error("指定的 App Server 任务没有可用的工作目录，暂时不能 fork。");
     const sourceTitle = remote?.title ?? source?.title ?? remote?.preview;
     const forkTitle = normalizeTaskTitle(requestedTitle) ?? this.store.nextForkTitle(sourceTitle);
     const modelProvider = remote?.modelProvider ?? source?.modelProvider;
@@ -1440,16 +1474,16 @@ export class ProxySessionController {
     sourceLabel: string,
   ): ForkSessionPlan {
     if (!source.remoteSessionId || !this.isCodexSession(source)) {
-      throw new Error(`${sourceLabel}不是可 fork 的 Codex 任务。`);
+      throw new Error(`${sourceLabel}不是可 fork 的 App Server 任务。`);
     }
     const runtime = this.runtimes.forAgent(source.agentName);
     if (runtime.kind !== "codex" || !runtime.forkSession) {
-      throw new Error("当前 Codex 运行时不支持 fork 任务。");
+      throw new Error("当前 App Server Agent 不支持 fork 任务。");
     }
 
     const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(lastTurnId));
     if (isTurnStillRunning(snapshot?.status)) {
-      throw new Error(`${sourceLabel}仍在执行，Codex 暂时不能从这一轮 fork。`);
+      throw new Error(`${sourceLabel}仍在执行，App Server 暂时不能从这一轮 fork。`);
     }
     const sourceWasRunning = Boolean(
       runtime.getSession(source.localSessionId)?.activeTurnId
@@ -1578,7 +1612,7 @@ export class ProxySessionController {
     }
     const source = direct ?? this.findStoredSessionByReference(taskId);
     if (source && !this.isCodexSession(source)) {
-      throw new Error("指定任务不是 Codex 任务，暂时不能按项目创建新任务。");
+      throw new Error("指定任务不是 App Server 任务，暂时不能按项目创建新任务。");
     }
 
     let agentName: string;
@@ -1609,7 +1643,7 @@ export class ProxySessionController {
 
     const cwd = remote?.cwd || source?.cwd;
     if (!cwd) {
-      throw new Error("指定的 Codex 任务没有可用的工作目录，暂时不能按项目创建新任务。");
+      throw new Error("指定的 App Server 任务没有可用的工作目录，暂时不能按项目创建新任务。");
     }
     const executionSettings: SessionExecutionSettings = {
       modelProvider: remote?.modelProvider ?? source?.modelProvider,
@@ -1829,7 +1863,7 @@ export class ProxySessionController {
         "群和新任务已创建。",
         `当前任务：${taskDescription}`,
         `当前 Project 目录：${boundProjectCwd ?? "未绑定（Projectless）"}`,
-        `当前 Provider：${task.modelProvider ?? "Codex 默认"}`,
+        `当前 Provider：${task.modelProvider ?? "Agent 默认"}`,
         `当前模型：${task.model ?? "默认"}`,
         `思考强度：${task.reasoningEffort ?? "自动"}`,
         `权限类型：${task.permissionMode === "confirm" ? "执行前确认" : "自动执行"}`,
@@ -1920,7 +1954,7 @@ export class ProxySessionController {
         `已从${prepared.sourceDescription}创建分支。`,
         `当前任务：${taskDescription}`,
         `当前 Project 目录：${boundProjectCwd ?? "未绑定（Projectless）"}`,
-        `当前 Provider：${forked.session.modelProvider ?? "Codex 默认"}`,
+        `当前 Provider：${forked.session.modelProvider ?? "Agent 默认"}`,
         `当前模型：${forked.session.model ?? "默认"}`,
         `思考强度：${forked.session.reasoningEffort ?? "自动"}`,
         `权限类型：${forked.session.permissionMode === "confirm" ? "执行前确认" : "自动执行"}`,
@@ -2010,7 +2044,7 @@ export class ProxySessionController {
           });
         } catch (error) {
           if (!(agent.kind === "app-server" && !record.lastTurnId && isMissingRolloutError(error))) throw error;
-          this.logger.warn({ error, sessionId: record.localSessionId }, "Codex task has no rollout; creating a replacement task.");
+          this.logger.warn({ error, sessionId: record.localSessionId }, "App Server task has no rollout; creating a replacement task.");
           session = await runtime.createSession({
             localSessionId: record.localSessionId,
             agentName: record.agentName,
@@ -2063,6 +2097,24 @@ export class ProxySessionController {
   }
 
   private async handleRuntimeEvent(event: RuntimeEvent): Promise<void> {
+    if ("turnId" in event) {
+      const source = this.store.getSession(event.sessionId);
+      if (source?.remoteSessionId && this.isCodexSession(source)) {
+        this.store.saveTurnRuntimeOrigin(
+          event.turnId,
+          source.localSessionId,
+          source.agentName,
+          source.remoteSessionId,
+        );
+      }
+      if (event.type === "turn_started") {
+        this.store.saveTurnParent(
+          event.turnId,
+          event.sessionId,
+          source?.lastTurnStatus === "completed" ? source.lastTurnId : undefined,
+        );
+      }
+    }
     if (event.type === "session_metadata_updated") {
       this.store.updateRuntimeSession(event.sessionId, { title: event.title });
       this.outbound.updateSessionTitle(event.sessionId, event.title);
@@ -2230,7 +2282,7 @@ export class ProxySessionController {
         } catch (error) {
           this.logger.warn(
             { error, sessionId: record.localSessionId },
-            "Failed to pause the active Codex goal before interrupting its turn.",
+            "Failed to pause the active Agent goal before interrupting its turn.",
           );
         }
       }
@@ -2244,7 +2296,7 @@ export class ProxySessionController {
         } catch (error) {
           this.logger.warn(
             { error, sessionId: record.localSessionId, remoteSessionId: record.remoteSessionId },
-            "Failed to inspect the current Codex turn before interrupting; using the locally tracked turn.",
+            "Failed to inspect the current App Server turn before interrupting; using the locally tracked turn.",
           );
         }
       }
@@ -2258,7 +2310,7 @@ export class ProxySessionController {
         remoteSessionId: record.remoteSessionId,
         turnId,
       });
-      await this.outbound.sendText(record.contextKey, `已向 Codex 发送 Interrupt 请求：${turnId}`);
+      await this.outbound.sendText(record.contextKey, `已向 Agent 发送 Interrupt 请求：${turnId}`);
       return;
     }
 
@@ -2271,6 +2323,111 @@ export class ProxySessionController {
     await loaded.runtime.cancelTurn(record.localSessionId, turnId);
   }
 
+  private async resetCurrentSessionToTurn(
+    contextKey: string,
+    sessionId: string,
+    turnId: string,
+  ): Promise<void> {
+    if (!sessionId || !turnId) throw new Error("无效的 Reset 请求。请使用最新的思考卡片重试。");
+    const previous = this.sessionResets.get(sessionId) ?? Promise.resolve();
+    const reset = previous.catch(() => undefined).then(() =>
+      this.performCurrentSessionReset(contextKey, sessionId, turnId));
+    this.sessionResets.set(sessionId, reset);
+    try {
+      await reset;
+    } finally {
+      if (this.sessionResets.get(sessionId) === reset) this.sessionResets.delete(sessionId);
+    }
+  }
+
+  private async performCurrentSessionReset(
+    contextKey: string,
+    sessionId: string,
+    turnId: string,
+  ): Promise<void> {
+    const current = this.requireCurrentSession(contextKey);
+    if (current.localSessionId !== sessionId) {
+      throw new Error("这张思考卡片不属于当前任务。请先切换回对应任务，再点击 Reset。");
+    }
+    if (!current.remoteSessionId || !this.isCodexSession(current)) {
+      throw new Error("当前任务不是可 Reset 的 App Server 任务。");
+    }
+
+    const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(turnId));
+    if (!snapshot || snapshot.sessionId !== sessionId || snapshot.status !== "completed") {
+      throw new Error("只能将当前任务 Reset 到已成功完成的轮次。");
+    }
+    if (current.lastTurnId === turnId && current.lastTurnStatus === "completed") {
+      await this.outbound.sendText(contextKey, "当前任务已经处于本轮完成后的对话状态，无需 Reset。");
+      return;
+    }
+
+    const runtime = this.runtimes.forAgent(current.agentName);
+    if (runtime.kind !== "codex" || !runtime.forkSession) {
+      throw new Error("当前 App Server Agent 不支持 Reset。");
+    }
+    const loaded = await this.loadSession(current);
+    const activity = await this.assertSessionTurnOwnership(current, runtime);
+    const active = activity?.active
+      ?? Boolean(loaded.session.activeTurnId || current.status === "running" || current.lastTurnStatus === "running");
+    if (active) {
+      throw new Error("当前任务仍在执行。请等待任务完成或先停止任务，再点击 Reset。");
+    }
+
+    const origin = this.store.getTurnRuntimeOrigin(turnId);
+    if (origin && (origin.localSessionId !== sessionId || origin.agentName !== current.agentName)) {
+      throw new Error("这张思考卡片与当前任务不匹配，已拒绝 Reset。");
+    }
+    const sourceRemoteSessionId = origin?.remoteSessionId ?? current.remoteSessionId;
+    const previousRemoteSessionId = current.remoteSessionId;
+    const forked = await runtime.forkSession({
+      localSessionId: current.localSessionId,
+      remoteSessionId: sourceRemoteSessionId,
+      lastTurnId: turnId,
+      agentName: current.agentName,
+      cwd: current.cwd,
+      title: current.title,
+      modelProvider: current.modelProvider,
+      model: current.model,
+      reasoningEffort: current.reasoningEffort,
+      permissionMode: current.permissionMode ?? "auto",
+    });
+    this.persistRuntimeSession(current, forked, "ready");
+    this.store.updateRuntimeSession(current.localSessionId, {
+      lastTurnId: turnId,
+      lastTurnStatus: "completed",
+    });
+    this.outbound.registerSession(
+      current.localSessionId,
+      contextKey,
+      forked.title ?? current.title,
+      current.cwd,
+      this.agentLabel(current.agentName),
+    );
+    this.store.audit(contextKey, "session_reset_to_turn", {
+      localSessionId: current.localSessionId,
+      previousRemoteSessionId,
+      sourceRemoteSessionId,
+      resetTurnId: turnId,
+      forkedRemoteSessionId: forked.remoteSessionId,
+    });
+    const targetSummary = truncateText(
+      (snapshot.prompt ?? snapshot.taskTitle ?? "未记录对话内容").replace(/\s+/g, " ").trim(),
+      100,
+    ) || "未记录对话内容";
+    const targetTime = snapshot.completedAt ?? snapshot.startedAt;
+    await this.outbound.sendText(
+      contextKey,
+      [
+        "已将当前任务重置到：",
+        targetSummary,
+        `完成时间：${targetTime === undefined ? "未知" : formatResetTurnTime(targetTime)}`,
+        `Turn ID：${turnId}`,
+        "后续对话将从该轮完成后的状态继续；本地文件没有回退。",
+      ].join("\n"),
+    );
+  }
+
   private async resolveApproval(action: CardAction): Promise<void> {
     const sessionId = String(action.value.sessionId ?? "");
     const requestId = String(action.value.requestId ?? "");
@@ -2621,7 +2778,7 @@ export class ProxySessionController {
 
     const loaded = await this.loadSession(record);
     if (loaded.runtime.kind !== "codex" || !loaded.runtime.getGoal || !loaded.runtime.setGoal || !loaded.runtime.clearGoal) {
-      throw new Error("当前任务不支持 Codex Goal 模式。");
+      throw new Error("当前 Agent 不支持 Goal 模式。");
     }
 
     if (command.action === "show") {
@@ -2648,7 +2805,7 @@ export class ProxySessionController {
         goal,
         command.action === "pause"
           ? "Goal 已暂停；当前轮次可以完成，但不会继续自动执行。"
-          : "Goal 已恢复，Codex 会继续自动执行。",
+          : "Goal 已恢复，Agent 会继续自动执行。",
         record,
       );
       return;
@@ -2669,7 +2826,7 @@ export class ProxySessionController {
     await this.sendGoalCard(
       contextKey,
       goal,
-      command.action === "edit" ? "Goal 已更新。" : "Goal 已启动，Codex 会持续执行直到完成、暂停或遇到阻塞。",
+      command.action === "edit" ? "Goal 已更新。" : "Goal 已启动，Agent 会持续执行直到完成、暂停或遇到阻塞。",
       record,
     );
   }
@@ -2690,7 +2847,7 @@ export class ProxySessionController {
         title: "任务",
         lines: [
           `**标题**：${cardText(record.title ?? "未命名任务")}`,
-          `**Codex 任务 ID**：${cardText(record.remoteSessionId ?? "尚未创建")}`,
+          `**App Server 任务 ID**：${cardText(record.remoteSessionId ?? "尚未创建")}`,
         ],
       });
     }
@@ -2701,7 +2858,7 @@ export class ProxySessionController {
         "**/goal edit &#60;新目标&#62;**　修改　　**/goal clear**　清除",
       ],
     });
-    await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderSectionsCard("Codex Goal", sections));
+    await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderSectionsCard("Agent Goal", sections));
   }
 
   private async runShellCommand(contextKey: string, command: string): Promise<void> {
@@ -2824,6 +2981,92 @@ export class ProxySessionController {
     await this.outbound.sendText(contextKey, mode === "auto" ? "已切换为自动执行模式。" : "已切换为执行前确认模式。");
   }
 
+  private async openResetHistory(
+    contextKey: string,
+    options: ResetHistoryCardOptions = {},
+  ): Promise<void> {
+    const current = this.requireCurrentSession(contextKey);
+    if (options.expectedSessionId && current.localSessionId !== options.expectedSessionId) {
+      throw new Error("这张历史轮次卡片不属于当前任务。请先切换回对应任务，再重新发送 /turns。");
+    }
+    if (!current.remoteSessionId || !this.isCodexSession(current)) {
+      throw new Error("当前任务不是可 Reset 的 App Server 任务。");
+    }
+    const allTurns = this.store.listCompletedTurnGraph(current.localSessionId, contextKey);
+    const graphRows = buildTurnGraphRows(allTurns.map((turn) => ({
+      turnId: turn.turnId,
+      parentTurnId: turn.parentTurnId,
+    })));
+    const total = allTurns.length;
+    const totalPages = Math.max(1, Math.ceil(total / RESET_HISTORY_PAGE_SIZE));
+    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 entries: ResetHistoryCardEntry[] = turns.flatMap((turn, index) => {
+      const snapshot = turnViewSnapshot(turn.snapshot);
+      if (!snapshot) return [];
+      const graph = graphRows[offset + index]!;
+      const summary = truncateText(
+        (snapshot.prompt ?? snapshot.taskTitle ?? "未记录对话内容").replace(/\s+/g, " ").trim(),
+        100,
+      );
+      const isCurrent = current.lastTurnId === turn.turnId && current.lastTurnStatus === "completed";
+      return [{
+        sequence: graph.sequence,
+        graphNodeLine: graph.nodeLine,
+        graphConnectorLine: graph.connectorLine,
+        lines: [
+          `**${cardText(summary || "未记录对话内容")}**`,
+          `${formatResetTurnTime(snapshot.completedAt ?? snapshot.startedAt)} · ${cardCode(turn.turnId)}`,
+        ],
+        current: isCurrent,
+        actions: isCurrent ? undefined : [{
+          text: "Reset",
+          value: {
+            action: "turn_reset",
+            cardView: "reset_history",
+            sessionId: current.localSessionId,
+            turnId: turn.turnId,
+            contextKey,
+            page: String(page),
+          },
+        }],
+      }];
+    });
+    const pageActions: TaskListCardAction[] = [
+      ...(page > 0 ? [{
+        text: "Previous",
+        value: {
+          action: "turn_reset_page",
+          sessionId: current.localSessionId,
+          contextKey,
+          page: String(page - 1),
+        },
+      }] : []),
+      ...(page < totalPages - 1 ? [{
+        text: "Next",
+        value: {
+          action: "turn_reset_page",
+          sessionId: current.localSessionId,
+          contextKey,
+          page: String(page + 1),
+        },
+      }] : []),
+    ];
+    const card = this.cardRenderer.renderResetHistoryCard({
+      entries,
+      footerLines: [
+        `第 ${page + 1}/${totalPages} 页 · 共 ${total} 个已完成 turn`,
+      ],
+      pageActions,
+    });
+    if (options.updateMessageId) {
+      await this.outbound.updateInteractiveCard(contextKey, options.updateMessageId, card);
+    } else {
+      await this.outbound.sendInteractiveCard(contextKey, card);
+    }
+  }
+
   private async listSessions(
     contextKey: string,
     searchTerm?: string,
@@ -2831,7 +3074,8 @@ export class ProxySessionController {
   ): Promise<void> {
     const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent!);
     const normalizedSearch = searchTerm?.trim().toLowerCase();
-    const visibleCount = options.visibleCount ?? SESSION_PAGE_SIZE;
+    const requestedPage = Math.max(0, Math.trunc(options.page ?? 0));
+    const fetchLimit = (requestedPage + 1) * SESSION_PAGE_SIZE;
     const localSessions = this.store.listSessions(contextKey).filter((session) =>
       session.status !== "closed" && this.isCodexSession(session),
     );
@@ -2841,11 +3085,11 @@ export class ProxySessionController {
     await Promise.all(this.runtimes.entries("codex").map(async ([agentName, runtime]) => {
       if (!runtime.listRemoteSessions) return;
       try {
-        const page = await runtime.listRemoteSessions({ searchTerm, limit: visibleCount });
-        remoteSessions.push(...page.sessions.map((session) => ({ agentName, session })));
-        remoteHasMore ||= Boolean(page.nextCursor);
+        const result = await runtime.listRemoteSessions({ searchTerm, limit: fetchLimit });
+        remoteSessions.push(...result.sessions.map((session) => ({ agentName, session })));
+        remoteHasMore ||= Boolean(result.nextCursor);
       } catch (error) {
-        this.logger.warn({ error, contextKey, agentName }, "Failed to list Codex sessions for an Agent.");
+        this.logger.warn({ error, contextKey, agentName }, "Failed to list App Server sessions for an Agent.");
         remoteErrors.push(`${agentName}: ${error instanceof Error ? error.message : String(error)}`);
       }
     }));
@@ -2861,9 +3105,13 @@ export class ProxySessionController {
         || Number(right.active) - Number(left.active)
         || right.updatedAt - left.updatedAt);
     const activeCount = entries.filter((entry) => entry.active).length;
-    const visibleEntries = entries.slice(0, visibleCount);
-    const hasMore = remoteHasMore || entries.length > visibleCount;
-    this.lastSessionListings.set(contextKey, visibleEntries.map((entry) => entry.reference));
+    const lastKnownPage = Math.max(0, Math.ceil(entries.length / SESSION_PAGE_SIZE) - 1);
+    const page = remoteHasMore ? requestedPage : Math.min(requestedPage, lastKnownPage);
+    const offset = page * SESSION_PAGE_SIZE;
+    const visibleEntries = entries.slice(offset, offset + SESSION_PAGE_SIZE);
+    const hasPrevious = page > 0;
+    const hasNext = remoteHasMore || entries.length > offset + SESSION_PAGE_SIZE;
+    this.lastSessionListings.set(contextKey, entries.map((entry) => entry.reference));
     const cardEntries = visibleEntries.map((entry, index) => {
       const marker = entry.current ? "✅" : entry.active ? "🟢 **活跃**" : "•";
       const showStop = entry.status === "外部执行中"
@@ -2876,7 +3124,7 @@ export class ProxySessionController {
           action: showStop ? "session_stop" : "session_switch",
           sessionId: entry.reference,
           ...(searchTerm ? { searchTerm } : {}),
-          visibleCount: String(visibleCount),
+          page: String(page),
           contextKey,
         },
       }];
@@ -2886,7 +3134,7 @@ export class ProxySessionController {
           action: "session_new",
           sessionId: entry.reference,
           ...(searchTerm ? { searchTerm } : {}),
-          visibleCount: String(visibleCount),
+          page: String(page),
           contextKey,
         },
       });
@@ -2896,7 +3144,7 @@ export class ProxySessionController {
           action: "session_new_group",
           sessionId: entry.reference,
           ...(searchTerm ? { searchTerm } : {}),
-          visibleCount: String(visibleCount),
+          page: String(page),
           contextKey,
         },
       });
@@ -2906,7 +3154,7 @@ export class ProxySessionController {
           action: "session_fork",
           sessionId: entry.reference,
           ...(searchTerm ? { searchTerm } : {}),
-          visibleCount: String(visibleCount),
+          page: String(page),
           contextKey,
         },
       });
@@ -2916,7 +3164,7 @@ export class ProxySessionController {
           action: "session_fork_group",
           sessionId: entry.reference,
           ...(searchTerm ? { searchTerm } : {}),
-          visibleCount: String(visibleCount),
+          page: String(page),
           contextKey,
         },
       });
@@ -2930,34 +3178,45 @@ export class ProxySessionController {
       });
       return {
         lines: [
-          `**${index + 1}.**　${marker}　**${cardText(entry.title)}**　${cardText(entry.id)}`,
+          `**${offset + index + 1}.**　${marker}　**${cardText(entry.title)}**　${cardText(entry.id)}`,
           `${entry.status} · ${entry.updatedLabel} · ${cardText(entry.agentName)} · ${cardText(entry.cwd || "目录未知")}`,
         ],
         actions,
       };
     });
     const card = this.cardRenderer.renderTaskListCard(
-      searchTerm ? `Codex 任务：${searchTerm}` : "Codex 任务",
+      searchTerm ? `App Server 任务：${searchTerm}` : "App Server 任务",
       activeCount > 0 ? `任务（${activeCount} 个活跃）` : "任务",
       cardEntries,
       [
         ...(remoteHint ? [remoteHint] : []),
+        `第 ${page + 1} 页 · 每页 ${SESSION_PAGE_SIZE} 个任务${hasNext ? "" : ` · 当前共 ${entries.length} 个任务`}`,
         "点击 **New** 在对应任务的项目中创建新任务；点击 **Switch** 快速切换；点击 **Fork** 从任务最新已完成轮次创建分支；外部正在运行的任务显示 **Stop**，点击后发送 Interrupt 并变为 **Switch**。",
         "点击 **NewGroup** 在对应任务的项目中创建新群和新任务；点击 **ForkGroup** 从对应任务最新已完成轮次创建分支群。",
         "也可发送 **/switch [序号或任务 ID]**；不带参数切回上一个任务。外部正在执行的回合不会被接管。",
         "发送 **/fork [序号或任务 ID]**，可从当前或指定任务创建分支；任务运行中时使用最近已完成轮次。",
         "点击 **Status**，或发送 **/status [序号或任务 ID]**，查看当前或指定任务状态。",
       ],
-      hasMore ? {
-        text: "More",
-        type: "primary",
-        value: {
-          action: "session_more",
-          ...(searchTerm ? { searchTerm } : {}),
-          visibleCount: String(visibleCount),
-          contextKey,
-        },
-      } : undefined,
+      [
+        ...(hasPrevious ? [{
+          text: "Previous",
+          value: {
+            action: "session_page",
+            ...(searchTerm ? { searchTerm } : {}),
+            page: String(page - 1),
+            contextKey,
+          },
+        }] : []),
+        ...(hasNext ? [{
+          text: "Next",
+          value: {
+            action: "session_page",
+            ...(searchTerm ? { searchTerm } : {}),
+            page: String(page + 1),
+            contextKey,
+          },
+        }] : []),
+      ],
     );
     if (options.updateMessageId) {
       await this.outbound.updateInteractiveCard(contextKey, options.updateMessageId, card);
@@ -2968,18 +3227,16 @@ export class ProxySessionController {
 
   private async refreshSessionsCardFromAction(
     action: CardAction,
-    forceSwitchTaskId?: string,
-    loadMore = false,
+    options: { forceSwitchTaskId?: string; page?: number } = {},
   ): Promise<void> {
     if (!action.messageId) return;
     const searchTerm = typeof action.value.searchTerm === "string" && action.value.searchTerm.trim()
       ? action.value.searchTerm
       : undefined;
-    const currentVisibleCount = parseSessionVisibleCount(action.value.visibleCount);
     await this.listSessions(action.contextKey, searchTerm, {
       updateMessageId: action.messageId,
-      forceSwitchTaskId,
-      visibleCount: currentVisibleCount + (loadMore ? SESSION_PAGE_SIZE : 0),
+      forceSwitchTaskId: options.forceSwitchTaskId,
+      page: options.page ?? parseSessionPage(action.value.page),
     });
   }
 
@@ -3006,7 +3263,7 @@ export class ProxySessionController {
     const candidates = scoped
       ? [[scoped.agentName, this.runtimes.forAgent(scoped.agentName)] as const]
       : this.runtimes.entries("codex");
-    if (candidates.length === 0) throw new Error("未配置 Codex Agent。");
+    if (candidates.length === 0) throw new Error("未配置 App Server Agent。");
 
     const reads = await Promise.allSettled(candidates.map(async ([agentName, runtime]) => {
       if (runtime.kind !== "codex" || !runtime.readRemoteSession) {
@@ -3031,7 +3288,7 @@ export class ProxySessionController {
         : undefined)
       .filter((detail): detail is string => Boolean(detail))
       .join("；");
-    throw new Error(`找不到 Codex 任务：${scoped?.remoteSessionId ?? reference}${details ? `（${details}）` : ""}`);
+    throw new Error(`找不到 App Server 任务：${scoped?.remoteSessionId ?? reference}${details ? `（${details}）` : ""}`);
   }
 
   private async switchSession(contextKey: string, reference?: string): Promise<void> {
@@ -3060,9 +3317,9 @@ export class ProxySessionController {
 
     const { agentName, remote } = await this.resolveRemoteCodexSession(taskId);
     if (remote.status === "active" || remote.lastTurnStatus === "inProgress") {
-      throw new Error(`这个任务正在外部 Codex 中执行，当前不会切换。可使用 /status ${taskId} 查看进度。`);
+      throw new Error(`这个任务正在外部 Agent 中执行，当前不会切换。可使用 /status ${taskId} 查看进度。`);
     }
-    if (!remote.cwd) throw new Error("这个 Codex 任务没有可用的工作目录，暂时无法切换。");
+    if (!remote.cwd) throw new Error("这个 App Server 任务没有可用的工作目录，暂时无法切换。");
     const localSessionId = createId("sess");
     this.store.createSession({
       localSessionId,
@@ -3109,7 +3366,7 @@ export class ProxySessionController {
 
     const { runtime, remote } = await this.resolveRemoteCodexSession(taskId);
     if (!runtime.readRemoteSession || !runtime.interruptRemoteTurn) {
-      throw new Error("当前 Codex 运行时不支持停止外部任务。");
+      throw new Error("当前 App Server Agent 不支持停止外部任务。");
     }
     const turnId = remote.status === "active" || remote.lastTurnStatus === "inProgress"
       ? remote.lastTurnId
@@ -3124,7 +3381,7 @@ export class ProxySessionController {
       turnId,
       source: "sessions_card",
     });
-    await this.outbound.sendText(contextKey, `已向 Codex 发送 Interrupt 请求：${turnId}`);
+    await this.outbound.sendText(contextKey, `已向 Agent 发送 Interrupt 请求：${turnId}`);
   }
 
   private resolveSessionReference(contextKey: string, reference?: string): string {
@@ -3165,7 +3422,7 @@ export class ProxySessionController {
         && activity.activeTurnId === record.lastTurnId;
       const botOwnsActiveTurn = runtimeOwnsActiveTurn || persistedTurnMatches;
       if (activity.active && !botOwnsActiveTurn) {
-        throw new Error("这个任务正在外部 Codex 中执行。Agent Bot 不会接管或追加消息，请等待外部执行完成。");
+        throw new Error("这个任务正在外部 Agent 中执行。Agent Bot 不会接管或追加消息，请等待外部执行完成。");
       }
       return activity;
     }
@@ -3173,14 +3430,14 @@ export class ProxySessionController {
     try {
       remote = await runtime.readRemoteSession(record.remoteSessionId);
     } catch (error) {
-      // Codex does not materialize a new thread until its first user message.
+      // App Server does not materialize a new thread until its first user message.
       // Such a thread has no turn to take over, so allow turn/start to create it.
       if (!record.lastTurnId && isUnmaterializedCodexThreadError(error)) return;
       throw error;
     }
     const botOwnsActiveTurn = isBotOwnedActiveTurn(record, remote);
     if ((remote.status === "active" || remote.lastTurnStatus === "inProgress") && !botOwnsActiveTurn) {
-      throw new Error("这个任务正在外部 Codex 中执行。Agent Bot 不会接管或追加消息，请等待外部执行完成。");
+      throw new Error("这个任务正在外部 Agent 中执行。Agent Bot 不会接管或追加消息，请等待外部执行完成。");
     }
     return undefined;
   }
@@ -3245,7 +3502,7 @@ export class ProxySessionController {
         try {
           remote = await runtime.readRemoteSession(current.remoteSessionId);
         } catch (error) {
-          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect Codex task status.");
+          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect App Server task status.");
         }
       }
       if (runtime.kind === "codex" && runtime.getGoal) {
@@ -3253,7 +3510,7 @@ export class ProxySessionController {
           const loaded = runtime.getSession(current.localSessionId) ?? (await this.loadSession(current)).session;
           goal = await runtime.getGoal(loaded.localSessionId);
         } catch (error) {
-          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect Codex goal status.");
+          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect Agent goal status.");
         }
       }
     }
@@ -3265,7 +3522,7 @@ export class ProxySessionController {
     let activeTurnId: string | undefined;
     let queued = 0;
     if (!current) {
-      taskLines.push("无。直接发送消息即可创建一个未指定项目的 Codex 任务。");
+      taskLines.push("无。直接发送消息即可创建一个未指定项目的 Agent 任务。");
     } else {
       const agent = this.ensureAgent(current.agentName);
       const runtimeSession = this.runtimes.forAgent(current.agentName).getSession(current.localSessionId);
@@ -3283,11 +3540,11 @@ export class ProxySessionController {
       taskLines.push(
         `**标题**：${cardCode(current.title ?? "未命名任务")}`,
         `**工作目录**：${cardCode(current.cwd)}`,
-        `**Provider / 模型 / 思考强度**：${cardCode(current.modelProvider ?? "Codex 默认")} / ${cardCode(current.model ?? "默认")} / ${cardCode(current.reasoningEffort ?? "自动")}`,
+        `**Provider / 模型 / 思考强度**：${cardCode(current.modelProvider ?? "Agent 默认")} / ${cardCode(current.model ?? "默认")} / ${cardCode(current.reasoningEffort ?? "自动")}`,
         `**状态 / 最近结果**：${statusLabel} / ${resultLabel}`,
         `**Agent**：${cardCode(agent.title)}`,
         `**权限 / 任务范围**：${current.permissionMode === "confirm" ? "执行前确认" : "自动执行"} / ${detectProjectlessWorkspace(current.cwd) ? "未指定项目" : "指定项目"}`,
-        `**Codex 任务 ID**：${cardCode(current.remoteSessionId ?? "尚未创建")}`,
+        `**App Server 任务 ID**：${cardCode(current.remoteSessionId ?? "尚未创建")}`,
         `**当前执行 / 排队消息**：${activeTurnId ? cardCode(activeTurnId) : "无"} / ${queued} 条`,
         `**创建时间 / 最近活动**：${formatStatusTime(current.createdAt)} / ${formatStatusTime(current.updatedAt)}`,
       );
@@ -3318,8 +3575,8 @@ export class ProxySessionController {
       },
     ];
     const title = targetSessionId && current
-      ? `Codex 状态：${truncateText((current.title ?? current.remoteSessionId ?? current.localSessionId).replace(/\s+/g, " "), 40)}`
-      : "Codex 状态";
+      ? `Agent 状态：${truncateText((current.title ?? current.remoteSessionId ?? current.localSessionId).replace(/\s+/g, " "), 40)}`
+      : "Agent 状态";
     const taskId = current?.remoteSessionId
       ? remoteSessionReference(current.agentName, current.remoteSessionId)
       : current?.localSessionId;
@@ -3363,7 +3620,7 @@ export class ProxySessionController {
           `**工作目录**：${cardCode(remote.cwd || "目录未知")}`,
           `**状态 / 当前任务**：${remoteSessionDetailStatus(remote)} / 未切换`,
           `**Agent**：${cardCode(agentName)}`,
-          `**Codex 任务 ID**：${cardCode(remote.id)}`,
+          `**App Server 任务 ID**：${cardCode(remote.id)}`,
           `**最近回合**：${cardCode(remote.lastTurnId ?? "无")}　${remoteTurnStatusLabel(remote.lastTurnStatus)}`,
           `**创建时间 / 最近活动**：${formatRemoteTime(remote.createdAt)} / ${formatRemoteTime(latestRemoteTimestamp(remote.recencyAt, remote.updatedAt))}`,
         ],
@@ -3374,14 +3631,14 @@ export class ProxySessionController {
         lines: [
           `**当前 / 最后步骤**：${statusExcerpt(remote.lastActivity ?? remoteStatusStep(remote), 500)}`,
           isRemoteSessionActive(remote)
-            ? "外部 Codex 正在执行；Agent Bot 只读取状态，不会接管。"
+            ? "外部 Agent 正在执行；Agent Bot 只读取状态，不会接管。"
             : `发送 **/switch ${cardText(remote.id)}** 切换到此任务。`,
         ],
         collapsible: true,
         elementId: "status_execution_details",
       },
     ];
-    const title = `Codex 状态：${truncateText((remote.title ?? remote.preview ?? remote.id).replace(/\s+/g, " "), 40)}`;
+    const title = `Agent 状态：${truncateText((remote.title ?? remote.preview ?? remote.id).replace(/\s+/g, " "), 40)}`;
     const showStop = isRemoteSessionActive(remote)
       && options.forceSwitchTaskId !== actionReference
       && options.forceSwitchTaskId !== remote.id;
@@ -3418,6 +3675,7 @@ export class ProxySessionController {
           "**/newgroup [title] [--dir &#60;cwd&#62; | --nodir]**　创建飞书群和新任务；参数与 /new 相同",
           "**/forkgroup [title]**　从当前任务最新已完成轮次创建分支并绑定到新群",
           "**/fork [序号或任务 ID]**　从当前或指定任务创建分支；运行中使用最近已完成轮次",
+          "**/turns**　浏览当前任务的历史对话轮次，并可将对话上下文恢复到所选轮次",
           "**/title &#60;新标题&#62;**　修改当前任务的标题",
           "**/sessions [关键词]**　查找本机任务",
           "**/switch [序号或任务 ID]**　不填参数切回上一个任务",
@@ -3825,6 +4083,10 @@ function formatStatusTime(value: string): string {
   }).format(date);
 }
 
+function formatResetTurnTime(value?: number): string {
+  return value === undefined ? "完成时间未知" : formatStatusTime(new Date(value).toISOString());
+}
+
 function cardText(value: string): string {
   return value.replaceAll("&", "&amp;").replaceAll("`", "&#96;").replaceAll("<", "&#60;").replaceAll(">", "&#62;");
 }
@@ -3843,9 +4105,15 @@ function executionSettingsTabValue(value: unknown): ExecutionSettingsTab {
   throw new Error("设置卡片的 tab 无效，请重新发送设置命令。");
 }
 
+function resetHistoryPageValue(value: unknown): number {
+  const page = Number(value);
+  if (!Number.isSafeInteger(page) || page < 0) throw new Error("历史轮次卡片页码无效，请重新发送 /turns。");
+  return page;
+}
+
 function requiredCardMessageId(value: string | undefined): string {
   if (value) return value;
-  throw new Error("无法更新设置卡片，请重新发送设置命令。");
+  throw new Error("无法更新卡片，请重新发送对应命令。");
 }
 
 function remoteSessionStatusLabel(status: RemoteSessionSummary["status"]): string {
@@ -3947,9 +4215,9 @@ function isQueueIndependentCommand(command: Command): boolean {
   return false;
 }
 
-function parseSessionVisibleCount(value: unknown): number {
+function parseSessionPage(value: unknown): number {
   const parsed = typeof value === "string" || typeof value === "number" ? Number(value) : Number.NaN;
-  return Number.isSafeInteger(parsed) && parsed >= SESSION_PAGE_SIZE ? parsed : SESSION_PAGE_SIZE;
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : 0;
 }
 
 function isPromptCommand(command: Command): boolean {