@keyou007/agent-bot 0.1.24-alpha.1 → 0.1.24-alpha.3

package/src/proxy/ProxySessionController.ts

@@ -26,6 +26,7 @@ import type {
   IncomingMessage,
   MessageReplyTarget,
   ReferencedMessageContent,
+  RecentContextMessage,
 } from "../feishu/types.js";
 import {
   type AppServerReleaseCardView,
@@ -49,11 +50,13 @@ import {
   parseTaskNameFromGroupName,
 } from "../feishu/GroupNameFormatter.js";
 import { normalizeFeishuPostText } from "../feishu/InboundText.js";
+import { RECENT_CONTEXT_LIMIT, RECENT_CONTEXT_IMAGE_LIMIT, RECENT_CONTEXT_TEXT_LIMIT, recentContextPrompt } from "../feishu/RecentMessageContext.js";
 import { allowsFeishuUser } from "../feishu/ownerAccess.js";
 import { classifyFileContent } from "../local-files/LocalFileViewerServer.js";
 import { errorLogValue } from "../logging/errorLogValue.js";
 import type { OutboundRouter } from "../presentation/OutboundRouter.js";
 import type { TurnActivity, TurnViewState } from "../presentation/turnViewTypes.js";
+import { createTurnViewState, hydrateTurnViewState } from "../presentation/TurnStateReducer.js";
 import { buildTurnGraphRows } from "../presentation/turnGraph.js";
 import type { AgentRuntimeRegistry } from "../runtime/AgentRuntimeRegistry.js";
 import type {
@@ -90,6 +93,7 @@ import {
   type SessionRecord,
   type TurnAttemptRecord,
   type TurnAnchorRecord,
+  type TurnRuntimeOriginRecord,
 } from "../state/StateStore.js";
 import { createId } from "../utils/id.js";
 import { formatStorageSize } from "../utils/formatStorageSize.js";
@@ -205,6 +209,7 @@ const FORK_GROUP_STARTED_MESSAGE = "正在创建分支群聊，请稍后。";
 const LIST_SESSIONS_STARTED_MESSAGE = "正在读取任务列表，请稍后。";
 const LIST_TURNS_STARTED_MESSAGE = "正在读取历史轮次，请稍后。";
 const SWITCH_TASK_STARTED_MESSAGE = "正在切换任务，请稍后。";
+const SWITCH_GROUP_STARTED_MESSAGE = "正在创建群聊并绑定所选任务，请稍后。";
 const STATUS_STARTED_MESSAGE = "正在读取任务状态，请稍后。";
 const GOAL_STARTED_MESSAGE = "正在处理 Goal，请稍后。";
 const ARCHIVE_TASK_STARTED_MESSAGE = "正在归档任务，请稍后。";
@@ -344,6 +349,7 @@ const HELP_COMMAND_SECTIONS: Array<{
         usage: "[--force]",
         description: "默认安全重启；--force 立即重启",
       },
+      { command: "/update", description: "查看正式版和 Alpha 版更新，选择版本安全更新" },
       {
         command: "/release",
         description: "释放 Agent Bot 占用的 App Server 任务",
@@ -392,6 +398,8 @@ interface StatusCardOptions {
 }
 
 interface ResetHistoryCardOptions {
+  sessionReference?: string;
+  cursor?: string;
   expectedSessionId?: string;
   updateMessageId?: string;
   page?: number;
@@ -503,6 +511,8 @@ export interface ProxyLifecycle {
   cancelSafeRestart?(scheduleId: number): Promise<boolean>;
   forceSafeRestart?(scheduleId: number): Promise<boolean>;
   cancelAutomaticUpdate?(action: CardAction): Promise<void>;
+  showUpdates?(contextKey: string, userId?: string): Promise<void>;
+  selectUpdate?(action: CardAction, replyTarget?: MessageReplyTarget): Promise<void>;
   rememberFeishuUserOpenId?(userOpenId: string): Promise<void> | void;
   persistAgentExecutionDefaults?(
     agentName: string,
@@ -527,6 +537,7 @@ export class ProxySessionController {
   private readonly router = new CommandRouter();
   private readonly cardRenderer = new CardRenderer();
   private readonly messageQueues = new Map<string, Promise<void>>();
+  private readonly switchGroupOperations = new Set<string>();
   private readonly sessionLoads = new Map<string, Promise<LoadedSession>>();
   private readonly queuedPromptStarts = new Map<string, Promise<void>>();
   private readonly queuedPromptCards = new Map<string, Map<string, string>>();
@@ -535,6 +546,7 @@ export class ProxySessionController {
   private readonly resetHistoryOperations = new Map<string, string>();
   private readonly remoteTurnHistoryRefreshes = new Map<string, number>();
   private readonly turnHistoryHydrations = new Map<string, Promise<boolean>>();
+  private readonly turnDetailHydrations = new Map<string, Promise<TurnViewState | undefined>>();
   private readonly forkHistoryCursors = new Map<string, ForkHistoryCursor>();
   private readonly lastSessionListings = new Map<string, string[]>();
   private readonly threadInitializations = new Map<string, Promise<void>>();
@@ -914,11 +926,14 @@ export class ProxySessionController {
           let executableImagePaths = localImagePaths;
           let executableMessage = message;
           let injectedRootMessageId: string | undefined;
+          let recentContextIds: string[] = [];
           if (command.type === "prompt") {
             await this.ensureThreadFork(message);
             const prepared = await this.prepareTopicRootPrompt(message, command.text, localImagePaths);
-            executableCommand = { ...command, text: prepared.text };
-            executableImagePaths = prepared.localImagePaths;
+            const recent = await this.prepareMutedGroupContext(message, prepared.text, prepared.localImagePaths);
+            executableCommand = { ...command, text: recent.text };
+            executableImagePaths = recent.localImagePaths;
+            recentContextIds = recent.messageIds;
             executableMessage = { ...message, displayText: prepared.displayPrompt };
             injectedRootMessageId = prepared.injectedRootMessageId;
           }
@@ -931,6 +946,12 @@ export class ProxySessionController {
             message.userId,
             executableMessage,
           );
+          if (command.type === "prompt" && message.chatType === "group" && message.mentionedBot
+            && this.store.chatRequiresMention(baseChatContextKey(message.contextKey))) {
+            const current = this.currentSession(message.contextKey);
+            if (current) this.store.rememberRecentContextMessages(current.localSessionId, current.remoteSessionId ?? "", message.contextKey, message.messageId,
+              [...recentContextIds, message.messageId, ...[referencedMessageId, injectedRootMessageId].filter((id): id is string => Boolean(id))]);
+          }
           if (injectedRootMessageId) {
             const current = this.currentSession(message.contextKey);
             if (current) {
@@ -994,10 +1015,15 @@ export class ProxySessionController {
         if (kind === "agentbot_update_cancel") {
           if (!this.lifecycle?.cancelAutomaticUpdate) throw new Error("自动更新功能未启用。");
           await this.lifecycle.cancelAutomaticUpdate(scopedAction);
+        } else if (kind === "agentbot_update_select") {
+          if (!this.lifecycle?.selectUpdate) throw new Error("当前运行方式不支持在线更新。");
+          await this.lifecycle.selectUpdate(scopedAction, replyTarget);
         } else if (kind === "help_command") {
           await this.executeHelpCommandAction(scopedAction, contextKey, replyTarget);
         } else if (kind === "turn_details") {
-          await this.outbound.showDetails(contextKey, String(scopedAction.value.turnId ?? ""));
+          const turnId = String(scopedAction.value.turnId ?? "");
+          await this.loadTurnDetails(turnId);
+          await this.outbound.showDetails(contextKey, turnId);
         } else if (kind === "activity_history") {
           const requestedPage = String(scopedAction.value.page ?? "0");
           const numericPage = Number(requestedPage);
@@ -1137,6 +1163,9 @@ export class ProxySessionController {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.forkSessionReference(contextKey, sessionId);
           await this.refreshSessionsCardFromAction(scopedAction, { page: 0 });
+        } else if (kind === "session_switch_group") {
+          await this.switchSessionReferenceToFeishuGroup(contextKey, String(scopedAction.value.sessionId ?? ""), scopedAction.userId);
+          await this.refreshSessionsCardFromAction(scopedAction);
         } else if (kind === "session_fork_group") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.forkSessionReferenceToFeishuGroup(contextKey, sessionId, scopedAction.userId);
@@ -1181,6 +1210,18 @@ export class ProxySessionController {
           else if (scopedAction.value.cardView !== "safe_restart") {
             await this.refreshSessionsCardFromAction(scopedAction, { forceSwitchTaskId: sessionId });
           }
+        } else if (kind === "session_turns" || kind === "session_turns_page") {
+          const sessionReference = String(scopedAction.value.sessionId ?? "").trim();
+          if (!sessionReference) throw new Error("任务轮次卡片无效，请重新发送 /sessions。");
+          if (kind === "session_turns") await this.outbound.sendText(contextKey, LIST_TURNS_STARTED_MESSAGE);
+          await this.openResetHistory(contextKey, {
+            sessionReference,
+            ...(kind === "session_turns_page" ? {
+              updateMessageId: requiredCardMessageId(scopedAction.messageId),
+              page: resetHistoryPageValue(scopedAction.value.page),
+              cursor: typeof scopedAction.value.cursor === "string" ? scopedAction.value.cursor : undefined,
+            } : {}),
+          });
         } else if (kind === "session_status") {
           await this.outbound.sendText(contextKey, STATUS_STARTED_MESSAGE);
           await this.status(contextKey, String(scopedAction.value.sessionId ?? ""));
@@ -1470,6 +1511,7 @@ export class ProxySessionController {
         scopedRecord.cwd,
         this.agentLabel(scopedRecord.agentName),
         scopedRecord.model,
+        scopedRecord.modelProvider,
       );
       const promptMessageId = await this.outbound.withReplyTarget(
         responseContextKey,
@@ -1757,7 +1799,7 @@ export class ProxySessionController {
         await loaded.runtime.setReasoningEffort(record.localSessionId, nextEffort);
       }
       this.store.updateRuntimeSession(record.localSessionId, { model: nextValue, reasoningEffort: nextEffort });
-      this.outbound.updateSessionModel(record.localSessionId, nextValue);
+      this.outbound.updateSessionModel(record.localSessionId, nextValue, loaded.session.modelProvider);
     } else if (setting === "thinking" && nextValue) {
       const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
       const currentModel = models.find((candidate) => candidate.id === loaded.session.model)
@@ -2139,6 +2181,10 @@ export class ProxySessionController {
         if (!this.lifecycle) throw new Error("当前运行方式不支持自动重启。");
         await this.lifecycle.restart(contextKey, command.force === true, replyTarget);
         return;
+      case "update":
+        if (!this.lifecycle?.showUpdates) throw new Error("当前运行方式不支持检查更新。");
+        await this.lifecycle.showUpdates(contextKey, userId);
+        return;
       case "release":
         await this.requestAppServerRelease(contextKey);
         return;
@@ -2158,7 +2204,7 @@ export class ProxySessionController {
         await this.openExecutionSettings(contextKey, "model");
         return;
       case "provider":
-        await this.openProviderSettings(contextKey);
+        await this.openExecutionSettings(contextKey, "provider");
         return;
       case "thinking":
         await this.openExecutionSettings(contextKey, "thinking");
@@ -2191,6 +2237,7 @@ export class ProxySessionController {
         session.cwd,
         this.agentLabel(session.agentName),
         session.model,
+        session.modelProvider,
       );
       if (!session.lastTurnId) continue;
       void this.outbound.resumeDelivery(session.localSessionId, turnContextKey, session.lastTurnId).catch((error: unknown) => {
@@ -2278,6 +2325,7 @@ export class ProxySessionController {
           session.cwd,
           this.agentLabel(session.agentName),
           session.model,
+          session.modelProvider,
         );
       }
       try {
@@ -2407,6 +2455,7 @@ export class ProxySessionController {
       session.cwd,
       this.agentLabel(session.agentName),
       session.model,
+      session.modelProvider,
     );
     if (announce) {
       await this.outbound.withReplyTarget(contextKey, replyTarget, () =>
@@ -2689,6 +2738,7 @@ export class ProxySessionController {
         record.cwd,
         this.agentLabel(record.agentName),
         record.model,
+        record.modelProvider,
       );
       await this.outbound.startPendingTurn(
         record.localSessionId,
@@ -2696,6 +2746,7 @@ export class ProxySessionController {
         record.title,
         replyTarget,
         displayPrompt ?? text,
+        localImagePaths,
       );
     }
     let loaded: LoadedSession;
@@ -2736,7 +2787,7 @@ export class ProxySessionController {
       }
       try {
         await loaded.runtime.steerTurn(record.localSessionId, activeTurnId, runtimePrompt(text, localImagePaths));
-        await this.presentSteerMessage(record.localSessionId, activeTurnId, displayPrompt ?? text, messageId);
+        await this.presentSteerMessage(record.localSessionId, activeTurnId, displayPrompt ?? text, messageId, localImagePaths);
         if (messageId) await this.bindMessageReactionToTurn(messageId, record.localSessionId, activeTurnId);
         return;
       } catch (error) {
@@ -2764,6 +2815,7 @@ export class ProxySessionController {
               current.activeTurnId,
               displayPrompt ?? text,
               messageId,
+              localImagePaths,
             );
             if (messageId) await this.bindMessageReactionToTurn(messageId, record.localSessionId, current.activeTurnId);
             return;
@@ -2792,10 +2844,11 @@ export class ProxySessionController {
     turnId: string,
     text: string,
     messageId?: string,
+    localImagePaths?: string[],
   ): Promise<void> {
     this.store.touchTurnAttempt(turnId);
     try {
-      await this.outbound.appendSteerMessage(localSessionId, turnId, text, messageId);
+      await this.outbound.appendSteerMessage(localSessionId, turnId, text, messageId, localImagePaths);
     } catch (error) {
       this.logger.warn(
         { error, sessionId: localSessionId, turnId, messageId },
@@ -2958,6 +3011,70 @@ export class ProxySessionController {
     }
   }
 
+  private async prepareMutedGroupContext(
+    message: IncomingMessage,
+    text: string,
+    localImagePaths?: string[],
+  ): Promise<{ text: string; localImagePaths?: string[]; messageIds: string[] }> {
+    if (message.chatType !== "group" || !message.chatId || message.mentionedBot !== true
+      || !this.store.chatRequiresMention(baseChatContextKey(message.contextKey))) {
+      return { text, localImagePaths, messageIds: [] };
+    }
+    if (message.threadContext && !message.threadId) throw new Error("无法识别当前话题，已停止补充上下文以避免读取其他话题。");
+    try {
+      const current = this.currentSession(message.contextKey);
+      const stopIds = current ? new Set([
+        ...this.store.recentContextMessageIds(current.localSessionId, current.remoteSessionId ?? "", message.contextKey, false),
+        ...this.store.recentSubmittedMessageIds(current.localSessionId, current.remoteSessionId ?? "", message.contextKey),
+      ]) : new Set<string>();
+      const messages = await this.outbound.readRecentMessages(message.contextKey, {
+        chatId: message.chatId,
+        ...(message.threadId ? { threadId: message.threadId } : {}),
+        beforeMessageId: message.messageId,
+        beforeTimestamp: message.createdAt,
+        ...(stopIds.size ? { stopBeforeMessageIds: [...stopIds] } : {}),
+      });
+      const seen = current ? this.store.recentContextMessageIds(current.localSessionId, current.remoteSessionId ?? "", message.contextKey) : new Set<string>();
+      seen.add(message.messageId);
+      if (message.parentMessageId) seen.add(message.parentMessageId);
+      if (message.threadContext && message.rootMessageId) seen.add(message.rootMessageId);
+      const selected: RecentContextMessage[] = [];
+      const imagePaths = [...(localImagePaths ?? [])];
+      const imageKeys = new Set<string>();
+      let remaining = RECENT_CONTEXT_TEXT_LIMIT;
+      let imageCount = 0;
+      for (const item of messages.slice(-RECENT_CONTEXT_LIMIT).reverse()) {
+        if (stopIds.has(item.messageId) || remaining <= 0) break;
+        if (seen.has(item.messageId)) continue;
+        seen.add(item.messageId);
+        const limit = Math.min(2_000, remaining);
+        let body = item.text.length > limit ? `${item.text.slice(0, limit)}\n[消息文本已截断]` : item.text;
+        remaining -= Math.min(item.text.length, limit);
+        for (const [index, image] of item.images.entries()) {
+          if (imageKeys.has(image.imageKey)) continue;
+          imageKeys.add(image.imageKey);
+          if (imageCount >= RECENT_CONTEXT_IMAGE_LIMIT) {
+            body += `\n[图片 ${index + 1} 未附带：已达到近期图片上限]`;
+            continue;
+          }
+          const imagePath = await this.outbound.downloadImage(message.contextKey, image.messageId, image.imageKey);
+          imagePaths.push(imagePath);
+          imageCount++;
+          body += `\n[图片 ${index + 1} 已附带：${imagePath}]`;
+        }
+        selected.unshift({ ...item, text: body });
+      }
+      return {
+        text: recentContextPrompt(text, selected),
+        ...(imagePaths.length ? { localImagePaths: [...new Set(imagePaths)] } : {}),
+        messageIds: selected.map((item) => item.messageId),
+      };
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(`无法补充近期群聊上下文（包括图片）：${detail}。请检查飞书历史消息/群消息读取权限及机器人是否在群内，或附图重试。`);
+    }
+  }
+
   private async prepareTopicRootPrompt(
     message: IncomingMessage,
     text: string,
@@ -3048,6 +3165,7 @@ export class ProxySessionController {
       source.cwd,
       this.agentLabel(source.agentName),
       source.model,
+      source.modelProvider,
     );
 
     try {
@@ -3409,7 +3527,8 @@ export class ProxySessionController {
         forked.title ?? plan.forkTitle,
         plan.cwd,
         this.agentLabel(plan.agentName),
-        plan.model,
+        forked.model ?? plan.model,
+        forked.modelProvider ?? plan.modelProvider,
       );
       this.store.audit(contextKey, "session_forked", {
         sourceLocalSessionId: plan.source?.localSessionId,
@@ -3458,6 +3577,7 @@ export class ProxySessionController {
               sessionId: input.localSessionId,
               turnId: turn.id,
               prompt: turn.prompt ?? "未记录对话内容",
+              historyDetail: "summary",
               status: "completed",
               startedAt,
               completedAt,
@@ -3807,16 +3927,15 @@ export class ProxySessionController {
       while (true) {
         let pendingTurnId: string | undefined;
         try {
-          this.outbound.updateSessionModel(
-            loaded.record.localSessionId,
-            loaded.runtime.getSession(loaded.record.localSessionId)?.model ?? loaded.session.model,
-          );
+          const session = loaded.runtime.getSession(loaded.record.localSessionId) ?? loaded.session;
+          this.outbound.updateSessionModel(loaded.record.localSessionId, session.model, session.modelProvider);
           pendingTurnId = await this.outbound.startPendingTurn(
             loaded.record.localSessionId,
             loaded.record.contextKey,
             title,
             replyTarget,
             cardPrompt,
+            localImagePaths,
           );
         } catch (error) {
           this.store.updateTurnAttempt(attemptId, {
@@ -3933,6 +4052,7 @@ export class ProxySessionController {
       sessionCwd,
       this.agentLabel(agentName),
       resolvedExecutionSettings.model,
+      resolvedExecutionSettings.modelProvider,
     );
     const runtime = this.runtimes.forAgent(agentName);
     try {
@@ -3950,7 +4070,7 @@ export class ProxySessionController {
         permissionMode: resolvedExecutionSettings.permissionMode ?? "auto",
       });
       this.persistRuntimeSession(record, session, session.activeTurnId ? "running" : "ready");
-      this.outbound.updateSessionModel(localSessionId, session.model);
+      this.outbound.updateSessionModel(localSessionId, session.model, session.modelProvider);
       const saved = this.store.getSession(localSessionId) ?? record;
       if (announce) {
         const task = initialTitle ? `${initialTitle}（${session.remoteSessionId}）` : session.remoteSessionId;
@@ -4013,6 +4133,105 @@ export class ProxySessionController {
     );
   }
 
+  private async switchSessionReferenceToFeishuGroup(
+    sourceContextKey: string,
+    reference: string,
+    userId: string | undefined,
+  ): Promise<void> {
+    if (!userId?.startsWith("ou_")) throw new Error("SwitchGroup 只能由具有 open_id 的飞书用户触发。");
+    if (!reference.trim()) throw new Error("任务无效，请重新发送 /sessions。");
+    await this.outbound.sendText(sourceContextKey, SWITCH_GROUP_STARTED_MESSAGE);
+    const taskId = this.resolveSessionReference(sourceContextKey, reference);
+    let task = this.store.getSession(taskId) ?? this.findStoredSessionByReference(taskId);
+    if (task?.status === "closed") throw new Error(`找不到任务：${taskId}`);
+    if (task && (!this.isCodexSession(task) || !task.remoteSessionId)) {
+      throw new Error("指定任务不是可切换的 App Server 任务。");
+    }
+    let remote: RemoteSessionSummary | undefined;
+    let agentName: string;
+    let runtime: AgentRuntime;
+    if (task) {
+      agentName = task.agentName;
+      runtime = this.runtimes.forAgent(agentName);
+      await this.assertSessionTurnOwnership(task, runtime);
+    } else {
+      const resolved = await this.resolveRemoteCodexSession(taskId);
+      ({ agentName, runtime, remote } = resolved);
+      if (isRemoteSessionActive(remote)) {
+        throw new Error("这个任务正在外部 Agent 中执行，请等待完成后再使用 SwitchGroup。");
+      }
+    }
+    const remoteSessionId = task?.remoteSessionId ?? remote!.id;
+    const operationKey = agentRemoteKey(agentName, remoteSessionId);
+    if (this.switchGroupOperations.has(operationKey)) throw new Error("正在为此任务创建群聊，请勿重复点击。");
+    const cwd = task?.cwd ?? remote!.cwd;
+    if (!cwd) throw new Error("指定任务没有可用的工作目录，暂时无法创建群聊。");
+    const title = task?.title ?? remote?.title ?? remote?.preview ?? remoteSessionId;
+    const boundProjectCwd = detectProjectlessWorkspace(cwd) ? undefined : cwd;
+    this.switchGroupOperations.add(operationKey);
+    try {
+      const group = await this.createFeishuGroupContext(sourceContextKey, agentName, title, userId, boundProjectCwd, "SwitchGroup");
+      try {
+        const latest = task ? undefined : await runtime.readRemoteSession!(remoteSessionId);
+        if (latest && isRemoteSessionActive(latest)) throw new Error("所选任务已在外部 Agent 中开始执行，请等待完成后切换。");
+        // Group creation may take time; reuse any canonical task linked in the meantime.
+        task = this.store.findSessionByRemoteSessionId(remoteSessionId, undefined, agentName) ?? task;
+        if (task) {
+          task = this.store.getSession(task.localSessionId);
+          if (!task || task.status === "closed") throw new Error("所选任务已归档，请重新选择任务。");
+          await this.assertSessionTurnOwnership(task, runtime);
+          task = this.store.getSession(task.localSessionId);
+          if (!task || task.status === "closed" || task.remoteSessionId !== remoteSessionId) {
+            throw new Error("所选任务已变化，请重新选择任务。");
+          }
+          this.store.attachSessionToContext(group.contextKey, task.localSessionId);
+        } else {
+          if (!latest) throw new Error("无法读取所选任务，请重试。");
+          const localSessionId = createId("sess");
+          this.store.createSession({ localSessionId, contextKey: group.contextKey, agentName, cwd, status: "ready" });
+          this.store.updateRuntimeSession(localSessionId, {
+            runtimeKind: "codex",
+            remoteSessionId,
+            title: latest.title ?? latest.preview ?? title,
+            modelProvider: latest.modelProvider ?? remote?.modelProvider,
+            model: latest.model ?? remote?.model,
+            reasoningEffort: latest.reasoningEffort ?? remote?.reasoningEffort,
+            permissionMode: latest.permissionMode ?? remote?.permissionMode ?? "auto",
+            lastTurnId: latest.lastTurnId ?? remote?.lastTurnId,
+            lastTurnStatus: mapRemoteTurnStatus(latest.lastTurnStatus ?? remote?.lastTurnStatus),
+          });
+          task = this.store.getSession(localSessionId)!;
+        }
+        this.store.setCurrentSession(group.contextKey, task.localSessionId);
+        // A live Turn keeps its original delivery route. The new group's next Turn
+        // establishes its own route through startPendingTurn.
+        if (task.status !== "running" && !runtime.getSession(task.localSessionId)?.activeTurnId) {
+          this.outbound.registerSession(task.localSessionId, group.contextKey, task.title, task.cwd, this.agentLabel(agentName), task.model, task.modelProvider);
+        }
+        this.store.audit(sourceContextKey, "session_switch_group", {
+          localSessionId: task.localSessionId, remoteSessionId, groupContextKey: group.contextKey,
+        });
+      } catch (error) {
+        await this.outbound.sendText(group.contextKey,
+          `群已创建，但绑定任务失败：${runtimeErrorMessage(error)}。可使用 /sessions 重新选择任务。`)
+          .catch((noticeError: unknown) => this.logger.warn({ error: noticeError, contextKey: group.contextKey }, "Failed to report SwitchGroup binding failure."));
+        throw new Error(`群 ${group.name} 已创建，但绑定任务失败：${runtimeErrorMessage(error)}`);
+      }
+      await this.outbound.sendText(group.contextKey, [
+        "已切换到已有任务，历史与原会话共享。",
+        `当前任务：${task.title ?? title}（${remoteSessionId}）`,
+        `当前 Project 目录：${boundProjectCwd ?? "未绑定（Projectless）"}`,
+        `当前 Provider：${task.modelProvider ?? "Agent 默认"}`,
+        `当前模型：${task.model ?? "默认"}`,
+        `思考强度：${task.reasoningEffort ?? "自动"}`,
+        `权限类型：${task.permissionMode === "confirm" ? "执行前确认" : "自动执行"}`,
+      ].join("\n"));
+      await this.outbound.sendText(sourceContextKey, `已创建飞书群：${group.name}，并切换到任务 ${task.title ?? remoteSessionId}。原会话不变。`);
+    } finally {
+      this.switchGroupOperations.delete(operationKey);
+    }
+  }
+
   private async createFeishuGroupWithTask(
     sourceContextKey: string,
     agentName: string,
@@ -4275,7 +4494,7 @@ export class ProxySessionController {
     taskTitle: string,
     userId: string | undefined,
     boundProjectCwd: string | undefined,
-    commandName: "/newgroup" | "/forkgroup" | "/clonegroup",
+    commandName: "/newgroup" | "/forkgroup" | "/clonegroup" | "SwitchGroup",
   ): Promise<CreatedFeishuGroupContext> {
     if (!userId?.startsWith("ou_")) {
       throw new Error(`${commandName} 只能由具有 open_id 的飞书用户消息触发。`);
@@ -4323,6 +4542,7 @@ export class ProxySessionController {
       record.cwd,
       this.agentLabel(record.agentName),
       record.model,
+      record.modelProvider,
     );
     const loading = (async (): Promise<LoadedSession> => {
       if (record.lastTurnId) {
@@ -5065,7 +5285,8 @@ export class ProxySessionController {
       forked.title ?? current.title,
       current.cwd,
       this.agentLabel(current.agentName),
-      current.model,
+      forked.model ?? current.model,
+      forked.modelProvider ?? current.modelProvider,
     );
     this.store.audit(contextKey, "session_reset_to_turn", {
       localSessionId: current.localSessionId,
@@ -5179,21 +5400,6 @@ export class ProxySessionController {
     await this.openExecutionSettings(contextKey, "agent");
   }
 
-  private async openProviderSettings(contextKey: string): Promise<void> {
-    const loaded = await this.loadSession(this.requireCurrentSession(contextKey));
-    const providers = loaded.runtime.kind === "codex" && loaded.runtime.listModelProviders
-      ? await this.modelProviderOptions(loaded)
-      : [];
-    const current = loaded.session.modelProvider?.trim()
-      || providers.find((provider) => provider.isDefault)?.id
-      || "运行时默认";
-    if (providers.length <= 1) {
-      await this.outbound.sendText(contextKey, `当前 Provider：${current}\n当前没有其他 Provider 可以切换。`);
-      return;
-    }
-    await this.openExecutionSettings(contextKey, "provider", { sessionId: loaded.record.localSessionId });
-  }
-
   private async selectProvider(
     contextKey: string,
     modelProvider: string,
@@ -5368,7 +5574,7 @@ export class ProxySessionController {
       }
     };
     const session = await loaded.runtime.setExecutionSettings(loaded.record.localSessionId, settings, persist);
-    this.outbound.updateSessionModel(loaded.record.localSessionId, session.model);
+    this.outbound.updateSessionModel(loaded.record.localSessionId, session.model, session.modelProvider);
     return session;
   }
 
@@ -5439,7 +5645,7 @@ export class ProxySessionController {
       await loaded.runtime.setReasoningEffort(loaded.record.localSessionId, nextEffort);
     }
     this.store.updateRuntimeSession(loaded.record.localSessionId, { model, reasoningEffort: nextEffort });
-    this.outbound.updateSessionModel(loaded.record.localSessionId, model);
+    this.outbound.updateSessionModel(loaded.record.localSessionId, model, loaded.session.modelProvider);
     await this.persistAgentExecutionDefaults(loaded.record.localSessionId);
     const effortMessage = nextEffort && nextEffort !== currentEffort
       ? `，思考强度已自动调整为 ${nextEffort}`
@@ -5951,6 +6157,78 @@ export class ProxySessionController {
     };
   }
 
+  async loadTurnDetails(turnId: string): Promise<TurnViewState | undefined> {
+    const existing = this.turnDetailHydrations.get(turnId);
+    if (existing) return existing;
+    const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(turnId));
+    if ((!snapshot || snapshot.previewJournal) && this.store.previews.has(turnId)) return this.store.previews.load(turnId);
+    if (snapshot && !needsHistoricalDetails(snapshot)) return snapshot;
+    const origin = !snapshot ? this.store.getTurnRuntimeOrigin(turnId) : undefined;
+    if (!snapshot && (!origin || !this.runtimes.forAgent(origin.agentName).readRemoteTurn)) return undefined;
+    const hydration = snapshot ? this.hydrateTurnDetails(snapshot) : this.loadUnrecordedTurnPreview(origin!);
+    this.turnDetailHydrations.set(turnId, hydration);
+    try {
+      return await hydration;
+    } finally {
+      if (this.turnDetailHydrations.get(turnId) === hydration) this.turnDetailHydrations.delete(turnId);
+    }
+  }
+
+  private async loadUnrecordedTurnPreview(origin: TurnRuntimeOriginRecord): Promise<TurnViewState> {
+    const runtime = this.runtimes.forAgent(origin.agentName);
+    if (!runtime.readRemoteTurn) throw new Error("此 Agent 不支持读取历史执行详情。");
+    const details = await runtime.readRemoteTurn(origin.remoteSessionId, origin.turnId);
+    if (details.turnId !== origin.turnId) throw new Error("Agent 返回的轮次与请求不一致，请重试。");
+    let remote: RemoteSessionSummary | undefined;
+    try {
+      remote = await runtime.readRemoteSession?.(origin.remoteSessionId, "metadata");
+    } catch (error) {
+      this.logger.warn({ error, turnId: origin.turnId }, "Failed to read Preview task metadata; retaining full Turn details.");
+    }
+    // An Agent Bot turn may have arrived while the read-only request was in flight.
+    const latest = turnViewSnapshot(this.store.getTurnSnapshot(origin.turnId));
+    if (latest) return latest.previewJournal ? this.store.previews.load(origin.turnId) ?? latest : latest;
+    const state = hydrateTurnViewState(createTurnViewState(
+      origin.localSessionId, origin.turnId, details.startedAt ?? 0,
+      remote?.title, undefined, remote?.cwd, undefined, this.agentLabel(origin.agentName),
+    ), details);
+    // Viewing external work must not create a task, a chat binding or a pending final reply.
+    this.store.previews.seed(state);
+    this.store.previews.release(state.turnId);
+    return state;
+  }
+
+  private async hydrateTurnDetails(snapshot: TurnViewState): Promise<TurnViewState | undefined> {
+    let updated: TurnViewState;
+    try {
+      const origin = this.store.getTurnRuntimeOrigin(snapshot.turnId);
+      if (!origin) throw new Error("未保存本轮的原始 Agent 会话信息，无法读取历史执行详情。");
+      const runtime = this.runtimes.forAgent(origin.agentName);
+      if (!runtime.readRemoteTurn) throw new Error("此 Agent 不支持读取历史执行详情。");
+      const details = await runtime.readRemoteTurn(origin.remoteSessionId, snapshot.turnId);
+      if (details.turnId !== snapshot.turnId) throw new Error("Agent 返回的轮次与请求不一致，请重试。");
+      const session = this.store.getSession(snapshot.sessionId);
+      updated = hydrateTurnViewState({
+        ...snapshot,
+        projectCwd: snapshot.projectCwd ?? session?.cwd,
+        agentLabel: snapshot.agentLabel ?? this.agentLabel(origin.agentName),
+      }, details);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn({ error, turnId: snapshot.turnId }, "Failed to load historical Turn details.");
+      updated = { ...snapshot, historyDetail: "summary", historyDetailError: message };
+    }
+    const latest = turnViewSnapshot(this.store.getTurnSnapshot(snapshot.turnId));
+    if (!latest || !needsHistoricalDetails(latest)) return latest;
+    if (updated.historyDetail === "full") {
+      this.store.previews.seed(updated);
+      this.store.previews.flush(updated.turnId, true);
+      updated = { ...updated, previewJournal: true };
+    }
+    this.store.saveTurnSnapshot(snapshot.turnId, snapshot.sessionId, updated);
+    return updated;
+  }
+
   private async openTurnDetails(contextKey: string, reference: string): Promise<void> {
     const current = this.requireCurrentSession(contextKey);
     let turnId: string | undefined;
@@ -5989,6 +6267,7 @@ export class ProxySessionController {
       ));
       return;
     }
+    await this.loadTurnDetails(turnId);
     await this.outbound.showDetails(contextKey, turnId);
   }
 
@@ -5996,7 +6275,18 @@ export class ProxySessionController {
     contextKey: string,
     options: ResetHistoryCardOptions = {},
   ): Promise<void> {
-    const current = this.requireCurrentSession(contextKey);
+    const taskId = options.sessionReference
+      ? this.resolveSessionReference(contextKey, options.sessionReference)
+      : undefined;
+    const current = taskId
+      ? this.store.getSession(taskId) ?? this.findStoredSessionByReference(taskId)
+      : this.requireCurrentSession(contextKey);
+    if (!current && taskId) {
+      await this.openRemoteTurnHistory(contextKey, taskId, options);
+      return;
+    }
+    if (!current || current.status === "closed") throw new Error(`找不到任务：${taskId}`);
+    const readOnly = this.currentSession(contextKey)?.localSessionId !== current.localSessionId;
     if (options.expectedSessionId && current.localSessionId !== options.expectedSessionId) {
       throw new Error("这张历史轮次卡片不属于当前任务。请先切换回对应任务，再重新发送 /turns。");
     }
@@ -6056,7 +6346,7 @@ export class ProxySessionController {
         current: isCurrent,
         running: isRunning,
         resetting: isResetting,
-        actions: isCurrent || isRunning || resettingTurnId ? undefined : [{
+        actions: readOnly || isCurrent || isRunning || resettingTurnId ? undefined : [{
           text: "Reset",
           value: {
             action: "turn_reset",
@@ -6073,8 +6363,8 @@ export class ProxySessionController {
       ...(page > 0 ? [{
         text: "Previous",
         value: {
-          action: "turn_reset_page",
-          sessionId: current.localSessionId,
+          action: options.sessionReference ? "session_turns_page" : "turn_reset_page",
+          sessionId: options.sessionReference ?? current.localSessionId,
           contextKey,
           page: String(page - 1),
         },
@@ -6082,14 +6372,15 @@ export class ProxySessionController {
       ...(page < totalPages - 1 ? [{
         text: "Next",
         value: {
-          action: "turn_reset_page",
-          sessionId: current.localSessionId,
+          action: options.sessionReference ? "session_turns_page" : "turn_reset_page",
+          sessionId: options.sessionReference ?? current.localSessionId,
           contextKey,
           page: String(page + 1),
         },
       }] : []),
     ];
     const card = this.cardRenderer.renderResetHistoryCard({
+      ...(options.sessionReference ? { taskTitle: current.title ?? current.remoteSessionId, readOnly } : {}),
       entries,
       footerLines: [
         hasMoreHistory
@@ -6108,6 +6399,78 @@ export class ProxySessionController {
     }
   }
 
+  private async openRemoteTurnHistory(
+    contextKey: string,
+    reference: string,
+    options: ResetHistoryCardOptions,
+  ): Promise<void> {
+    const { runtime, remote } = await this.resolveRemoteCodexSession(reference);
+    if (!runtime.listRemoteTurnSummaries) throw new Error("当前 Agent 不支持读取历史轮次。");
+    const page = Math.max(0, Math.trunc(options.page ?? 0));
+    const running = remote.lastTurnStatus === "inProgress" && remote.lastTurnId;
+    let cursor = options.cursor;
+    // Next carries its cursor; only backwards navigation needs to locate a page again.
+    if (!cursor && page > 0) {
+      const seen = new Set<string>();
+      for (let index = 0; index < page; index += 1) {
+        const previous = await runtime.listRemoteTurnSummaries(remote.id, {
+          cursor,
+          limit: RESET_HISTORY_PAGE_SIZE - (index === 0 && running ? 1 : 0),
+        });
+        if (!previous.nextCursor || seen.has(previous.nextCursor)) {
+          throw new Error("任务轮次已变化，请从 /sessions 重新打开 Turns。");
+        }
+        cursor = previous.nextCursor;
+        seen.add(cursor);
+      }
+    }
+    const result = await runtime.listRemoteTurnSummaries(remote.id, {
+      cursor,
+      limit: RESET_HISTORY_PAGE_SIZE - (page === 0 && running ? 1 : 0),
+    });
+    if (result.nextCursor && result.nextCursor === cursor) {
+      throw new Error("历史轮次分页游标无效，请稍后重试。");
+    }
+    const turns = [
+      ...(page === 0 && running ? [{ id: running, prompt: remote.lastUserPrompt }] : []),
+      ...result.turns,
+    ];
+    const entries: ResetHistoryCardEntry[] = turns.map((turn, index) => ({
+      sequence: page * RESET_HISTORY_PAGE_SIZE + index + 1,
+      graphNodeLine: "●",
+      graphConnectorLine: index < turns.length - 1 ? "│" : undefined,
+      lines: [cardText(truncateText((turn.prompt ?? "未记录对话内容").replace(/\s+/g, " ").trim(), 100))],
+      timestamp: formatResetTurnTime(turn.completedAt ?? turn.startedAt),
+      current: remote.lastTurnStatus === "completed" && remote.lastTurnId === turn.id,
+      running: running === turn.id,
+    }));
+    const pageAction = (text: string, targetPage: number, targetCursor?: string): TaskListCardAction => ({
+      text,
+      value: {
+        action: "session_turns_page",
+        sessionId: reference,
+        contextKey,
+        page: String(targetPage),
+        ...(targetCursor ? { cursor: targetCursor } : {}),
+      },
+    });
+    const card = this.cardRenderer.renderResetHistoryCard({
+      taskTitle: remote.title ?? remote.preview ?? remote.id,
+      readOnly: true,
+      entries,
+      footerLines: [`第 ${page + 1} 页 · 本页 ${entries.length} 个 turn`],
+      pageActions: [
+        ...(page > 0 ? [pageAction("Previous", page - 1)] : []),
+        ...(result.nextCursor ? [pageAction("Next", page + 1, result.nextCursor)] : []),
+      ],
+    });
+    if (options.updateMessageId) {
+      await this.outbound.updateInteractiveCard(contextKey, options.updateMessageId, card);
+    } else {
+      await this.outbound.sendInteractiveCard(contextKey, card);
+    }
+  }
+
   private async openDirectoryBrowser(
     contextKey: string,
     requestedDirectory?: string,
@@ -6403,6 +6766,16 @@ export class ProxySessionController {
           contextKey,
         },
       })];
+      actions.push(bindCardAction({
+        text: "SwitchGroup",
+        value: {
+          action: "session_switch_group",
+          sessionId: entry.reference,
+          ...(searchTerm ? { searchTerm } : {}),
+          page: String(page),
+          contextKey,
+        },
+      }));
       const projectActions: TaskListCardAction[] = [bindCardAction({
         text: "New",
         value: {
@@ -6450,6 +6823,14 @@ export class ProxySessionController {
           contextKey,
         },
       }));
+      actions.push(bindCardAction({
+        text: "Turns",
+        value: {
+          action: "session_turns",
+          sessionId: entry.reference,
+          contextKey,
+        },
+      }));
       actions.push(bindCardAction({
         text: "Archive",
         value: {
@@ -6667,6 +7048,7 @@ export class ProxySessionController {
         existing.cwd,
         this.agentLabel(existing.agentName),
         existing.model,
+        existing.modelProvider,
       );
       await this.outbound.sendText(contextKey, `已切换到任务：${existing.title ?? existing.remoteSessionId ?? taskId}`);
       return;
@@ -6701,6 +7083,7 @@ export class ProxySessionController {
       remote.cwd,
       this.agentLabel(agentName),
       remote.model,
+      remote.modelProvider,
     );
     await this.outbound.sendText(
       contextKey,
@@ -7131,12 +7514,30 @@ export class ProxySessionController {
     const actions: TaskListCardAction[] = [
       statusRefreshAction(taskId, contextKey),
       ...taskActions,
+      ...this.statusPreviewActions(contextKey, activeTurnId ?? current?.lastTurnId, current?.remoteSessionId ? {
+        agentName: current.agentName, remoteSessionId: current.remoteSessionId, localSessionId: current.localSessionId,
+      } : undefined),
     ];
     const card = this.cardRenderer.renderSectionsCard(title, sections, actions);
     if (options.updateMessageId) await this.outbound.updateInteractiveCard(contextKey, options.updateMessageId, card);
     else await this.outbound.sendInteractiveCard(contextKey, card);
   }
 
+  private statusPreviewActions(
+    contextKey: string,
+    turnId?: string,
+    source?: { agentName: string; remoteSessionId: string; localSessionId?: string },
+  ): TaskListCardAction[] {
+    if (!turnId || turnId.startsWith("pending_")) return [];
+    if (source && this.runtimes.forAgent(source.agentName).readRemoteTurn) {
+      this.store.saveTurnRuntimeOrigin(turnId,
+        source.localSessionId ?? remoteSessionReference(source.agentName, source.remoteSessionId),
+        source.agentName, source.remoteSessionId);
+    }
+    const url = this.outbound.getTurnPreviewUrl(contextKey, turnId);
+    return url ? [{ text: "Preview", value: {}, url }] : [];
+  }
+
   private async statusForCodexTask(
     contextKey: string,
     reference: string,
@@ -7193,6 +7594,7 @@ export class ProxySessionController {
         actionReference,
         contextKey,
       ),
+      ...this.statusPreviewActions(contextKey, remote.lastTurnId, { agentName, remoteSessionId: remote.id }),
     ];
     const card = this.cardRenderer.renderSectionsCard(title, sections, actions);
     if (options.updateMessageId) await this.outbound.updateInteractiveCard(contextKey, options.updateMessageId, card);
@@ -7282,7 +7684,7 @@ export class ProxySessionController {
     await this.outbound.sendText(
       contextKey,
       enabled
-        ? "已开启当前群的静音模式。之后只有 @ 机器人的消息会被处理；发送 @机器人 /mute off 可恢复自动响应。"
+        ? "已开启当前群的静音模式。之后只有 @ 机器人的消息会被处理；普通提问会补充当前群/话题近期文字和图片（最多 20 条、6 张图片）。发送 @机器人 /mute off 可恢复自动响应并关闭自动补充。"
         : "已关闭当前群的静音模式。机器人将恢复自动响应群消息。",
     );
   }
@@ -8217,6 +8619,17 @@ function isUnmaterializedCodexThreadError(error: unknown): boolean {
   return /thread\/read failed:[^\n]*(?:not materialized|not loaded|includeTurns is unavailable before first user message)/i.test(message);
 }
 
+function needsHistoricalDetails(state: TurnViewState): boolean {
+  if (!isTerminalTurnViewStatus(state.status) || state.historyDetail === "full") return false;
+  if (state.historyDetail === "summary") return true;
+  return state.status === "completed" && state.finalResponse === undefined && !state.assistantText
+    && !state.error && !state.progressText && !state.approval && !state.activeTool
+    && !state.activities?.length && !state.plan?.length && !state.reasoningItems?.length
+    && !state.completedTools?.length && !state.failedTools?.length && !state.fileSummary?.length
+    && !state.totalToolCount && !state.totalTokens
+    && state.fullToolOutputs === undefined && state.fullToolErrors === undefined && state.toolStatuses === undefined;
+}
+
 function turnViewSnapshot(value: unknown): TurnViewState | undefined {
   if (!value || typeof value !== "object") return undefined;
   const candidate = value as Partial<TurnViewState>;
@@ -8543,7 +8956,7 @@ function isBotOwnedActiveTurn(record: SessionRecord, remote: RemoteSessionSummar
 }
 
 function isQueueIndependentCommand(command: Command): boolean {
-  if (["archive", "dismiss", "stop", "status", "restart", "release", "mute", "help", "sessions", "dir", "file", "goal", "nosteer", "shell"].includes(command.type)) return true;
+  if (["archive", "dismiss", "stop", "status", "restart", "update", "release", "mute", "help", "sessions", "dir", "file", "goal", "nosteer", "shell"].includes(command.type)) return true;
   if (command.type === "agent") return command.agent === undefined;
   if (["model", "provider", "thinking", "permissions"].includes(command.type)) return true;
   return false;