@keyou007/agent-bot 0.1.14 → 0.1.15-alpha.1

package/src/proxy/ProxySessionController.ts

@@ -13,6 +13,7 @@ import type {
   ChatUpdatedEvent,
   IncomingMessage,
   MessageReplyTarget,
+  ReferencedMessageContent,
 } from "../feishu/types.js";
 import {
   CardRenderer,
@@ -23,9 +24,12 @@ import {
   type ResetHistoryCardEntry,
   type SessionTaskCardEntry,
   type SessionTaskCardGroup,
+  type ShellCommandCardView,
   type TaskListCardAction,
 } from "../feishu/CardRenderer.js";
+import { CardUpdateScheduler } from "../feishu/CardUpdateScheduler.js";
 import { generateGroupAvatarPng, resolveGroupAvatarProjectName } from "../feishu/GroupAvatarGenerator.js";
+import { normalizeFeishuPostText } from "../feishu/InboundText.js";
 import { allowsFeishuUser } from "../feishu/ownerAccess.js";
 import type { OutboundRouter } from "../presentation/OutboundRouter.js";
 import type { TurnActivity, TurnViewState } from "../presentation/turnViewTypes.js";
@@ -52,10 +56,12 @@ import {
   type TurnAnchorRecord,
 } from "../state/StateStore.js";
 import { createId } from "../utils/id.js";
-import { asInlineCode, codeBlock, truncateMiddle, truncateText } from "../utils/markdown.js";
+import { truncateMiddle, truncateText } from "../utils/markdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import {
   executeShellCommand,
+  type ShellCommandOptions,
+  type ShellCommandOutputSnapshot,
   type ShellCommandResult,
 } from "../utils/executeShellCommand.js";
 
@@ -72,6 +78,20 @@ interface StartTurnOptions {
   preserveAttemptOnFailure?: boolean;
 }
 
+interface PendingForwardAttachment {
+  contextKey: string;
+  attachmentMessageId?: string;
+  attachmentPromise: Promise<IncomingMessage | undefined>;
+  resolveAttachment: (message: IncomingMessage | undefined) => void;
+}
+
+interface ForwardAttachmentReservation {
+  sourceMessageId: string;
+  sourceKind: "merged_forward" | "resource";
+  pending: PendingForwardAttachment;
+  registry: Map<string, PendingForwardAttachment>;
+}
+
 const MESSAGE_RECEIVED_REACTION = "OnIt";
 const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
@@ -82,6 +102,10 @@ const RESET_HISTORY_PAGE_SIZE = 10;
 const MAX_LLM_TURN_RETRIES = 3;
 const RECOVERY_ACTIVITY_WINDOW_MS = 5 * 60 * 1_000;
 const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
