@keyou007/agent-bot 0.1.18 → 0.1.19-alpha.1

package/src/proxy/ProxySessionController.ts

@@ -4,6 +4,11 @@ import os from "node:os";
 import path from "node:path";
 import type { Logger } from "pino";
 import { createProjectlessWorkspace, detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
+import {
+  SystemThreadWriterProcessController,
+  type ThreadWriterProcess,
+  type ThreadWriterProcessController,
+} from "../codex/ThreadWriterProcess.js";
 import { resolveUserPath } from "../config/paths.js";
 import {
   DEFAULT_GROUP_NAME_FORMAT,
@@ -21,6 +26,7 @@ import type {
   ReferencedMessageContent,
 } from "../feishu/types.js";
 import {
+  type AppServerReleaseCardView,
   CardRenderer,
   type CardSection,
   type DirectoryBrowserCardEntry,
@@ -31,6 +37,7 @@ import {
   type SessionTaskCardGroup,
   type ShellCommandCardView,
   type TaskListCardAction,
+  type ThreadWriterConflictCardView,
 } from "../feishu/CardRenderer.js";
 import { CardUpdateScheduler } from "../feishu/CardUpdateScheduler.js";
 import { generateGroupAvatarPng, resolveGroupAvatarProjectName } from "../feishu/GroupAvatarGenerator.js";
@@ -42,6 +49,7 @@ import {
 import { normalizeFeishuPostText } from "../feishu/InboundText.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 { buildTurnGraphRows } from "../presentation/turnGraph.js";
@@ -52,6 +60,7 @@ import type {
   PermissionMode,
   RemoteCompletedTurnSummary,
   RemoteSessionActivity,
+  RemoteSessionPage,
   RemoteSessionSummary,
   RuntimeGoal,
   RuntimeEvent,
@@ -110,12 +119,55 @@ interface ForwardAttachmentReservation {
   registry: Map<string, PendingForwardAttachment>;
 }
 
+interface PreparedTopicRootPrompt {
+  text: string;
+  localImagePaths?: string[];
+  displayPrompt: string;
+  injectedRootMessageId?: string;
+}
+
 interface ShellCommandJobMonitor {
   scheduler: CardUpdateScheduler<ShellCommandCardView>;
   timer: NodeJS.Timeout;
   refreshing: boolean;
 }
 
+interface AppServerReleaseCardTarget {
+  contextKey: string;
+  messageId: string;
+}
+
+interface AppServerReleaseSchedule {
+  id: number;
+  agentName: string;
+  runtime: AgentRuntime;
+  status: AppServerReleaseCardView["status"];
+  blockingTaskCount: number;
+  targets: Map<string, AppServerReleaseCardTarget>;
+  forced: boolean;
+  releaseAt?: number;
+  releaseCountdownSeconds?: number;
+  releaseStarted?: boolean;
+  error?: string;
+  timer?: NodeJS.Timeout;
+  inFlight?: Promise<void>;
+}
+
+interface RequestFailureDetails {
+  requestId?: string;
+  messageId?: string;
+  actionId?: string;
+  command?: string;
+  phase?: string;
+}
+
+class PresentedRequestError extends Error {
+  constructor(public readonly originalError: unknown) {
+    super(originalError instanceof Error ? originalError.message : String(originalError), { cause: originalError });
+    this.name = "PresentedRequestError";
+  }
+}
+
 const MESSAGE_RECEIVED_REACTION = "OnIt";
 const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
@@ -124,12 +176,15 @@ const SESSION_PAGE_SIZE = 10;
 const SESSION_PROMPT_PREVIEW_LENGTH = 50;
 const DIRECTORY_PAGE_SIZE = 15;
 const RESET_HISTORY_PAGE_SIZE = 10;
+const REMOTE_TURN_HISTORY_REFRESH_INTERVAL_MS = 30_000;
 const MAX_LLM_TURN_RETRIES = 3;
 const QUEUED_PROMPT_RETRY_DELAY_MS = 5_000;
 const RECOVERY_ACTIVITY_WINDOW_MS = 10 * 60 * 1_000;
 const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
 const SHELL_COMMAND_JOB_POLL_INTERVAL_MS = 1_000;
 const SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS = 5_000;
+const APP_SERVER_RELEASE_POLL_INTERVAL_MS = 500;
+const APP_SERVER_RELEASE_IDLE_DELAY_MS = 5_000;
 const FORWARD_ATTACHMENT_WINDOW_MS = 800;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
@@ -263,6 +318,10 @@ const HELP_COMMAND_SECTIONS: Array<{
         usage: "[--force]",
         description: "默认安全重启；--force 立即重启",
       },
+      {
+        command: "/release",
+        description: "释放 Agent Bot 占用的 App Server 任务",
+      },
       {
         command: "/mute",
         usage: "[on|off]",
@@ -391,6 +450,13 @@ export interface ControlTaskGroupResult {
   task: SessionRecord;
 }
 
+export interface ControlTaskReleaseResult {
+  agentName: string;
+  status: "waiting" | "released";
+  blockingTaskCount: number;
+  releaseInSeconds?: number;
+}
+
 export interface ProxyLifecycle {
   supervised?: boolean;
   restart(contextKey: string, force: boolean, replyTarget?: MessageReplyTarget): Promise<void>;
@@ -425,6 +491,7 @@ export class ProxySessionController {
   private readonly queuedPromptCardWrites = new Map<string, Promise<void>>();
   private readonly sessionResets = new Map<string, Promise<void>>();
   private readonly resetHistoryOperations = new Map<string, string>();
+  private readonly remoteTurnHistoryRefreshes = new Map<string, number>();
   private readonly lastSessionListings = new Map<string, string[]>();
   private readonly threadInitializations = new Map<string, Promise<void>>();
   private readonly llmRetryingSessions = new Set<string>();
@@ -435,6 +502,8 @@ export class ProxySessionController {
   private readonly pendingResourceForwards = new Map<string, PendingForwardAttachment>();
   private readonly relatedReactionMessageIds = new Map<string, string[]>();
   private readonly shellCommandJobMonitors = new Map<string, ShellCommandJobMonitor>();
+  private readonly appServerReleaseSchedules = new Map<string, AppServerReleaseSchedule>();
+  private nextAppServerReleaseScheduleId = 1;
   private readonly unsubscribe: Array<() => void> = [];
   private readonly recoveryActivityHeartbeat: NodeJS.Timeout;
   private startupRecovery?: Promise<void>;
@@ -452,6 +521,7 @@ export class ProxySessionController {
     private readonly shellCommandJobs: ShellCommandJobManagerLike = new ShellCommandJobManager(
       path.join(path.dirname(config.storage.sqlitePath), "command-jobs"),
     ),
+    private readonly threadWriterProcesses: ThreadWriterProcessController = new SystemThreadWriterProcessController(),
   ) {
     for (const [, runtime] of this.runtimes.entries()) {
       this.unsubscribe.push(
@@ -608,7 +678,11 @@ export class ProxySessionController {
         await this.outbound.withReplyTarget(
           message.contextKey,
           replyTarget,
-          () => this.sendError(message.contextKey, new Error(`无法读取合并转发消息：${detail}`)),
+          () => this.sendError(message.contextKey, new Error(`无法读取合并转发消息：${detail}`), {
+            requestId: message.messageId,
+            messageId: message.messageId,
+            phase: "merged_forward_read",
+          }),
         );
         return;
       }
@@ -643,7 +717,11 @@ export class ProxySessionController {
         await this.outbound.withReplyTarget(
           message.contextKey,
           replyTarget,
-          () => this.sendError(message.contextKey, new Error(`无法读取引用消息：${detail}`)),
+          () => this.sendError(message.contextKey, new Error(`无法读取引用消息：${detail}`), {
+            requestId: message.messageId,
+            messageId: message.messageId,
+            phase: "referenced_message_read",
+          }),
         );
         return;
       }
@@ -681,7 +759,11 @@ export class ProxySessionController {
         await this.outbound.withReplyTarget(
           message.contextKey,
           replyTarget,
-          () => this.sendError(message.contextKey, error),
+          () => this.sendError(message.contextKey, error, {
+            requestId: message.messageId,
+            messageId: message.messageId,
+            phase: "image_download",
+          }),
         );
         return;
       }
@@ -708,7 +790,11 @@ export class ProxySessionController {
         await this.outbound.withReplyTarget(
           message.contextKey,
           replyTarget,
-          () => this.sendError(message.contextKey, error),
+          () => this.sendError(message.contextKey, error, {
+            requestId: message.messageId,
+            messageId: message.messageId,
+            phase: "file_download",
+          }),
         );
         return;
       }
@@ -724,10 +810,25 @@ export class ProxySessionController {
       await this.outbound.withReplyTarget(
         message.contextKey,
         replyTarget,
-        () => this.sendError(message.contextKey, error),
+        () => this.sendError(message.contextKey, error, {
+          requestId: message.messageId,
+          messageId: message.messageId,
+          phase: "command_parse",
+        }),
       );
       return;
     }
+    if (command.type !== "prompt") {
+      this.logger.info(
+        {
+          requestId: message.messageId,
+          messageId: message.messageId,
+          contextKey: message.contextKey,
+          command: command.type,
+        },
+        "Processing Agent Bot command.",
+      );
+    }
     // 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 () => {
@@ -747,7 +848,12 @@ export class ProxySessionController {
           }
         } catch (error) {
           await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-          await this.sendError(message.contextKey, error);
+          await this.sendError(message.contextKey, error, {
+            requestId: message.messageId,
+            messageId: message.messageId,
+            command: command.type,
+            phase: "command_execute",
+          });
         }
       });
       return;
@@ -757,22 +863,48 @@ export class ProxySessionController {
     const next = previous.catch(() => undefined).then(() =>
       this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
         try {
-          if (command.type === "prompt") await this.ensureThreadFork(message);
+          let executableCommand = command;
+          let executableImagePaths = localImagePaths;
+          let executableMessage = message;
+          let injectedRootMessageId: string | undefined;
+          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;
+            executableMessage = { ...message, displayText: prepared.displayPrompt };
+            injectedRootMessageId = prepared.injectedRootMessageId;
+          }
           await this.execute(
             message.contextKey,
-            command,
+            executableCommand,
             message.messageId,
             replyTarget,
-            localImagePaths,
+            executableImagePaths,
             message.userId,
-            message,
+            executableMessage,
           );
+          if (injectedRootMessageId) {
+            const current = this.currentSession(message.contextKey);
+            if (current) {
+              this.store.audit(message.contextKey, "topic_root_injected", {
+                localSessionId: current.localSessionId,
+                rootMessageId: injectedRootMessageId,
+                promptMessageId: message.messageId,
+              });
+            }
+          }
           if (!commandDefersReactionFinalization(command)) {
             await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
           }
         } catch (error) {
           await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-          await this.sendError(message.contextKey, error);
+          await this.sendError(message.contextKey, error, {
+            requestId: message.messageId,
+            messageId: message.messageId,
+            command: command.type,
+            phase: "command_execute",
+          });
         }
       }),
     );
@@ -794,7 +926,11 @@ export class ProxySessionController {
     try {
       resolvedAction = this.resolveCardActionBinding(action);
     } catch (error) {
-      await this.sendError(action.contextKey, error);
+      await this.sendError(action.contextKey, error, {
+        requestId: action.actionId,
+        actionId: action.actionId,
+        phase: "card_action_resolve",
+      });
       return;
     }
     const contextKey = this.cardActionContextKey(resolvedAction);
@@ -829,6 +965,20 @@ export class ProxySessionController {
             contextKey,
             String(scopedAction.value.jobId ?? ""),
           );
+        } else if (kind === "thread_writer_close") {
+          await this.closeThreadWriter(scopedAction, contextKey);
+        } else if (kind === "thread_writer_fork") {
+          const sessionId = String(scopedAction.value.sessionId ?? "");
+          const threadId = String(scopedAction.value.threadId ?? "");
+          const record = this.requireSession(contextKey, sessionId);
+          if (!threadId || record.remoteSessionId !== threadId) {
+            throw new Error("任务占用卡片已经失效，请重新发送消息获取最新状态。");
+          }
+          await this.forkSessionReference(contextKey, sessionId);
+        } else if (kind === "app_server_release_now") {
+          await this.releaseAppServerNow(scopedAction);
+        } else if (kind === "app_server_release_cancel") {
+          await this.cancelAppServerRelease(scopedAction);
         } else if (kind === "turn_reset") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           const turnId = String(scopedAction.value.turnId ?? "");
@@ -1069,7 +1219,12 @@ export class ProxySessionController {
           await this.resolveApproval(scopedAction);
         }
       } catch (error) {
-        await this.sendError(contextKey, error);
+        await this.sendError(contextKey, error, {
+          requestId: scopedAction.actionId,
+          actionId: scopedAction.actionId,
+          command: String(scopedAction.value.action ?? "unknown"),
+          phase: "card_action_execute",
+        });
       }
     });
   }
@@ -1094,6 +1249,7 @@ export class ProxySessionController {
     this.queuedPromptCardWrites.clear();
     this.sessionResets.clear();
     this.resetHistoryOperations.clear();
+    this.remoteTurnHistoryRefreshes.clear();
     for (const pending of this.pendingMergedForwards.values()) pending.resolveAttachment(undefined);
     this.pendingMergedForwards.clear();
     for (const pending of this.pendingResourceForwards.values()) pending.resolveAttachment(undefined);
@@ -1103,6 +1259,10 @@ export class ProxySessionController {
     this.queuedPromptRetryTimers.clear();
     for (const timer of this.recoveryRetryTimers.values()) clearTimeout(timer);
     this.recoveryRetryTimers.clear();
+    for (const schedule of this.appServerReleaseSchedules.values()) {
+      if (schedule.timer) clearTimeout(schedule.timer);
+    }
+    this.appServerReleaseSchedules.clear();
     for (const [jobId] of this.shellCommandJobMonitors) this.stopShellCommandJobMonitor(jobId);
     clearInterval(this.recoveryActivityHeartbeat);
   }
@@ -1114,6 +1274,23 @@ export class ProxySessionController {
     return `Task stop requested: ${record.title ?? record.remoteSessionId ?? record.localSessionId}`;
   }
 
+  async controlReleaseTask(localSessionId: string): Promise<ControlTaskReleaseResult> {
+    const record = this.requireControlSession(localSessionId);
+    const contextKey = this.controlSessionContextKey(record);
+    const result = await this.outbound.withReplyTarget(
+      contextKey,
+      this.controlSessionReplyTarget(record),
+      () => this.requestAppServerRelease(contextKey, record),
+    );
+    if (result.status === "failed") throw new Error(result.error ?? "Failed to release App Server tasks.");
+    return {
+      agentName: result.agentName,
+      status: result.status,
+      blockingTaskCount: result.blockingTaskCount,
+      ...(result.releaseInSeconds !== undefined ? { releaseInSeconds: result.releaseInSeconds } : {}),
+    };
+  }
+
   async controlArchiveTask(localSessionId: string): Promise<{
     localSessionId: string;
     remoteSessionId: string;
@@ -1852,6 +2029,9 @@ export class ProxySessionController {
         if (!this.lifecycle) throw new Error("当前运行方式不支持自动重启。");
         await this.lifecycle.restart(contextKey, command.force === true, replyTarget);
         return;
+      case "release":
+        await this.requestAppServerRelease(contextKey);
+        return;
       case "mute":
         await this.setGroupMute(contextKey, command.enabled);
         return;
@@ -2401,6 +2581,9 @@ export class ProxySessionController {
     try {
       loaded = await this.loadSession(record);
     } catch (error) {
+      if (await this.presentThreadWriterConflict(record, contextKey, error, true)) {
+        throw new PresentedRequestError(error);
+      }
       await this.outbound.failPendingTurn(record.localSessionId, error instanceof Error ? error.message : String(error));
       throw error;
     }
@@ -2654,6 +2837,61 @@ export class ProxySessionController {
     }
   }
 
+  private async prepareTopicRootPrompt(
+    message: IncomingMessage,
+    text: string,
+    localImagePaths?: string[],
+  ): Promise<PreparedTopicRootPrompt> {
+    const displayPrompt = message.displayText ?? text;
+    const rootMessageId = topicRootMessageId(message);
+    if (!rootMessageId) return { text, localImagePaths, displayPrompt };
+
+    const current = this.currentSession(message.contextKey);
+    if (current && (
+      this.store.hasInjectedTopicRoot(current.localSessionId, rootMessageId)
+      || this.taskHistoryContainsMessage(current, rootMessageId)
+    )) {
+      return { text, localImagePaths, displayPrompt };
+    }
+
+    try {
+      const root = await this.resolveReferencedMessage(message.contextKey, rootMessageId);
+      const rootImagePaths = await Promise.all(root.images.map((image) =>
+        this.outbound.downloadImage(message.contextKey, image.messageId, image.imageKey)));
+      let promptText = topicRootMessagePrompt(text, root.text);
+      if (root.files.length > 0) {
+        const downloadedFiles = await Promise.all(root.files.map(async (file) => ({
+          fileName: file.fileName,
+          filePath: await this.outbound.downloadFile(
+            message.contextKey,
+            file.messageId,
+            file.fileKey,
+            file.fileName,
+          ),
+        })));
+        promptText = appendDownloadedFiles(promptText, downloadedFiles);
+      }
+      const combinedImagePaths = [...new Set([...(localImagePaths ?? []), ...rootImagePaths])];
+      return {
+        text: promptText,
+        ...(combinedImagePaths.length > 0 ? { localImagePaths: combinedImagePaths } : {}),
+        displayPrompt,
+        injectedRootMessageId: rootMessageId,
+      };
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(`无法读取话题根消息：${detail}`);
+    }
+  }
+
+  private taskHistoryContainsMessage(record: SessionRecord, messageId: string): boolean {
+    const anchor = this.store.findTurnAnchorByMessageId(messageId);
+    if (!anchor) return false;
+    if (record.lastTurnId === anchor.turnId) return true;
+    return this.store.listTaskTurnGraph(record.localSessionId)
+      .some((turn) => turn.turnId === anchor.turnId);
+  }
+
   private async forkThreadSession(message: IncomingMessage): Promise<void> {
     const { anchor, source, snapshot } = this.resolveThreadForkAnchor(message);
     const agent = this.ensureAgent(source.agentName);
@@ -3249,6 +3487,39 @@ export class ProxySessionController {
     }
   }
 
+  private async hydrateRemoteTurnHistory(
+    contextKey: string,
+    current: SessionRecord,
+  ): Promise<void> {
+    if (!current.remoteSessionId) return;
+    const refreshedAt = this.remoteTurnHistoryRefreshes.get(current.localSessionId);
+    if (refreshedAt !== undefined && Date.now() - refreshedAt < REMOTE_TURN_HISTORY_REFRESH_INTERVAL_MS) return;
+    const forkSource = this.store.getForkHistorySource(current.localSessionId);
+    if (forkSource?.sourceTurnId === current.lastTurnId
+      && this.store.hasImportedForkTurnHistory(current.localSessionId)) return;
+    const runtime = this.runtimes.forAgent(current.agentName);
+    if (runtime.kind !== "codex" || !runtime.readRemoteSession) return;
+    try {
+      const remote = await runtime.readRemoteSession(current.remoteSessionId);
+      this.remoteTurnHistoryRefreshes.set(current.localSessionId, Date.now());
+      const completedTurns = remote.completedTurns ?? [];
+      if (completedTurns.length === 0) return;
+      this.persistCompletedTurnHistory({
+        localSessionId: current.localSessionId,
+        contextKey,
+        agentName: current.agentName,
+        remoteSessionId: current.remoteSessionId,
+        completedTurns,
+        fallbackStart: parseIsoTimestamp(current.createdAt) ?? Date.now() - completedTurns.length,
+      });
+    } catch (error) {
+      this.logger.warn(
+        { error, localSessionId: current.localSessionId, remoteSessionId: current.remoteSessionId },
+        "Failed to hydrate App Server Turn history; rendering the locally available history.",
+      );
+    }
+  }
+
   private async createProjectSessionFromReference(contextKey: string, reference: string): Promise<void> {
     const resolved = await this.resolveProjectSessionReference(contextKey, reference);
     const created = await this.createSession(
@@ -3809,6 +4080,7 @@ export class ProxySessionController {
             lastTurnStatus: record.lastTurnStatus,
           });
         } catch (error) {
+          if (activeWriterThreadId(error)) throw error;
           if (!(agent.kind === "app-server" && !record.lastTurnId && isMissingRolloutError(error))) throw error;
           this.logger.warn({ error, sessionId: record.localSessionId }, "App Server task has no rollout; creating a replacement task.");
           session = await runtime.createSession({
@@ -5330,6 +5602,7 @@ export class ProxySessionController {
       throw new Error("当前任务不是可 Reset 的 App Server 任务。");
     }
     await this.hydrateLegacyForkTurnHistory(contextKey, current);
+    await this.hydrateRemoteTurnHistory(contextKey, current);
     const completedTurns = this.store.listTaskTurnGraph(current.localSessionId);
     const completedTurnIds = new Set(completedTurns.map((turn) => turn.turnId));
     const runningTurnId = current.lastTurnStatus === "running" && current.lastTurnId
@@ -5664,7 +5937,7 @@ export class ProxySessionController {
     await Promise.all(this.runtimes.entries("codex").map(async ([agentName, runtime]) => {
       if (!runtime.listRemoteSessions) return;
       try {
-        const result = await runtime.listRemoteSessions({ searchTerm, limit: fetchLimit });
+        const result = await this.listRemoteSessionsThroughCursor(runtime, searchTerm, fetchLimit);
         remoteSessions.push(...result.sessions.map((session) => ({ agentName, session })));
         remoteHasMore ||= Boolean(result.nextCursor);
       } catch (error) {
@@ -5876,6 +6149,42 @@ export class ProxySessionController {
     }
   }
 
+  private async listRemoteSessionsThroughCursor(
+    runtime: AgentRuntime,
+    searchTerm: string | undefined,
+    limit: number,
+  ): Promise<RemoteSessionPage> {
+    const sessions: RemoteSessionSummary[] = [];
+    const seenSessionIds = new Set<string>();
+    const seenCursors = new Set<string>();
+    let cursor: string | undefined;
+
+    while (sessions.length < limit) {
+      const page = await runtime.listRemoteSessions!({
+        searchTerm,
+        ...(cursor ? { cursor } : {}),
+        limit: limit - sessions.length,
+      });
+      for (const session of page.sessions) {
+        if (seenSessionIds.has(session.id)) continue;
+        seenSessionIds.add(session.id);
+        sessions.push(session);
+      }
+
+      const nextCursor = page.nextCursor?.trim() || undefined;
+      if (!nextCursor) return { sessions };
+      if (sessions.length >= limit) return { sessions, nextCursor };
+      if (seenCursors.has(nextCursor)) {
+        this.logger.warn({ cursor: nextCursor }, "App Server repeated a thread/list cursor; stopping pagination.");
+        return { sessions };
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
+    }
+
+    return { sessions };
+  }
+
   private async refreshSessionsCardFromAction(
     action: CardAction,
     options: { forceSwitchTaskId?: string; page?: number } = {},
@@ -6509,18 +6818,34 @@ export class ProxySessionController {
         description: command.description,
       })),
     }));
-    await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderHelpCard(
-      "Agent Bot 使用帮助",
-      [
-        "直接发送消息即可继续当前任务；执行中发送的新消息会追加到本次任务。",
-        "点击命令按钮可执行默认形式；有必填参数的命令需要手动发送。",
-        "> 命令前缀示例：/sess 等同于 /sessions。",
-        "> 命令缩写示例：/fg 等同于 /forkgroup。",
-        "前缀或缩写匹配多个命令时，需要输入更长的形式。",
-        "**[参数]** 可选　**&#60;参数&#62;** 必填",
-      ],
-      sections,
-    ));
+    const introLines = [
+      "直接发送消息即可继续当前任务；执行中发送的新消息会追加到本次任务。",
+      "点击命令按钮可执行默认形式；有必填参数的命令需要手动发送。",
+      "> 命令前缀示例：/sess 等同于 /sessions。",
+      "> 命令缩写示例：/fg 等同于 /forkgroup。",
+      "前缀或缩写匹配多个命令时，需要输入更长的形式。",
+      "**[参数]** 可选　**&#60;参数&#62;** 必填",
+    ];
+    try {
+      await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderHelpCard(
+        "Agent Bot 使用帮助",
+        introLines,
+        sections,
+      ));
+    } catch (cardError) {
+      this.logger.warn(
+        { error: cardError, contextKey, command: "help", phase: "help_card_send" },
+        "Failed to send the help card; falling back to plain text.",
+      );
+      try {
+        await this.outbound.sendText(contextKey, renderPlainHelp(introLines, sections));
+      } catch (textError) {
+        throw new AggregateError(
+          [cardError, textError],
+          "帮助卡片和纯文本帮助均发送失败。",
+        );
+      }
+    }
   }
 
   private async setGroupMute(contextKey: string, enabled: boolean): Promise<void> {
@@ -6636,10 +6961,647 @@ export class ProxySessionController {
     return record;
   }
 
-  private async sendError(contextKey: string, error: unknown): Promise<void> {
-    this.logger.warn({ error, contextKey }, "Request failed.");
-    await this.outbound.sendText(contextKey, error instanceof Error ? error.message : String(error));
+  private async requestAppServerRelease(
+    contextKey: string,
+    requestedRecord?: SessionRecord,
+  ): Promise<{
+    agentName: string;
+    status: "waiting" | "released" | "failed";
+    blockingTaskCount: number;
+    releaseInSeconds?: number;
+    error?: string;
+  }> {
+    const record = requestedRecord ?? this.requireCurrentSession(contextKey);
+    const runtime = this.runtimes.forAgent(record.agentName);
+    if (!this.isCodexSession(record) || runtime.kind !== "codex" || !runtime.release) {
+      throw new Error("当前 Agent 不使用可释放的 App Server。");
+    }
+
+    let schedule = this.appServerReleaseSchedules.get(record.agentName);
+    const created = !schedule;
+    if (!schedule) {
+      const blockingTaskCount = this.appServerReleaseBlockers(record.agentName, runtime).length;
+      schedule = {
+        id: this.nextAppServerReleaseScheduleId++,
+        agentName: record.agentName,
+        runtime,
+        status: "waiting",
+        blockingTaskCount,
+        targets: new Map(),
+        forced: false,
+        ...(blockingTaskCount === 0
+          ? {
+              releaseCountdownSeconds: Math.ceil(APP_SERVER_RELEASE_IDLE_DELAY_MS / 1_000),
+            }
+          : {}),
+      };
+      this.appServerReleaseSchedules.set(record.agentName, schedule);
+    }
+
+    try {
+      const messageId = await this.outbound.sendInteractiveCard(
+        contextKey,
+        this.cardRenderer.renderAppServerRelease(this.appServerReleaseCardView(schedule, contextKey)),
+      );
+      if (messageId) {
+        schedule.targets.set(`${contextKey}\u0000${messageId}`, { contextKey, messageId });
+      }
+      if (
+        schedule.status === "waiting"
+        && schedule.blockingTaskCount === 0
+        && schedule.releaseCountdownSeconds !== undefined
+        && schedule.releaseAt === undefined
+      ) {
+        schedule.releaseAt = Date.now() + APP_SERVER_RELEASE_IDLE_DELAY_MS;
+      }
+    } catch (error) {
+      if (created && schedule.targets.size === 0) {
+        this.clearAppServerReleaseSchedule(schedule);
+      }
+      throw error;
+    }
+
+    this.armAppServerReleaseCheck(schedule);
+    return {
+      agentName: schedule.agentName,
+      status: schedule.status === "failed" ? "failed" : schedule.status === "released" ? "released" : "waiting",
+      blockingTaskCount: schedule.blockingTaskCount,
+      ...(schedule.releaseCountdownSeconds !== undefined
+        ? { releaseInSeconds: schedule.releaseCountdownSeconds }
+        : {}),
+      ...(schedule.error ? { error: schedule.error } : {}),
+    };
+  }
+
+  private async releaseAppServerNow(action: CardAction): Promise<void> {
+    const scheduleId = Number(action.value.scheduleId);
+    const agentName = typeof action.value.agentName === "string" ? action.value.agentName : "";
+    const schedule = this.appServerReleaseSchedules.get(agentName);
+    if (!Number.isSafeInteger(scheduleId) || !schedule || schedule.id !== scheduleId || schedule.status !== "waiting") {
+      throw new Error("释放卡片已失效，请重新发送 /release。");
+    }
+    await this.performAppServerRelease(schedule, true);
+  }
+
+  private async cancelAppServerRelease(action: CardAction): Promise<void> {
+    const scheduleId = Number(action.value.scheduleId);
+    const agentName = typeof action.value.agentName === "string" ? action.value.agentName : "";
+    const schedule = this.appServerReleaseSchedules.get(agentName);
+    const cancellable = schedule?.status === "waiting"
+      || (schedule?.status === "releasing" && schedule.releaseStarted !== true);
+    if (!Number.isSafeInteger(scheduleId) || !schedule || schedule.id !== scheduleId || !cancellable) {
+      throw new Error("释放卡片已失效，请重新发送 /release。");
+    }
+    const pendingRelease = schedule.inFlight;
+    schedule.status = "cancelled";
+    if (schedule.timer) {
+      clearTimeout(schedule.timer);
+      schedule.timer = undefined;
+    }
+    if (pendingRelease) await pendingRelease;
+    await this.publishAppServerReleaseSchedule(schedule);
+    this.clearAppServerReleaseSchedule(schedule);
+  }
+
+  private appServerReleaseBlockers(agentName: string, runtime: AgentRuntime): SessionRecord[] {
+    return this.store.listAllSessions().filter((session) => {
+      if (session.agentName !== agentName || session.status === "closed") return false;
+      return session.status === "starting"
+        || session.status === "running"
+        || this.store.countQueuedPrompts(session.localSessionId) > 0
+        || this.queuedPromptStarts.has(session.localSessionId)
+        || this.sessionLoads.has(session.localSessionId)
+        || Boolean(runtime.getSession(session.localSessionId)?.activeTurnId);
+    });
+  }
+
+  private armAppServerReleaseCheck(schedule: AppServerReleaseSchedule): void {
+    if (schedule.status !== "waiting" || schedule.timer || schedule.inFlight) return;
+    schedule.timer = setTimeout(() => {
+      schedule.timer = undefined;
+      void this.refreshAppServerReleaseSchedule(schedule).catch((error: unknown) => {
+        this.logger.warn({ error, agentName: schedule.agentName }, "Failed to refresh App Server release status.");
+        this.armAppServerReleaseCheck(schedule);
+      });
+    }, APP_SERVER_RELEASE_POLL_INTERVAL_MS);
+    schedule.timer.unref?.();
+  }
+
+  private async refreshAppServerReleaseSchedule(schedule: AppServerReleaseSchedule): Promise<void> {
+    if (this.appServerReleaseSchedules.get(schedule.agentName) !== schedule || schedule.status !== "waiting") return;
+    const blockingTaskCount = this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length;
+    if (blockingTaskCount > 0) {
+      const changed = schedule.blockingTaskCount !== blockingTaskCount || schedule.releaseAt !== undefined;
+      schedule.releaseAt = undefined;
+      schedule.releaseCountdownSeconds = undefined;
+      if (changed) {
+        schedule.blockingTaskCount = blockingTaskCount;
+        await this.publishAppServerReleaseSchedule(schedule);
+      }
+      this.armAppServerReleaseCheck(schedule);
+      return;
+    }
+    schedule.blockingTaskCount = 0;
+    if (schedule.releaseAt !== undefined) {
+      const releaseCountdownSeconds = Math.max(0, Math.ceil((schedule.releaseAt - Date.now()) / 1_000));
+      if (releaseCountdownSeconds > 0) {
+        if (schedule.releaseCountdownSeconds !== releaseCountdownSeconds) {
+          schedule.releaseCountdownSeconds = releaseCountdownSeconds;
+          await this.publishAppServerReleaseSchedule(schedule);
+        }
+        this.armAppServerReleaseCheck(schedule);
+        return;
+      }
+    }
+    await this.performAppServerRelease(schedule, false);
+  }
+
+  private async performAppServerRelease(schedule: AppServerReleaseSchedule, force: boolean): Promise<void> {
+    if (schedule.inFlight) return schedule.inFlight;
+    const operation = this.performAppServerReleaseNow(schedule, force);
+    schedule.inFlight = operation;
+    try {
+      await operation;
+    } finally {
+      if (schedule.inFlight === operation) schedule.inFlight = undefined;
+      if (schedule.status === "waiting") this.armAppServerReleaseCheck(schedule);
+    }
+  }
+
+  private async performAppServerReleaseNow(schedule: AppServerReleaseSchedule, force: boolean): Promise<void> {
+    if (schedule.timer) {
+      clearTimeout(schedule.timer);
+      schedule.timer = undefined;
+    }
+    const interruptedWork = force && this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length > 0;
+    if (force) await this.cancelQueuedPromptsForAppServerRelease(schedule.agentName);
+    else {
+      const blockingTaskCount = this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length;
+      if (blockingTaskCount > 0) {
+        schedule.status = "waiting";
+        schedule.blockingTaskCount = blockingTaskCount;
+        schedule.releaseAt = undefined;
+        schedule.releaseCountdownSeconds = undefined;
+        schedule.releaseStarted = false;
+        await this.publishAppServerReleaseSchedule(schedule);
+        this.armAppServerReleaseCheck(schedule);
+        return;
+      }
+    }
+
+    schedule.status = "releasing";
+    schedule.blockingTaskCount = 0;
+    schedule.releaseAt = undefined;
+    schedule.releaseCountdownSeconds = undefined;
+    schedule.releaseStarted = false;
+    schedule.forced = interruptedWork;
+    await this.publishAppServerReleaseSchedule(schedule);
+    if (
+      this.appServerReleaseWasCancelled(schedule)
+      || this.appServerReleaseSchedules.get(schedule.agentName) !== schedule
+    ) return;
+    schedule.releaseStarted = true;
+    try {
+      const result = await schedule.runtime.release?.({ force });
+      if (!result) throw new Error("当前 Agent 不支持释放 App Server。");
+      if (result.status === "busy") {
+        schedule.status = "waiting";
+        schedule.blockingTaskCount = Math.max(
+          result.activeSessionIds?.length ?? 0,
+          this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length,
+          1,
+        );
+        schedule.forced = false;
+        schedule.releaseAt = undefined;
+        schedule.releaseCountdownSeconds = undefined;
+        schedule.releaseStarted = false;
+        await this.publishAppServerReleaseSchedule(schedule);
+        this.armAppServerReleaseCheck(schedule);
+        return;
+      }
+      schedule.status = "released";
+    } catch (error) {
+      schedule.status = "failed";
+      schedule.error = error instanceof Error ? error.message : String(error);
+      this.logger.warn({ error, agentName: schedule.agentName }, "Failed to release App Server tasks.");
+    }
+    await this.publishAppServerReleaseSchedule(schedule);
+    this.clearAppServerReleaseSchedule(schedule);
+  }
+
+  private appServerReleaseWasCancelled(schedule: AppServerReleaseSchedule): boolean {
+    return schedule.status === "cancelled";
+  }
+
+  private async cancelQueuedPromptsForAppServerRelease(agentName: string): Promise<void> {
+    for (const session of this.store.listAllSessions()) {
+      if (session.agentName !== agentName) continue;
+      const retryTimer = this.queuedPromptRetryTimers.get(session.localSessionId);
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        this.queuedPromptRetryTimers.delete(session.localSessionId);
+      }
+      const queued = this.store.listQueuedPrompts(session.localSessionId);
+      for (const prompt of queued) {
+        const cancelled = this.store.cancelQueuedPrompt(prompt.promptId, session.localSessionId);
+        if (!cancelled?.messageId) continue;
+        await this.finalizeStandaloneMessageReaction(cancelled.messageId, "cancelled").catch((error: unknown) => {
+          this.logger.warn(
+            { error, agentName, sessionId: session.localSessionId, promptId: cancelled.promptId },
+            "Failed to finalize a queued Prompt reaction during App Server release.",
+          );
+        });
+      }
+      if (queued.length > 0) {
+        await this.refreshPromptQueueCards(session.localSessionId).catch((error: unknown) => {
+          this.logger.warn(
+            { error, agentName, sessionId: session.localSessionId },
+            "Failed to refresh queued Prompt cards during App Server release.",
+          );
+        });
+      }
+    }
+  }
+
+  private appServerReleaseCardView(
+    schedule: AppServerReleaseSchedule,
+    contextKey: string,
+  ): AppServerReleaseCardView {
+    return {
+      status: schedule.status,
+      contextKey,
+      scheduleId: schedule.id,
+      agentName: schedule.agentName,
+      ...(schedule.blockingTaskCount > 0 ? { blockingTaskCount: schedule.blockingTaskCount } : {}),
+      ...(schedule.releaseCountdownSeconds !== undefined
+        ? { releaseInSeconds: schedule.releaseCountdownSeconds }
+        : {}),
+      ...(schedule.forced ? { forced: true } : {}),
+      ...(schedule.error ? { error: schedule.error } : {}),
+    };
   }
+
+  private async publishAppServerReleaseSchedule(schedule: AppServerReleaseSchedule): Promise<void> {
+    await Promise.all([...schedule.targets.values()].map(async (target) => {
+      try {
+        await this.outbound.updateInteractiveCard(
+          target.contextKey,
+          target.messageId,
+          this.cardRenderer.renderAppServerRelease(this.appServerReleaseCardView(schedule, target.contextKey)),
+        );
+      } catch (error) {
+        this.logger.warn(
+          { error, agentName: schedule.agentName, messageId: target.messageId },
+          "Failed to update App Server release card.",
+        );
+      }
+    }));
+  }
+
+  private clearAppServerReleaseSchedule(schedule: AppServerReleaseSchedule): void {
+    if (schedule.timer) clearTimeout(schedule.timer);
+    schedule.timer = undefined;
+    if (this.appServerReleaseSchedules.get(schedule.agentName) === schedule) {
+      this.appServerReleaseSchedules.delete(schedule.agentName);
+    }
+  }
+
+  private async presentThreadWriterConflict(
+    record: SessionRecord,
+    contextKey: string,
+    error: unknown,
+    replacePendingTurn: boolean,
+  ): Promise<boolean> {
+    if (contextKey.startsWith("console:")) return false;
+    const threadId = activeWriterThreadId(error);
+    if (!threadId || record.remoteSessionId !== threadId) return false;
+    const runtime = this.runtimes.forAgent(record.agentName);
+    const lockPath = runtime.getThreadWriterLockPath?.(threadId);
+    let owners: ThreadWriterProcess[] = [];
+    if (lockPath) {
+      try {
+        owners = await this.threadWriterProcesses.inspect(lockPath);
+      } catch (inspectionError) {
+        this.logger.warn(
+          { error: inspectionError, threadId, lockPath },
+          "Failed to inspect the process holding a thread writer lock.",
+        );
+      }
+    }
+    const owner = owners.length === 1 ? owners[0] : undefined;
+    const applicationIdle = owner && lockPath
+      ? await this.inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, owner)
+      : undefined;
+    const card = this.cardRenderer.renderThreadWriterConflict(this.threadWriterConflictView(
+      record,
+      contextKey,
+      threadId,
+      owners,
+      "occupied",
+      lockPath
+        ? undefined
+        : "无法识别占用进程。",
+      applicationIdle,
+    ));
+    if (replacePendingTurn) {
+      const replaced = await this.outbound.failPendingTurn(
+        record.localSessionId,
+        "任务被占用。",
+        card,
+      );
+      if (!replaced) await this.outbound.sendInteractiveCard(contextKey, card);
+    } else {
+      await this.outbound.sendInteractiveCard(contextKey, card);
+    }
+    return true;
+  }
+
+  private threadWriterConflictView(
+    record: SessionRecord,
+    contextKey: string,
+    threadId: string,
+    owners: ThreadWriterProcess[],
+    status: ThreadWriterConflictCardView["status"],
+    notice?: string,
+    applicationIdle?: boolean,
+  ): ThreadWriterConflictCardView {
+    const owner = owners.length === 1 ? owners[0] : undefined;
+    return {
+      status,
+      contextKey,
+      sessionId: record.localSessionId,
+      threadId,
+      taskTitle: record.title,
+      notice: notice ?? (owners.length > 1
+        ? `检测到 ${owners.length} 个相关进程，无法安全地自动关闭。`
+        : undefined),
+      applicationIdle,
+      ...(owner ? {
+        owner: {
+          displayName: owner.displayName,
+          writerPid: owner.writerPid,
+          writerProcessName: owner.writerProcessName,
+          writerStartedAt: owner.writerStartedAt,
+          applicationPid: owner.applicationPid,
+          applicationProcessName: owner.applicationProcessName,
+          applicationStartedAt: owner.applicationStartedAt,
+          canClose: owner.canClose,
+        },
+      } : {}),
+    };
+  }
+
+  private async closeThreadWriter(action: CardAction, contextKey: string): Promise<void> {
+    const messageId = requiredCardMessageId(action.messageId);
+    const sessionId = String(action.value.sessionId ?? "");
+    const threadId = String(action.value.threadId ?? "");
+    const expectedWriterPid = positiveActionPid(action.value.writerPid);
+    const expectedApplicationPid = positiveActionPid(action.value.applicationPid);
+    const expectedWriterStartedAt = String(action.value.writerStartedAt ?? "");
+    const expectedApplicationStartedAt = String(action.value.applicationStartedAt ?? "");
+    const force = action.value.force === true || action.value.force === "true";
+    const record = this.requireSession(contextKey, sessionId);
+    if (!threadId || record.remoteSessionId !== threadId) {
+      throw new Error("任务占用卡片已经失效，请重新发送消息获取最新状态。");
+    }
+    const runtime = this.runtimes.forAgent(record.agentName);
+    const lockPath = runtime.getThreadWriterLockPath?.(threadId);
+    if (!lockPath) throw new Error("当前 Agent 不支持自动关闭占用程序。");
+
+    let owners = await this.threadWriterProcesses.inspect(lockPath);
+    const expectedOwner = owners.length === 1 && threadWriterMatches(
+      owners[0],
+      expectedWriterPid,
+      expectedWriterStartedAt,
+      expectedApplicationPid,
+      expectedApplicationStartedAt,
+    ) ? owners[0] : undefined;
+    if (!expectedOwner) {
+      const currentOwner = owners.length === 1 ? owners[0] : undefined;
+      const applicationIdle = currentOwner
+        ? await this.inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, currentOwner)
+        : undefined;
+      await this.outbound.updateInteractiveCard(
+        contextKey,
+        messageId,
+        this.cardRenderer.renderThreadWriterConflict(this.threadWriterConflictView(
+          record,
+          contextKey,
+          threadId,
+          owners,
+          owners.length === 0 ? "released" : "occupied",
+          owners.length === 0
+            ? "请重新发送消息。"
+            : "占用进程已变化，请重试。",
+          applicationIdle,
+        )),
+      );
+      return;
+    }
+    if (!expectedOwner.canClose) throw new Error("无法确认占用者是 Agent 程序，已拒绝关闭。");
+
+    try {
+      await this.threadWriterProcesses.close(expectedOwner, force);
+    } catch (error) {
+      owners = await this.threadWriterProcesses.inspect(lockPath);
+      if (owners.some((owner) => threadWriterMatches(
+        owner,
+        expectedWriterPid,
+        expectedWriterStartedAt,
+        expectedApplicationPid,
+        expectedApplicationStartedAt,
+      ))) throw error;
+    }
+    owners = await this.waitForThreadWriterChange(lockPath, expectedOwner);
+    const sameOwnerRemains = owners.some((owner) => threadWriterMatches(
+      owner,
+      expectedOwner.writerPid,
+      expectedOwner.writerStartedAt ?? "",
+      expectedOwner.applicationPid,
+      expectedOwner.applicationStartedAt ?? "",
+    ));
+    if (sameOwnerRemains && force) {
+      throw new Error(`无法关闭 ${expectedOwner.displayName}（PID ${expectedOwner.applicationPid}）。`);
+    }
+    const status: ThreadWriterConflictCardView["status"] = owners.length === 0
+      ? "released"
+      : sameOwnerRemains ? "force_required" : "occupied";
+    const notice = owners.length === 0
+      ? "请重新发送消息。"
+      : sameOwnerRemains
+        ? "普通关闭失败，可强制关闭。"
+        : "占用进程已变化，请重试。";
+    const currentOwner = owners.length === 1 ? owners[0] : undefined;
+    const applicationIdle = currentOwner
+      ? await this.inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, currentOwner)
+      : undefined;
+    await this.outbound.updateInteractiveCard(
+      contextKey,
+      messageId,
+      this.cardRenderer.renderThreadWriterConflict(this.threadWriterConflictView(
+        record,
+        contextKey,
+        threadId,
+        owners,
+        status,
+        notice,
+        applicationIdle,
+      )),
+    );
+  }
+
+  private async inspectThreadWriterApplicationIdle(
+    runtime: AgentRuntime,
+    lockPath: string,
+    threadId: string,
+    owner: ThreadWriterProcess,
+  ): Promise<boolean | undefined> {
+    if (!owner.applicationStartedAt
+      || !this.threadWriterProcesses.inspectApplicationThreadIds
+      || !runtime.inspectRemoteSessionActivity) return undefined;
+    try {
+      const ownedThreadIds = await this.threadWriterProcesses.inspectApplicationThreadIds(lockPath, owner);
+      if (!ownedThreadIds.includes(threadId)) return undefined;
+      const activities = await Promise.all(
+        ownedThreadIds.map((ownedThreadId) => runtime.inspectRemoteSessionActivity!(ownedThreadId)),
+      );
+      return activities.every((activity) => !activity.active);
+    } catch (error) {
+      this.logger.warn(
+        { error, threadId, applicationPid: owner.applicationPid },
+        "Failed to inspect thread-writer application activity.",
+      );
+      return undefined;
+    }
+  }
+
+  private async waitForThreadWriterChange(
+    lockPath: string,
+    expectedOwner: ThreadWriterProcess,
+  ): Promise<ThreadWriterProcess[]> {
+    const deadline = Date.now() + 5_000;
+    let owners: ThreadWriterProcess[] = [];
+    do {
+      owners = await this.threadWriterProcesses.inspect(lockPath);
+      if (!owners.some((owner) => threadWriterMatches(
+        owner,
+        expectedOwner.writerPid,
+        expectedOwner.writerStartedAt ?? "",
+        expectedOwner.applicationPid,
+        expectedOwner.applicationStartedAt ?? "",
+      ))) return owners;
+      await delay(250);
+    } while (Date.now() < deadline);
+    return owners;
+  }
+
+  private async sendError(
+    contextKey: string,
+    error: unknown,
+    details: RequestFailureDetails = {},
+  ): Promise<void> {
+    if (error instanceof PresentedRequestError) {
+      this.logger.warn(
+        { error: errorLogValue(error.originalError), contextKey, ...details },
+        "Request failed after a dedicated error card was presented.",
+      );
+      return;
+    }
+    const record = this.currentSession(contextKey);
+    if (record) {
+      try {
+        if (await this.presentThreadWriterConflict(record, contextKey, error, false)) return;
+      } catch (presentationError) {
+        this.logger.warn(
+          { error: presentationError, originalError: errorLogValue(error), contextKey, ...details },
+          "Failed to present the thread writer conflict card.",
+        );
+      }
+    }
+    this.logger.warn({ error, contextKey, ...details }, "Request failed.");
+    try {
+      await this.outbound.sendText(contextKey, error instanceof Error ? error.message : String(error));
+    } catch (deliveryError) {
+      this.logger.error(
+        {
+          error: deliveryError,
+          originalError: errorLogValue(error),
+          contextKey,
+          ...details,
+          phase: "error_response_send",
+        },
+        "Failed to deliver the request failure to the user.",
+      );
+    }
+  }
+}
+
+function activeWriterThreadId(error: unknown): string | undefined {
+  const visited = new Set<unknown>();
+  let current = error;
+  while (current !== undefined && current !== null && !visited.has(current)) {
+    visited.add(current);
+    const message = current instanceof Error
+      ? current.message
+      : typeof current === "string" ? current : undefined;
+    const match = message?.match(
+      /thread(?:\/resume failed:\s*thread)?\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\s+already has an active writer/iu,
+    );
+    if (match?.[1]) return match[1];
+    current = current instanceof Error ? current.cause : undefined;
+  }
+  return undefined;
+}
+
+function positiveActionPid(value: unknown): number {
+  const pid = typeof value === "number" ? value : Number(value);
+  if (!Number.isSafeInteger(pid) || pid <= 4) {
+    throw new Error("任务占用卡片中的进程信息无效，请重新发送消息获取最新状态。");
+  }
+  return pid;
+}
+
+function threadWriterMatches(
+  owner: ThreadWriterProcess,
+  writerPid: number,
+  writerStartedAt: string,
+  applicationPid: number,
+  applicationStartedAt: string,
+): boolean {
+  return Boolean(writerStartedAt)
+    && Boolean(applicationStartedAt)
+    && owner.writerPid === writerPid
+    && owner.writerStartedAt === writerStartedAt
+    && owner.applicationPid === applicationPid
+    && owner.applicationStartedAt === applicationStartedAt;
+}
+
+function delay(milliseconds: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+function renderPlainHelp(introLines: string[], sections: HelpCardSection[]): string {
+  return [
+    "Agent Bot 使用帮助",
+    "",
+    ...introLines.map((line) => decodeHelpEntities(line.replace(/^>\s*/u, "").replaceAll("**", ""))),
+    ...sections.flatMap((section) => [
+      "",
+      section.title,
+      ...section.commands.map((command) => [
+        command.text,
+        command.usage ? decodeHelpEntities(command.usage) : "",
+        `- ${command.description}`,
+      ].filter(Boolean).join(" ")),
+    ]),
+  ].join("\n");
+}
+
+function decodeHelpEntities(value: string): string {
+  return value
+    .replaceAll("&#60;", "<")
+    .replaceAll("&#62;", ">")
+    .replaceAll("&amp;", "&");
 }
 
 function threadForkAnchorMessageIds(message: IncomingMessage): string[] {
@@ -7194,7 +8156,7 @@ function isBotOwnedActiveTurn(record: SessionRecord, remote: RemoteSessionSummar
 }
 
 function isQueueIndependentCommand(command: Command): boolean {
-  if (["archive", "dismiss", "stop", "status", "restart", "mute", "help", "sessions", "dir", "file", "goal", "nosteer", "shell"].includes(command.type)) return true;
+  if (["archive", "dismiss", "stop", "status", "restart", "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;
@@ -7423,6 +8385,17 @@ function referencedMessagePrompt(instruction: string, referencedMessage: string)
   return `${instruction}\n\n引用消息：\n${referencedMessage}`;
 }
 
+function topicRootMessagePrompt(instruction: string, rootMessage: string): string {
+  return `${instruction}\n\n话题根消息：\n${rootMessage}`;
+}
+
+function topicRootMessageId(message: IncomingMessage): string | undefined {
+  if (!message.threadContext) return undefined;
+  const rootMessageId = message.rootMessageId?.trim();
+  if (!rootMessageId || rootMessageId === message.messageId) return undefined;
+  return rootMessageId;
+}
+
 function quotedMessageId(message: IncomingMessage): string | undefined {
   const messageId = message.parentMessageId?.trim();
   if (!messageId || message.contextKey.startsWith("console:")) return undefined;