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

package/src/proxy/ProxySessionController.ts

@@ -26,6 +26,7 @@ import type {
   ReferencedMessageContent,
 } from "../feishu/types.js";
 import {
+  type AppServerReleaseCardView,
   CardRenderer,
   type CardSection,
   type DirectoryBrowserCardEntry,
@@ -59,6 +60,7 @@ import type {
   PermissionMode,
   RemoteCompletedTurnSummary,
   RemoteSessionActivity,
+  RemoteSessionPage,
   RemoteSessionSummary,
   RuntimeGoal,
   RuntimeEvent,
@@ -117,12 +119,40 @@ 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;
@@ -146,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 = "请参考引用消息回复用户";
@@ -285,6 +318,10 @@ const HELP_COMMAND_SECTIONS: Array<{
         usage: "[--force]",
         description: "默认安全重启；--force 立即重启",
       },
+      {
+        command: "/release",
+        description: "释放 Agent Bot 占用的 App Server 任务",
+      },
       {
         command: "/mute",
         usage: "[on|off]",
@@ -413,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>;
@@ -447,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>();
@@ -457,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>;
@@ -816,16 +863,37 @@ 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");
           }
@@ -907,6 +975,10 @@ export class ProxySessionController {
             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 ?? "");
@@ -1177,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);
@@ -1186,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);
   }
@@ -1197,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;
@@ -1935,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;
@@ -2740,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);
@@ -3335,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(
@@ -5417,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
@@ -5751,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) {
@@ -5963,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 } = {},
@@ -6739,6 +6961,311 @@ export class ProxySessionController {
     return record;
   }
 
+  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,
@@ -7629,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;
@@ -7858,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;