+const SHELL_COMMAND_ELAPSED_UPDATE_INTERVAL_MS = 3_000;
+const FORWARD_ATTACHMENT_WINDOW_MS = 800;
+const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
+const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
 const REMOTE_SESSION_REFERENCE_PREFIX = "agent-runtime:";
 const WINDOWS_DRIVES_DIRECTORY = "agentbot://windows-drives";
 const IMAGE_FILE_EXTENSIONS = new Set([
@@ -347,7 +371,11 @@ export interface ProxyLifecycle {
   rememberFeishuUserOpenId?(userOpenId: string): Promise<void> | void;
 }
 
-export type ShellCommandExecutor = (command: string, cwd: string) => Promise<ShellCommandResult>;
+export type ShellCommandExecutor = (
+  command: string,
+  cwd: string,
+  options?: ShellCommandOptions,
+) => Promise<ShellCommandResult>;
 export interface WindowsDriveInfo {
   root: string;
   label?: string;
@@ -370,6 +398,9 @@ export class ProxySessionController {
   private readonly llmRetryingSessions = new Set<string>();
   private readonly retriedFailureTurnIds = new Set<string>();
   private readonly recoveryRetryTimers = new Map<string, NodeJS.Timeout>();
+  private readonly pendingMergedForwards = new Map<string, PendingForwardAttachment>();
+  private readonly pendingResourceForwards = new Map<string, PendingForwardAttachment>();
+  private readonly relatedReactionMessageIds = new Map<string, string[]>();
   private readonly unsubscribe: Array<() => void> = [];
   private readonly recoveryActivityHeartbeat: NodeJS.Timeout;
   private startupRecovery?: Promise<void>;
@@ -406,6 +437,9 @@ export class ProxySessionController {
   }
 
   async onMessage(message: IncomingMessage): Promise<void> {
+    let forwardedImages: Array<{ messageId: string; imageKey: string }> = [];
+    let forwardedFiles: Array<{ messageId: string; fileKey: string; fileName: string }> = [];
+    let coalescedForwardAttachment = false;
     if (!message.contextKey.startsWith("console:") && !allowsFeishuUser(this.config, message.userId)) {
       this.logger.debug(
         { messageId: message.messageId },
@@ -427,6 +461,15 @@ export class ProxySessionController {
     // For accepted messages, claim durable deduplication before acknowledgement so event
     // retries cannot add duplicate reactions.
     if (!this.store.claimInboundEvent(message.messageId, "message")) return;
+    const attachmentReservation = message.mergedForwardMessageId
+      ? undefined
+      : this.reserveForwardAttachment(message);
+    const pendingMergedForward = message.mergedForwardMessageId
+      ? this.registerPendingForwardAttachment(message, this.pendingMergedForwards)
+      : undefined;
+    const pendingResourceForward = !attachmentReservation && isStandaloneResourceMessage(message)
+      ? this.registerPendingForwardAttachment(message, this.pendingResourceForwards)
+      : undefined;
     try {
       const reactionId = await this.outbound.addReaction(
         message.contextKey,
@@ -442,6 +485,13 @@ export class ProxySessionController {
         "Failed to acknowledge the incoming Feishu message with a reaction.",
       );
     }
+    if (attachmentReservation && this.completeForwardAttachment(message, attachmentReservation)) {
+      this.store.audit(message.contextKey, `${attachmentReservation.sourceKind}_attachment_coalesced`, {
+        messageId: message.messageId,
+        parentMessageId: message.parentMessageId,
+      });
+      return;
+    }
     if (message.chatType === "p2p" && message.userId?.startsWith("ou_")) {
       try {
         await this.lifecycle?.rememberFeishuUserOpenId?.(message.userId);
@@ -457,20 +507,165 @@ export class ProxySessionController {
       this.store.recordChatContext(chatContextKey, message.chatType);
       this.store.markChatActive(chatContextKey);
     }
+    if (pendingResourceForward) {
+      const resourceMessage = message;
+      const attachment = await this.waitForForwardAttachment(
+        message.messageId,
+        pendingResourceForward,
+        this.pendingResourceForwards,
+      );
+      if (attachment) {
+        coalescedForwardAttachment = true;
+        const instruction = normalizeFeishuPostText(attachment.text) || defaultResourcePrompt(resourceMessage);
+        forwardedImages = (resourceMessage.images ?? []).map((image) => ({
+          messageId: resourceMessage.messageId,
+          imageKey: image.imageKey,
+        }));
+        forwardedFiles = (resourceMessage.files ?? []).map((file) => ({
+          messageId: resourceMessage.messageId,
+          fileKey: file.fileKey,
+          fileName: file.fileName,
+        }));
+        message = {
+          ...attachment,
+          text: instruction,
+          displayText: instruction,
+        };
+        this.relatedReactionMessageIds.set(message.messageId, [resourceMessage.messageId]);
+      }
+    }
+    if (message.mergedForwardMessageId) {
+      const mergedForwardMessage = message;
+      const mergedForwardResult = this.outbound.readMergedForward(
+        message.contextKey,
+        message.mergedForwardMessageId,
+      ).then(
+        (content) => ({ content } as const),
+        (error: unknown) => ({ error } as const),
+      );
+      const attachment = pendingMergedForward
+        ? await this.waitForForwardAttachment(
+            message.messageId,
+            pendingMergedForward,
+            this.pendingMergedForwards,
+          )
+        : undefined;
+      if (attachment) {
+        coalescedForwardAttachment = true;
+        const instruction = normalizeFeishuPostText(attachment.text)
+          || ((attachment.images?.length ?? 0) > 0 ? "请查看附带的内容。" : "请结合参考聊天记录处理。");
+        message = {
+          ...attachment,
+          text: instruction,
+          displayText: instruction,
+        };
+        this.relatedReactionMessageIds.set(message.messageId, [mergedForwardMessage.messageId]);
+      }
+      const result = await mergedForwardResult;
+      if ("error" in result) {
+        const replyTarget = message.replyInThread
+          ? { messageId: message.messageId, replyInThread: true as const }
+          : undefined;
+        await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
+        const detail = result.error instanceof Error ? result.error.message : String(result.error);
+        await this.outbound.withReplyTarget(
+          message.contextKey,
+          replyTarget,
+          () => this.sendError(message.contextKey, new Error(`无法读取合并转发消息：${detail}`)),
+        );
+        return;
+      }
+      const instruction = message.displayText ?? DEFAULT_MERGED_FORWARD_INSTRUCTION;
+      forwardedImages = result.content.images;
+      forwardedFiles = result.content.files;
+      message = {
+        ...message,
+        displayText: instruction,
+        text: mergedForwardPrompt(instruction, result.content.text),
+      };
+    }
+    const referencedMessageId = coalescedForwardAttachment ? undefined : quotedMessageId(message);
+    if (referencedMessageId) {
+      try {
+        const referenced = await this.resolveReferencedMessage(message.contextKey, referencedMessageId);
+        const instruction = normalizeFeishuPostText(message.displayText ?? message.text)
+          || DEFAULT_REFERENCED_MESSAGE_INSTRUCTION;
+        forwardedImages = [...referenced.images, ...forwardedImages];
+        forwardedFiles = [...referenced.files, ...forwardedFiles];
+        message = {
+          ...message,
+          displayText: instruction,
+          text: referencedMessagePrompt(instruction, referenced.text),
+        };
+      } catch (error) {
+        const replyTarget = message.replyInThread
+          ? { messageId: message.messageId, replyInThread: true as const }
+          : undefined;
+        await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
+        const detail = error instanceof Error ? error.message : String(error);
+        await this.outbound.withReplyTarget(
+          message.contextKey,
+          replyTarget,
+          () => this.sendError(message.contextKey, new Error(`无法读取引用消息：${detail}`)),
+        );
+        return;
+      }
+    }
     const replyTarget = message.replyInThread
       ? { messageId: message.messageId, replyInThread: true as const }
       : undefined;
-    const imageCount = message.images?.length ?? 0;
+    const imageReferences = deduplicateImageReferences([
+      ...forwardedImages,
+      ...(message.images ?? []).map((image) => ({ messageId: message.messageId, imageKey: image.imageKey })),
+    ]);
+    const fileReferences = deduplicateFileReferences([
+      ...forwardedFiles,
+      ...(message.files ?? []).map((file) => ({
+        messageId: message.messageId,
+        fileKey: file.fileKey,
+        fileName: file.fileName,
+      })),
+    ]);
+    const imageCount = imageReferences.length;
+    const fileCount = fileReferences.length;
     this.store.audit(message.contextKey, "incoming_message", {
       messageId: message.messageId,
       text: message.text,
       ...(imageCount > 0 ? { imageCount } : {}),
+      ...(fileCount > 0 ? { fileCount } : {}),
     });
     let localImagePaths: string[] | undefined;
     if (imageCount > 0) {
       try {
-        localImagePaths = await Promise.all(message.images!.map((image) =>
-          this.outbound.downloadImage(message.contextKey, message.messageId, image.imageKey)));
+        localImagePaths = await Promise.all(imageReferences.map((image) =>
+          this.outbound.downloadImage(message.contextKey, image.messageId, image.imageKey)));
+      } catch (error) {
+        await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
+        await this.outbound.withReplyTarget(
+          message.contextKey,
+          replyTarget,
+          () => this.sendError(message.contextKey, error),
+        );
+        return;
+      }
+    }
+    if (fileCount > 0) {
+      try {
+        const downloadedFiles = await Promise.all(fileReferences.map(async (file) => ({
+          fileName: file.fileName,
+          filePath: await this.outbound.downloadFile(
+            message.contextKey,
+            file.messageId,
+            file.fileKey,
+            file.fileName,
+          ),
+        })));
+        const instruction = message.text.trim() || defaultResourcePromptFromCounts(imageCount, fileCount);
+        message = {
+          ...message,
+          displayText: message.displayText ?? instruction,
+          text: appendDownloadedFiles(instruction, downloadedFiles),
+        };
       } catch (error) {
         await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
         await this.outbound.withReplyTarget(
@@ -483,8 +678,9 @@ export class ProxySessionController {
     }
     let command: Command;
     try {
-      command = imageCount > 0 && !message.text.trimStart().startsWith("/")
-        ? { type: "prompt", text: message.text.trim() || "请查看这张图片" }
+      const resourceCount = imageCount + fileCount;
+      command = resourceCount > 0 && !message.text.trimStart().startsWith("/")
+        ? { type: "prompt", text: message.text.trim() || defaultResourcePromptFromCounts(imageCount, fileCount) }
         : this.router.parse(message.text);
     } catch (error) {
       await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
@@ -499,7 +695,7 @@ export class ProxySessionController {
     if (isQueueIndependentCommand(command)) {
       await this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
         try {
-          if (command.type !== "forkgroup" && command.type !== "dismiss") await this.ensureThreadFork(message);
+          if (command.type === "prompt") await this.ensureThreadFork(message);
           await this.execute(
             message.contextKey,
             command,
@@ -522,7 +718,7 @@ export class ProxySessionController {
     const next = previous.catch(() => undefined).then(() =>
       this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
         try {
-          if (command.type !== "forkgroup") await this.ensureThreadFork(message);
+          if (command.type === "prompt") await this.ensureThreadFork(message);
           await this.execute(
             message.contextKey,
             command,
@@ -818,6 +1014,11 @@ export class ProxySessionController {
     this.queuedPromptCards.clear();
     this.queuedPromptCardWrites.clear();
     this.sessionResets.clear();
+    for (const pending of this.pendingMergedForwards.values()) pending.resolveAttachment(undefined);
+    this.pendingMergedForwards.clear();
+    for (const pending of this.pendingResourceForwards.values()) pending.resolveAttachment(undefined);
+    this.pendingResourceForwards.clear();
+    this.relatedReactionMessageIds.clear();
     for (const timer of this.recoveryRetryTimers.values()) clearTimeout(timer);
     this.recoveryRetryTimers.clear();
     clearInterval(this.recoveryActivityHeartbeat);
@@ -1296,8 +1497,7 @@ export class ProxySessionController {
     if (!session.remoteSessionId || !this.isCodexSession(session)) {
       throw new Error("The task is not an App Server task that can be reset.");
     }
-    const contextKey = this.controlSessionContextKey(session);
-    const rows = this.store.listCompletedTurnGraph(session.localSessionId, contextKey);
+    const rows = this.store.listTaskTurnGraph(session.localSessionId);
     const graph = buildTurnGraphRows(rows.map((turn) => ({ turnId: turn.turnId, parentTurnId: turn.parentTurnId })));
     return {
       session,
@@ -1449,6 +1649,9 @@ export class ProxySessionController {
     incomingMessage?: IncomingMessage,
   ): Promise<void> {
     const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent!);
+    if (!this.currentSession(contextKey) && isThreadContextKey(contextKey) && commandRequiresCurrentSession(command)) {
+      throw new Error(unboundThreadTaskMessage());
+    }
     switch (command.type) {
       case "shell":
         await this.runShellCommand(contextKey, command.command);
@@ -1499,7 +1702,14 @@ export class ProxySessionController {
         await this.setTitle(contextKey, command.title);
         return;
       case "prompt":
-        await this.prompt(contextKey, command.text, messageId, replyTarget, localImagePaths);
+        await this.prompt(
+          contextKey,
+          command.text,
+          messageId,
+          replyTarget,
+          localImagePaths,
+          incomingMessage?.displayText,
+        );
         return;
       case "nosteer":
         await this.enqueueNoSteerPrompt(contextKey, command.text, messageId, replyTarget);
@@ -1986,6 +2196,7 @@ export class ProxySessionController {
     messageId?: string,
     replyTarget?: MessageReplyTarget,
     localImagePaths?: string[],
+    displayPrompt?: string,
   ): Promise<void> {
     if (!text.trim()) throw new Error("请输入要交给 Agent 的内容。");
     let record = this.currentSession(contextKey);
@@ -1997,11 +2208,11 @@ export class ProxySessionController {
         this.inheritedNewTaskCwd(contextKey),
         false,
         true,
-        text,
+        displayPrompt ?? text,
         replyTarget,
       );
     }
-    await this.promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths);
+    await this.promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths, displayPrompt);
   }
 
   private async promptSession(
@@ -2011,12 +2222,14 @@ export class ProxySessionController {
     messageId?: string,
     replyTarget?: MessageReplyTarget,
     localImagePaths?: string[],
+    displayPrompt?: string,
   ): Promise<void> {
     if (this.llmRetryingSessions.has(record.localSessionId)) {
       const queued = this.persistQueuedPrompt(record.localSessionId, contextKey, text, {
         localImagePaths,
         messageId,
         replyTarget,
+        displayPrompt,
       });
       this.store.audit(contextKey, "queued_prompt_added_during_llm_retry", {
         promptId: queued.promptId,
@@ -2034,7 +2247,13 @@ export class ProxySessionController {
         record.cwd,
         this.agentLabel(record.agentName),
       );
-      await this.outbound.startPendingTurn(record.localSessionId, contextKey, record.title, replyTarget, text);
+      await this.outbound.startPendingTurn(
+        record.localSessionId,
+        contextKey,
+        record.title,
+        replyTarget,
+        displayPrompt ?? text,
+      );
     }
     let loaded: LoadedSession;
     try {
@@ -2065,12 +2284,13 @@ export class ProxySessionController {
           localImagePaths,
           messageId,
           replyTarget,
+          displayPrompt,
         });
         return;
       }
       try {
         await loaded.runtime.steerTurn(record.localSessionId, activeTurnId, runtimePrompt(text, localImagePaths));
-        await this.presentSteerMessage(record.localSessionId, activeTurnId, text, messageId);
+        await this.presentSteerMessage(record.localSessionId, activeTurnId, displayPrompt ?? text, messageId);
         if (messageId) await this.bindMessageReactionToTurn(messageId, record.localSessionId, activeTurnId);
         return;
       } catch (error) {
@@ -2082,7 +2302,7 @@ export class ProxySessionController {
           this.logger.warn({ error: syncError, sessionId: record.localSessionId }, "Failed to synchronize after steering failure.");
         }
         if (!current?.activeTurnId) {
-          const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId });
+          const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId, displayPrompt });
           if (messageId) await this.bindMessageReactionToTurn(messageId, record.localSessionId, turnId);
           return;
         }
@@ -2093,7 +2313,12 @@ export class ProxySessionController {
               current.activeTurnId,
               runtimePrompt(text, localImagePaths),
             );
-            await this.presentSteerMessage(record.localSessionId, current.activeTurnId, text, messageId);
+            await this.presentSteerMessage(
+              record.localSessionId,
+              current.activeTurnId,
+              displayPrompt ?? text,
+              messageId,
+            );
             if (messageId) await this.bindMessageReactionToTurn(messageId, record.localSessionId, current.activeTurnId);
             return;
           } catch (retryError) {
@@ -2107,11 +2332,12 @@ export class ProxySessionController {
           localImagePaths,
           messageId,
           replyTarget,
+          displayPrompt,
         });
         return;
       }
     }
-    const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId });
+    const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId, displayPrompt });
     if (messageId) await this.bindMessageReactionToTurn(messageId, record.localSessionId, turnId);
   }
 
@@ -2156,6 +2382,7 @@ export class ProxySessionController {
       localImagePaths?: string[];
       messageId?: string;
       replyTarget?: MessageReplyTarget;
+      displayPrompt?: string;
     } = {},
   ): QueuedPromptRecord {
     return this.store.enqueuePrompt({
@@ -2166,6 +2393,7 @@ export class ProxySessionController {
       localImagePaths: options.localImagePaths,
       messageId: options.messageId,
       replyMessageId: options.replyTarget?.messageId,
+      displayPrompt: options.displayPrompt,
     });
   }
 
@@ -2227,7 +2455,7 @@ export class ProxySessionController {
       contextKey,
       prompts: this.store.listQueuedPrompts(localSessionId).map((prompt) => ({
         id: prompt.promptId,
-        text: prompt.text,
+        text: prompt.displayPrompt ?? prompt.text,
       })),
     });
   }
@@ -2729,7 +2957,7 @@ export class ProxySessionController {
     options: StartTurnOptions = {},
   ): Promise<string> {
     const currentRecord = this.store.getSession(loaded.record.localSessionId);
-    const title = currentRecord?.title ?? normalizeTaskTitle(text);
+    const title = currentRecord?.title ?? normalizeTaskTitle(options.displayPrompt ?? text);
     if (!currentRecord?.title && title) this.store.updateRuntimeSession(loaded.record.localSessionId, { title });
     if (title) this.outbound.updateSessionTitle(loaded.record.localSessionId, title);
     const attemptId = options.attemptId ?? createId("attempt");
@@ -3091,7 +3319,13 @@ export class ProxySessionController {
     const existing = runtime.getSession(record.localSessionId);
     if (existing) return { record, runtime, session: existing };
     const pending = this.sessionLoads.get(record.localSessionId);
-    if (pending) return pending;
+    if (pending) {
+      const loaded = await pending;
+      return {
+        ...loaded,
+        record: { ...loaded.record, contextKey: record.contextKey },
+      };
+    }
 
     this.outbound.registerSession(
       record.localSessionId,
@@ -3160,7 +3394,11 @@ export class ProxySessionController {
       }
       this.persistRuntimeSession(record, session, session.activeTurnId ? "running" : "ready");
       const saved = this.store.getSession(record.localSessionId) ?? record;
-      return { record: saved, runtime, session };
+      return {
+        record: { ...saved, contextKey: record.contextKey },
+        runtime,
+        session,
+      };
     })();
     this.sessionLoads.set(record.localSessionId, loading);
     try {
@@ -3259,6 +3497,7 @@ export class ProxySessionController {
     }
 
     if (event.type === "turn_completed" || event.type === "turn_cancelled" || event.type === "turn_failed") {
+      await this.refreshGoalCards(event.sessionId);
       const terminalStatus = event.type === "turn_completed"
         ? "completed"
         : event.type === "turn_cancelled"
@@ -3392,7 +3631,7 @@ export class ProxySessionController {
         prompt.text,
         prompt.replyMessageId ? { messageId: prompt.replyMessageId, replyInThread: true } : undefined,
         prompt.localImagePaths,
-        { messageId: prompt.messageId },
+        { messageId: prompt.messageId, displayPrompt: prompt.displayPrompt },
       );
       if (prompt.messageId) await this.bindMessageReactionToTurn(prompt.messageId, sessionId, turnId);
     } catch (error) {
@@ -3418,13 +3657,17 @@ export class ProxySessionController {
     messageId: string,
     status: "completed" | "failed" | "cancelled",
   ): Promise<void> {
-    const reaction = this.store.claimMessageReaction(messageId);
-    if (reaction) await this.replaceMessageReaction(reaction, status);
+    for (const relatedMessageId of this.takeRelatedReactionMessageIds(messageId)) {
+      const reaction = this.store.claimMessageReaction(relatedMessageId);
+      if (reaction) await this.replaceMessageReaction(reaction, status);
+    }
   }
 
   private async bindMessageReactionToTurn(messageId: string, sessionId: string, turnId: string): Promise<void> {
-    this.store.bindMessageToTurn(messageId, sessionId, turnId);
-    this.store.bindMessageReaction(messageId, sessionId, turnId);
+    for (const relatedMessageId of this.takeRelatedReactionMessageIds(messageId)) {
+      this.store.bindMessageToTurn(relatedMessageId, sessionId, turnId);
+      this.store.bindMessageReaction(relatedMessageId, sessionId, turnId);
+    }
     const session = this.store.getSession(sessionId);
     if (session?.lastTurnId !== turnId) return;
     if (session.lastTurnStatus === "completed" || session.lastTurnStatus === "failed" || session.lastTurnStatus === "cancelled") {
@@ -3432,6 +3675,101 @@ export class ProxySessionController {
     }
   }
 
+  private registerPendingForwardAttachment(
+    message: IncomingMessage,
+    registry: Map<string, PendingForwardAttachment>,
+  ): PendingForwardAttachment {
+    let resolveAttachment!: (message: IncomingMessage | undefined) => void;
+    const attachmentPromise = new Promise<IncomingMessage | undefined>((resolve) => {
+      resolveAttachment = resolve;
+    });
+    const pending = {
+      contextKey: message.contextKey,
+      attachmentPromise,
+      resolveAttachment,
+    };
+    registry.set(message.messageId, pending);
+    return pending;
+  }
+
+  private reserveForwardAttachment(message: IncomingMessage): ForwardAttachmentReservation | undefined {
+    if (!message.parentMessageId) return undefined;
+    const candidates = [
+      { sourceKind: "merged_forward" as const, registry: this.pendingMergedForwards },
+      { sourceKind: "resource" as const, registry: this.pendingResourceForwards },
+    ];
+    for (const candidate of candidates) {
+      const pending = candidate.registry.get(message.parentMessageId);
+      if (!pending || pending.contextKey !== message.contextKey || pending.attachmentMessageId) continue;
+      pending.attachmentMessageId = message.messageId;
+      return {
+        sourceMessageId: message.parentMessageId,
+        sourceKind: candidate.sourceKind,
+        pending,
+        registry: candidate.registry,
+      };
+    }
+    return undefined;
+  }
+
+  private completeForwardAttachment(
+    message: IncomingMessage,
+    reservation: ForwardAttachmentReservation,
+  ): boolean {
+    if (!message.parentMessageId) return false;
+    if (reservation.sourceMessageId !== message.parentMessageId) return false;
+    if (reservation.registry.get(message.parentMessageId) !== reservation.pending) return false;
+    if (reservation.pending.attachmentMessageId !== message.messageId) return false;
+    reservation.pending.resolveAttachment(message);
+    return true;
+  }
+
+  private async waitForForwardAttachment(
+    messageId: string,
+    pending: PendingForwardAttachment,
+    registry: Map<string, PendingForwardAttachment>,
+  ): Promise<IncomingMessage | undefined> {
+    let timer: NodeJS.Timeout | undefined;
+    const timeout = new Promise<undefined>((resolve) => {
+      timer = setTimeout(() => resolve(undefined), FORWARD_ATTACHMENT_WINDOW_MS);
+      timer.unref?.();
+    });
+    try {
+      return await Promise.race([pending.attachmentPromise, timeout]);
+    } finally {
+      if (timer) clearTimeout(timer);
+      if (registry.get(messageId) === pending) {
+        registry.delete(messageId);
+      }
+    }
+  }
+
+  private async resolveReferencedMessage(
+    contextKey: string,
+    messageId: string,
+  ): Promise<ReferencedMessageContent> {
+    const local = this.store.findAgentBotTurnMessageById(messageId);
+    if (local) {
+      const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(local.turnId));
+      const text = snapshot ? renderLocalTurnReference(snapshot, local.messageKind) : undefined;
+      if (text) {
+        return {
+          text,
+          messageType: local.messageKind === "final" ? "agent_bot_reply" : "agent_bot_progress",
+          images: [],
+          files: [],
+        };
+      }
+    }
+    return this.outbound.readReferencedMessage(contextKey, messageId);
+  }
+
+  private takeRelatedReactionMessageIds(messageId: string): string[] {
+    const related = this.relatedReactionMessageIds.get(messageId) ?? [];
+    this.relatedReactionMessageIds.delete(messageId);
+    return [...new Set([messageId, ...related])];
+  }
+
   private async finalizeTurnMessageReactions(
     turnId: string,
     status: "completed" | "failed" | "cancelled",
@@ -3567,8 +3905,10 @@ export class ProxySessionController {
       throw new Error("当前任务不是可 Reset 的 App Server 任务。");
     }
 
-    const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(turnId));
-    if (!snapshot || snapshot.sessionId !== current.localSessionId || snapshot.status !== "completed") {
+    const historyTurn = this.store.listTaskTurnGraph(current.localSessionId)
+      .find((turn) => turn.turnId === turnId);
+    const snapshot = turnViewSnapshot(historyTurn?.snapshot);
+    if (!snapshot || snapshot.status !== "completed") {
       throw new Error("只能将当前任务 Reset 到已成功完成的轮次。");
     }
     if (current.lastTurnId === turnId && current.lastTurnStatus === "completed") {
@@ -3589,7 +3929,7 @@ export class ProxySessionController {
     }
 
     const origin = this.store.getTurnRuntimeOrigin(turnId);
-    if (origin && (origin.localSessionId !== current.localSessionId || origin.agentName !== current.agentName)) {
+    if (origin && origin.agentName !== current.agentName) {
       throw new Error("这张思考卡片与当前任务不匹配，已拒绝 Reset。");
     }
     const sourceRemoteSessionId = origin?.remoteSessionId ?? current.remoteSessionId;
@@ -4053,6 +4393,25 @@ export class ProxySessionController {
     notice?: string,
     record = this.currentSession(contextKey),
   ): Promise<void> {
+    const card = this.renderGoalCard(goal, notice, record);
+    if (!record) {
+      await this.outbound.sendInteractiveCard(contextKey, card);
+      return;
+    }
+    const existing = this.store.getGoalCardDelivery(record.localSessionId, contextKey);
+    if (existing) {
+      await this.outbound.updateInteractiveCard(contextKey, existing.messageId, card);
+      return;
+    }
+    const messageId = await this.outbound.sendInteractiveCard(contextKey, card);
+    if (messageId) this.store.saveGoalCardDelivery(record.localSessionId, contextKey, messageId);
+  }
+
+  private renderGoalCard(
+    goal: RuntimeGoal | undefined,
+    notice?: string,
+    record?: SessionRecord,
+  ): Record<string, unknown> {
     const sections: CardSection[] = [];
     if (notice) sections.push({ lines: [cardText(notice)] });
     sections.push(goal
@@ -4074,24 +4433,138 @@ export class ProxySessionController {
         "**/goal edit &#60;新目标&#62;**　修改　　**/goal clear**　清除",
       ],
     });
-    await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderSectionsCard("Agent Goal", sections));
+    const title = goal ? `Agent Goal · ${goalStatusLabel(goal.status)}` : "Agent Goal";
+    return this.cardRenderer.renderSectionsCard(title, sections);
+  }
+
+  private async refreshGoalCards(localSessionId: string): Promise<void> {
+    const deliveries = this.store.listGoalCardDeliveries(localSessionId);
+    if (deliveries.length === 0) return;
+    const record = this.store.getSession(localSessionId);
+    if (!record) return;
+    const runtime = this.runtimes.forAgent(record.agentName);
+    if (runtime.kind !== "codex" || !runtime.getGoal) return;
+
+    try {
+      const loaded = runtime.getSession(localSessionId) ?? (await this.loadSession(record)).session;
+      const goal = await runtime.getGoal(loaded.localSessionId);
+      const card = this.renderGoalCard(goal, undefined, record);
+      await Promise.all(deliveries.map(async (delivery) => {
+        try {
+          await this.outbound.updateInteractiveCard(delivery.contextKey, delivery.messageId, card);
+        } catch (error) {
+          this.logger.warn(
+            { error, localSessionId, contextKey: delivery.contextKey, messageId: delivery.messageId },
+            "Failed to refresh an Agent Goal card.",
+          );
+        }
+      }));
+    } catch (error) {
+      this.logger.warn({ error, localSessionId }, "Failed to read the latest Agent Goal status.");
+    }
   }
 
   private async runShellCommand(contextKey: string, command: string): Promise<void> {
     const cwd = this.currentSession(contextKey)?.cwd ?? this.config.defaults.cwd;
-    const result = await this.shellCommandExecutor(command, cwd);
-    const outputParts = [
-      result.stdout.trimEnd(),
-      result.stderr.trimEnd() ? `[stderr]\n${result.stderr.trimEnd()}` : "",
-    ].filter(Boolean);
-    const output = truncateMiddle(outputParts.join("\n"), 6_000);
-    const status = result.timedOut
-      ? "已超时（120s）"
-      : `退出码 ${result.exitCode ?? "未知"}`;
-    await this.outbound.sendMarkdown(contextKey, [
-      codeBlock(`$  ${command.trim()}\n${output || "（无输出）"}`, "text"),
-      `${asInlineCode(cwd)} · ${status}${result.outputTruncated ? " · 输出已截断" : ""}`,
-    ].join("\n"));
+    const startedAt = Date.now();
+    let latestOutput: ShellCommandOutputSnapshot = {
+      stdout: "",
+      stderr: "",
+      outputTruncated: false,
+    };
+    let runningState: ShellCommandCardView = {
+      command,
+      cwd,
+      ...latestOutput,
+      status: "running",
+      elapsedMs: 0,
+    };
+    const cardMessageId = await this.outbound.sendInteractiveCard(
+      contextKey,
+      this.cardRenderer.renderShellCommandCard(runningState),
+    );
+    const scheduler = cardMessageId
+      ? new CardUpdateScheduler<ShellCommandCardView>({
+          render: (state) => this.cardRenderer.renderShellCommandCard(state),
+          write: (card) => this.outbound.updateInteractiveCard(contextKey, cardMessageId, card),
+          onError: (error) => this.logger.warn(
+            { error, contextKey, messageId: cardMessageId },
+            "Failed to update a shell command card.",
+          ),
+        })
+      : undefined;
+    scheduler?.seed(runningState);
+    const elapsedTimer = scheduler ? setInterval(() => {
+      runningState = { ...runningState, elapsedMs: Date.now() - startedAt };
+      scheduler.update(runningState);
+    }, SHELL_COMMAND_ELAPSED_UPDATE_INTERVAL_MS) : undefined;
+    elapsedTimer?.unref?.();
+
+    const updateRunningOutput = (snapshot: ShellCommandOutputSnapshot): void => {
+      latestOutput = snapshot;
+      runningState = {
+        ...runningState,
+        ...snapshot,
+        elapsedMs: Date.now() - startedAt,
+      };
+      scheduler?.update(runningState);
+    };
+
+    let result: ShellCommandResult;
+    try {
+      result = await this.shellCommandExecutor(command, cwd, { onOutput: updateRunningOutput });
+    } catch (error) {
+      if (elapsedTimer) clearInterval(elapsedTimer);
+      const failedCard = this.cardRenderer.renderShellCommandCard({
+        command,
+        cwd,
+        ...latestOutput,
+        stderr: [latestOutput.stderr.trimEnd(), runtimeErrorMessage(error)].filter(Boolean).join("\n"),
+        status: "failed",
+        elapsedMs: Date.now() - startedAt,
+      });
+      if (scheduler) {
+        try {
+          await scheduler.flush({
+            ...runningState,
+            stderr: [latestOutput.stderr.trimEnd(), runtimeErrorMessage(error)].filter(Boolean).join("\n"),
+            status: "failed",
+            elapsedMs: Date.now() - startedAt,
+          });
+        } catch (cardError) {
+          this.logger.warn(
+            { error: cardError, contextKey, messageId: cardMessageId },
+            "Failed to finalize a shell command card.",
+          );
+        } finally {
+          scheduler.dispose();
+        }
+      } else {
+        await this.outbound.sendInteractiveCard(contextKey, failedCard);
+      }
+      throw error;
+    }
+
+    if (elapsedTimer) clearInterval(elapsedTimer);
+    const finalState: ShellCommandCardView = {
+      command,
+      cwd,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      status: result.timedOut ? "timed_out" : result.exitCode === 0 ? "completed" : "failed",
+      exitCode: result.exitCode,
+      elapsedMs: Date.now() - startedAt,
+      outputTruncated: result.outputTruncated,
+    };
+    if (scheduler) {
+      try {
+        await scheduler.flush(finalState);
+      } finally {
+        scheduler.dispose();
+      }
+    } else {
+      await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderShellCommandCard(finalState));
+    }
   }
 
   private async setTitle(contextKey: string, title: string): Promise<void> {
@@ -4208,7 +4681,7 @@ export class ProxySessionController {
     if (!current.remoteSessionId || !this.isCodexSession(current)) {
       throw new Error("当前任务不是可 Reset 的 App Server 任务。");
     }
-    const allTurns = this.store.listCompletedTurnGraph(current.localSessionId, contextKey);
+    const allTurns = this.store.listTaskTurnGraph(current.localSessionId);
     const graphRows = buildTurnGraphRows(allTurns.map((turn) => ({
       turnId: turn.turnId,
       parentTurnId: turn.parentTurnId,
@@ -4350,7 +4823,6 @@ export class ProxySessionController {
                 contextKey,
               },
             },
-            actions: directoryCreationActions(entry.path, contextKey),
           }
         : {
             name: entry.name,
@@ -4375,7 +4847,7 @@ export class ProxySessionController {
       footerLines: [
         `第 ${page + 1}/${totalPages} 页 · ${directoryCount} 个目录 · ${entries.length - directoryCount} 个文件`,
         "",
-        "> 点击目录名称进入，点击文件名称发送到当前会话；**New** 在该目录创建任务，**NewGroup** 在该目录创建新群和任务。",
+        "> 点击目录名称进入，点击文件名称发送到当前会话；卡片顶部的 **New** 和 **NewGroup** 使用当前目录。",
       ],
     });
     if (options.updateMessageId) {
@@ -4407,7 +4879,6 @@ export class ProxySessionController {
             contextKey,
           },
         },
-        actions: directoryCreationActions(drive.root, contextKey),
       }));
     const card = this.cardRenderer.renderDirectoryBrowserCard({
       directory: "此电脑",
@@ -4422,7 +4893,7 @@ export class ProxySessionController {
       footerLines: [
         `第 ${page + 1}/${totalPages} 页 · ${drives.length} 个磁盘`,
         "",
-        "> 点击磁盘名称进入；**New** 在磁盘根目录创建任务，**NewGroup** 在磁盘根目录创建新群和任务。",
+        "> 点击磁盘名称进入。",
       ],
     });
     if (options.updateMessageId) {
@@ -5104,7 +5575,9 @@ export class ProxySessionController {
     let activeTurnId: string | undefined;
     let queued = 0;
     if (!current) {
-      taskLines.push("无。直接发送消息即可创建一个未指定项目的 Agent 任务。");
+      taskLines.push(isThreadContextKey(contextKey)
+        ? unboundThreadTaskMessage()
+        : "无。直接发送消息即可创建一个未指定项目的 Agent 任务。");
     } else {
       const agent = this.ensureAgent(current.agentName);
       const runtimeSession = this.runtimes.forAgent(current.agentName).getSession(current.localSessionId);
@@ -5380,7 +5853,11 @@ export class ProxySessionController {
 
   private requireCurrentSession(contextKey: string): SessionRecord {
     const record = this.currentSession(contextKey);
-    if (!record) throw new Error("当前没有任务，直接发送一条消息即可自动创建。");
+    if (!record) {
+      throw new Error(isThreadContextKey(contextKey)
+        ? unboundThreadTaskMessage()
+        : "当前没有任务，直接发送一条消息即可自动创建。");
+    }
     return record;
   }
 
@@ -5897,6 +6374,19 @@ function isQueueIndependentCommand(command: Command): boolean {
   return false;
 }
 
+function commandRequiresCurrentSession(command: Command): boolean {
+  if (["dismiss", "stop", "title", "turns", "model", "provider", "thinking", "permissions", "nosteer"].includes(command.type)) {
+    return true;
+  }
+  if (command.type === "archive" || command.type === "fork") return command.sessionId === undefined;
+  if (command.type === "goal") return command.action !== "set";
+  return false;
+}
+
+function unboundThreadTaskMessage(): string {
+  return "当前话题尚未绑定任务。发送普通消息后，Agent Bot 会从可识别的原始轮次创建分支；没有原始轮次时会创建全新任务。也可以使用 /new 创建全新任务，或使用 /sessions 绑定现有任务。";
+}
+
 function parseSessionPage(value: unknown): number {
   const parsed = typeof value === "string" || typeof value === "number" ? Number(value) : Number.NaN;
   return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : 0;
@@ -6042,6 +6532,104 @@ function runtimePrompt(text: string, localImagePaths?: string[]): RuntimePrompt
   return localImagePaths?.length ? { text, localImagePaths } : text;
 }
 
+function mergedForwardPrompt(
+  instruction: string,
+  transcript: string,
+): string {
+  return `${instruction}\n\n参考聊天记录：\n${transcript}`;
+}
+
+function referencedMessagePrompt(instruction: string, referencedMessage: string): string {
+  return `${instruction}\n\n引用消息：\n${referencedMessage}`;
+}
+
+function quotedMessageId(message: IncomingMessage): string | undefined {
+  const messageId = message.parentMessageId?.trim();
+  if (!messageId || message.contextKey.startsWith("console:")) return undefined;
+  if (message.mergedForwardMessageId) return undefined;
+  const text = message.text.trimStart();
+  if (text.startsWith("/") || text.startsWith("!")) return undefined;
+  if (message.threadContext && message.rootMessageId === messageId) return undefined;
+  return messageId;
+}
+
+function renderLocalTurnReference(
+  snapshot: TurnViewState,
+  messageKind: "progress" | "final",
+): string | undefined {
+  if (messageKind === "final") {
+    const response = snapshot.finalResponse?.trim() || snapshot.assistantText?.trim();
+    return response
+      ? `[消息类型：AgentBot 回复]\n${truncateMiddle(response, 48_000)}`
+      : undefined;
+  }
+
+  const activityText = (snapshot.activities ?? [])
+    .filter((activity): activity is Extract<TurnActivity, { kind: "assistant" | "reasoning" }> =>
+      activity.kind === "assistant" || activity.kind === "reasoning")
+    .map((activity) => activity.text.trim())
+    .filter(Boolean)
+    .join("\n\n");
+  const content = [
+    snapshot.prompt?.trim() ? `用户请求：\n${snapshot.prompt.trim()}` : "",
+    activityText,
+    snapshot.progressText?.trim() || "",
+    snapshot.finalResponse?.trim() || snapshot.assistantText?.trim() || "",
+    snapshot.error?.trim() ? `错误：${snapshot.error.trim()}` : "",
+  ].filter(Boolean).join("\n\n");
+  return content
+    ? `[消息类型：AgentBot 思考卡片]\n${truncateMiddle(content, 48_000)}`
+    : undefined;
+}
+
+function appendDownloadedFiles(
+  prompt: string,
+  files: Array<{ fileName: string; filePath: string }>,
+): string {
+  return `${prompt}\n\n参考文件（已下载到本地）：\n${files.map((file, index) =>
+    `[文件 ${index + 1}：${file.fileName}] ${file.filePath}`).join("\n")}`;
+}
+
+function defaultResourcePrompt(message: IncomingMessage): string {
+  return defaultResourcePromptFromCounts(message.images?.length ?? 0, message.files?.length ?? 0);
+}
+
+function defaultResourcePromptFromCounts(imageCount: number, fileCount: number): string {
+  if (imageCount > 0 && fileCount > 0) return "请查看附带的图片和文件";
+  if (fileCount > 0) return fileCount === 1 ? "请查看这个文件" : "请查看这些文件";
+  return imageCount === 1 ? "请查看这张图片" : "请查看这些图片";
+}
+
+function isStandaloneResourceMessage(message: IncomingMessage): boolean {
+  return !message.mergedForwardMessageId
+    && message.text.trim().length === 0
+    && ((message.images?.length ?? 0) > 0 || (message.files?.length ?? 0) > 0);
+}
+
+function deduplicateImageReferences(
+  images: Array<{ messageId: string; imageKey: string }>,
+): Array<{ messageId: string; imageKey: string }> {
+  const seen = new Set<string>();
+  return images.filter((image) => {
+    const key = `${image.messageId}:${image.imageKey}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function deduplicateFileReferences(
+  files: Array<{ messageId: string; fileKey: string; fileName: string }>,
+): Array<{ messageId: string; fileKey: string; fileName: string }> {
+  const seen = new Set<string>();
+  return files.filter((file) => {
+    const key = `${file.messageId}:${file.fileKey}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
 function recoveryCardPrompt(prompt: string): string {
   return `恢复重启前的任务：${prompt}`;
 }
@@ -6140,14 +6728,13 @@ const GROUP_PROJECT_DIRECTORY_MAX_LENGTH = 15;
 
 function formatGroupProjectDirectory(projectCwd: string): string {
   const value = abbreviateHomeDirectory(projectCwd);
-  if (Array.from(value).length <= GROUP_PROJECT_DIRECTORY_MAX_LENGTH) return `[${value}]`;
-
   const levels = value
     .replace(/[\\/]+$/, "")
     .split(/[\\/]+/)
     .filter(Boolean)
     .slice(-2);
-  return `[${fitTrailingPathLevels(levels, GROUP_PROJECT_DIRECTORY_MAX_LENGTH, path.sep)}]`;
+  const separator = value.includes("\\") ? path.win32.sep : path.posix.sep;
+  return `[${fitTrailingPathLevels(levels, GROUP_PROJECT_DIRECTORY_MAX_LENGTH, separator)}]`;
 }
 
 function abbreviateHomeDirectory(value: string): string {