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

package/docs/technical-reference.md

@@ -261,7 +261,7 @@ Starting a Feishu thread from a mapped user message, progress card, or final res
 
 `/forkgroup` has thread-aware source selection. An unbound thread, or a bound thread task with no completed turn of its own, forks directly from the thread's original anchor turn without creating an intermediate thread task. Once the thread task has completed a turn, `/forkgroup` uses its latest locally persisted completed turn. A newer active turn does not block the command and is excluded from the fork point.
 
-Agent Bot sends the experimental `excludeTurns: true` field on every `thread/fork` request. This suppresses populated `thread.turns` in the response without changing the history copied into the fork. The App Server connection enables `experimentalApi`; no user-facing command option is required. If an older App Server explicitly rejects `excludeTurns` as unknown, unsupported, or unavailable without experimental support, Agent Bot retries once without that field. Timeouts, disconnects, and unrelated fork errors are never retried because the first request may already have created a branch.
+Before forking a task that has never been bound to Agent Bot, Agent Bot reads metadata without Turns and pages backward through the lightweight `summary` Turn view only until it finds the latest completed Turn. It does not load the task's complete tool history as a Fork prerequisite. Agent Bot then sends the experimental `excludeTurns: true` field on every `thread/fork` request. This suppresses populated `thread.turns` in the response without changing the history copied into the fork. The App Server connection enables `experimentalApi`; no user-facing command option is required. If an older App Server explicitly rejects the lightweight Turn-list method or the `excludeTurns` field, Agent Bot falls back to the compatible complete-history read or Fork request. Timeouts, disconnects, and unrelated Fork errors are never retried because a timed-out Fork request may already have created a branch.
 
 The new group's welcome message reports the persisted fork settings: Provider, model, reasoning effort, and permission type. Permission type is rendered as automatic execution or confirmation before execution.
 

package/docs/technical-reference.zh.md

@@ -261,7 +261,7 @@ AGENT_BOT_LARK_USER_OPEN_ID=<已保存的授权用户 open_id，可用时提供>
 
 `/forkgroup` 会根据话题状态选择来源。话题尚未绑定任务，或者已绑定任务但尚未完成过自己的 turn 时，直接从话题原始锚点 turn fork，不创建中间话题任务。话题任务完成过 turn 后，使用本地持久化的最近完成 turn；更晚的执行中 turn 不会阻塞命令，也不会成为 fork 点。
 
-Agent Bot 会在每个 `thread/fork` 请求中默认发送实验性的 `excludeTurns: true`。它只阻止响应填充 `thread.turns`，不会改变复制到分支中的历史。App Server 连接已启用 `experimentalApi`，不需要用户提供命令参数。如果旧版 App Server 明确提示 `excludeTurns` 字段未知、不支持或需要实验能力，Agent Bot 会移除该字段并重试一次。超时、断连和无关的 Fork 错误绝不重试，因为第一次请求可能已经创建分支。
+Fork 从未绑定过 Agent Bot 的任务前，Agent Bot 会先读取不含 Turns 的元数据，再通过轻量的 `summary` Turn 视图从新到旧分页，只读到最近一个已完成 Turn，不再把完整工具历史作为 Fork 前置条件。随后每个 `thread/fork` 请求仍默认发送实验性的 `excludeTurns: true`；它只阻止响应填充 `thread.turns`，不会改变复制到分支中的历史。App Server 连接已启用 `experimentalApi`，不需要用户提供命令参数。如果旧版 App Server 明确不支持轻量 Turn 列表或 `excludeTurns` 字段，Agent Bot 会分别回退到兼容的完整历史读取或 Fork 请求。超时、断连和无关的 Fork 错误绝不重试，因为超时的 Fork 请求可能已经创建分支。
 
 新群欢迎消息会显示分支任务持久化后的 Provider、模型、思考强度和权限类型；权限类型显示为自动执行或执行前确认。
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.19-alpha.1",
+  "version": "0.1.20-alpha.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@keyou007/agent-bot",
-      "version": "0.1.19-alpha.1",
+      "version": "0.1.20-alpha.0",
       "license": "GPL-3.0-only",
       "dependencies": {
         "@agentclientprotocol/sdk": "1.2.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.19-alpha.1",
+  "version": "0.1.20-alpha.0",
   "type": "module",
   "description": "Use Codex, TraeX, and compatible coding agents from Lark/Feishu.",
   "license": "GPL-3.0-only",

package/skills/agent-bot/SKILL.md

@@ -74,9 +74,10 @@ agentbot task title "<title>"
 - `prompt` posts the Prompt to the task's Feishu conversation before submitting it.
 - `queue` creates a later turn instead of steering the active turn. `nosteer` is an alias.
 - `stop` requests an Agent interrupt; it does not kill the Agent process.
+- `release` sends a Lark confirmation card for releasing the Agent's shared App Server. It never releases automatically; the user must click **Release** or **Release Now** on the card.
 - `dismiss --yes` irreversibly dissolves the task's current Feishu group and archives its current task. Use it only after the user explicitly confirms.
 
-From Feishu, `/release` hands App Server tasks back to Codex Desktop without archiving them. When idle, it sends a release card and counts down for five seconds; otherwise it waits for the current Agent's running and queued work. **Release Now** interrupts active work and clears queued Prompts, while **Cancel** cancels the pending release. Because each App Server Agent is shared, releasing affects every task loaded by that Agent process.
+From Feishu, `/release` sends a confirmation card for handing App Server tasks back to Codex Desktop without archiving them. It lists the current Agent's running and queued work and never releases automatically. **Release** confirms an idle release, **Release Now** interrupts active work and clears queued Prompts, and **Cancel** cancels the pending release. Because each App Server Agent is shared, releasing affects every task loaded by that Agent process.
 
 Create or branch work in the same conversation:
 

package/src/cli/controlProtocol.ts

@@ -113,7 +113,6 @@ export interface TaskReleaseControlData {
   agentName: string;
   status: "waiting" | "released";
   blockingTaskCount: number;
-  releaseInSeconds?: number;
 }
 
 export interface TaskForkControlData {

package/src/cli/help.ts

@@ -45,7 +45,7 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   task shell [任务] <命令>          在任务目录执行本地命令
   task stop [任务]                  停止任务
   task archive [任务]               归档任务
-  task release [任务]               释放任务所属 Agent 的共享 App Server
+  task release [任务]               发送共享 App Server 释放确认卡片
   task dismiss [任务] --yes         归档任务并解散其当前群聊
   task title [任务] <标题>          重命名任务
   task restart [任务] [--force]     从任务会话请求安全或立即重启
@@ -138,7 +138,7 @@ Task commands:
   task shell [task] <command>       Run a local command in the task directory
   task stop [task]                  Stop a task
   task archive [task]               Archive a task
-  task release [task]               Release the task Agent's shared App Server
+  task release [task]               Send a confirmation card to release the shared App Server
   task dismiss [task] --yes         Archive a task and dissolve its current group
   task title [task] <title>         Rename a task
   task restart [task] [--force]     Request a safe or immediate restart from a task

package/src/cli.ts

@@ -1337,15 +1337,14 @@ async function taskCommand(input: string[]): Promise<void> {
           `App Server tasks released for ${released.agentName}.\n`,
           `已释放 ${released.agentName} 的 App Server 任务。\n`,
         ));
-      } else if (released.releaseInSeconds !== undefined) {
-        process.stdout.write(cliText(
-          `App Server release scheduled for ${released.agentName} in ${released.releaseInSeconds} seconds.\n`,
-          `已安排在 ${released.releaseInSeconds} 秒后释放 ${released.agentName} 的 App Server。\n`,
-        ));
       } else {
         process.stdout.write(cliText(
-          `App Server release scheduled for ${released.agentName} (${released.blockingTaskCount} waiting).\n`,
-          `已安排释放 ${released.agentName} 的 App Server（等待 ${released.blockingTaskCount} 个任务）。\n`,
+          released.blockingTaskCount > 0
+            ? `App Server release card sent for ${released.agentName} (${released.blockingTaskCount} blocking). Confirm in Lark to release.\n`
+            : `App Server release card sent for ${released.agentName}. Confirm in Lark to release.\n`,
+          released.blockingTaskCount > 0
+            ? `已发送 ${released.agentName} 的 App Server 释放卡片（${released.blockingTaskCount} 个任务阻塞）。请在飞书中确认释放。\n`
+            : `已发送 ${released.agentName} 的 App Server 释放卡片。请在飞书中确认释放。\n`,
         ));
       }
       return;

package/src/codex/CodexRuntime.ts

@@ -42,6 +42,8 @@ const SESSION_REQUEST_TIMEOUT_MS = 60_000;
 const CONTROL_REQUEST_TIMEOUT_MS = 10_000;
 const SYNC_REQUEST_TIMEOUT_MS = 5_000;
 const THREAD_TURN_PAGE_SIZE = 100;
+const FORK_SOURCE_TURN_PAGE_SIZE = 20;
+const FORK_SOURCE_REQUEST_TIMEOUT_MS = 15_000;
 const USER_RESUMABLE_THREAD_SOURCE_KINDS = ["cli", "vscode", "exec", "appServer"] as const;
 // A timed-out fork keeps running in App Server and can create an orphan thread.
 // Wait for its response; connection closure still rejects the request.
@@ -305,7 +307,37 @@ export class CodexRuntime implements AgentRuntime {
   async readRemoteSession(remoteSessionId: string): Promise<RemoteSessionSummary> {
     const client = await this.client();
     const response = await this.readThreadWithTurns(client, remoteSessionId);
-    const summary = remoteSessionSummary(response.thread);
+    return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary(response.thread));
+  }
+
+  async readRemoteForkSource(remoteSessionId: string): Promise<RemoteSessionSummary> {
+    const client = await this.client();
+    const metadata = await client.request<ThreadReadResponse>(
+      "thread/read",
+      { threadId: remoteSessionId, includeTurns: false },
+      FORK_SOURCE_REQUEST_TIMEOUT_MS,
+    );
+    let turns: CodexTurnSnapshot[];
+    try {
+      turns = await this.listRecentThreadTurnsThroughCompleted(client, remoteSessionId);
+    } catch (error) {
+      if (!isUnsupportedThreadTurnsListError(error)) throw error;
+      this.logger.warn(
+        { error, remoteSessionId },
+        "App Server does not support lightweight Fork source reads; falling back to complete thread history.",
+      );
+      return this.readRemoteSession(remoteSessionId);
+    }
+    return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary({
+      ...metadata.thread,
+      turns,
+    }));
+  }
+
+  private async decorateRemoteSession(
+    remoteSessionId: string,
+    summary: RemoteSessionSummary,
+  ): Promise<RemoteSessionSummary> {
     const activeThreads = await this.localActivityDetector?.activeThreads([remoteSessionId]);
     const activeSummary = activeThreads ? markLocallyDetectedActive(summary, activeThreads) : summary;
     const settings = await this.localActivityDetector?.threadSettings([remoteSessionId]);
@@ -315,6 +347,46 @@ export class CodexRuntime implements AgentRuntime {
     };
   }
 
+  private async listRecentThreadTurnsThroughCompleted(
+    client: AppServerClient,
+    remoteSessionId: string,
+  ): Promise<CodexTurnSnapshot[]> {
+    const turns: CodexTurnSnapshot[] = [];
+    const seenCursors = new Set<string>();
+    let cursor: string | undefined;
+    do {
+      const response = await client.request<ThreadTurnsListResponse>(
+        "thread/turns/list",
+        {
+          threadId: remoteSessionId,
+          ...(cursor ? { cursor } : {}),
+          limit: FORK_SOURCE_TURN_PAGE_SIZE,
+          sortDirection: "desc",
+          itemsView: "summary",
+        },
+        FORK_SOURCE_REQUEST_TIMEOUT_MS,
+      );
+      turns.push(...response.data);
+      const completedIndex = turns.findIndex((turn) => turn.status === "completed");
+      if (completedIndex >= 0) {
+        turns.splice(completedIndex + 1);
+        break;
+      }
+      const nextCursor = response.nextCursor ?? undefined;
+      if (!nextCursor) break;
+      if (seenCursors.has(nextCursor)) {
+        this.logger.warn(
+          { remoteSessionId, cursor: nextCursor },
+          "App Server repeated a Fork source Turn cursor; stopping pagination.",
+        );
+        break;
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
+    } while (cursor);
+    return turns.reverse();
+  }
+
   private async readThreadWithTurns(
     client: AppServerClient,
     remoteSessionId: string,
@@ -1229,6 +1301,12 @@ function isPaginatedThreadReadError(error: unknown): boolean {
   return /paginated threads?[^\n]*do(?:es)? not support[^\n]*thread\/read[^\n]*includeTurns\s*=\s*true/i.test(details);
 }
 
+function isUnsupportedThreadTurnsListError(error: unknown): boolean {
+  if (!(error instanceof AppServerRequestError) || error.method !== "thread/turns/list") return false;
+  return error.code === -32601
+    || /method not found|unknown method|unsupported|not supported/i.test(appServerErrorDetails(error));
+}
+
 function isUnmaterializedThreadReadError(error: unknown): boolean {
   const details = appServerErrorDetails(error);
   return /thread[^\n]*(?:not materialized|not loaded)[^\n]*includeTurns[^\n]*(?:unavailable|before first user message)/i

package/src/feishu/CardRenderer.ts

@@ -281,7 +281,7 @@ export interface AppServerReleaseCardView {
   scheduleId: number;
   agentName: string;
   blockingTaskCount?: number;
-  releaseInSeconds?: number;
+  blockingTaskTitles?: string[];
   forced?: boolean;
   error?: string;
 }
@@ -405,16 +405,20 @@ export class CardRenderer {
     }
 
     const blockingTaskCount = Math.max(0, view.blockingTaskCount ?? 0);
-    const releaseInSeconds = Math.max(1, view.releaseInSeconds ?? 1);
-    return sectionCard("等待释放", [
+    const blockingTaskLines = (view.blockingTaskTitles ?? []).map((title, index) => {
+      const normalizedTitle = title.replace(/\s+/g, " ").trim() || "未命名任务";
+      return `${index + 1}. ${inlineCode(truncateText(normalizedTitle, 80))}`;
+    });
+    return sectionCard(blockingTaskCount > 0 ? "等待释放" : "确认释放", [
       markdown([
         `**Agent**：${agent}`,
         blockingTaskCount > 0
           ? `**等待任务**：${blockingTaskCount}`
-          : `**自动释放**：${releaseInSeconds} 秒后`,
+          : "**状态**：可以释放",
+        ...blockingTaskLines,
         blockingTaskCount > 0
-          ? "> 任务结束后自动释放；立即释放会中断执行。"
-          : "> 可立即释放或取消。",
+          ? "> 点击 **Release Now** 会中断执行；也可等待任务结束后再释放。"
+          : "> 点击 **Release** 释放，或取消。",
       ].join("\n")),
       {
         tag: "column_set",
@@ -428,7 +432,7 @@ export class CardRenderer {
             vertical_align: "center",
             elements: [{
               tag: "button",
-              text: { tag: "plain_text", content: "Release Now" },
+              text: { tag: "plain_text", content: blockingTaskCount > 0 ? "Release Now" : "Release" },
               type: "danger",
               size: "small",
               behaviors: [{

package/src/proxy/ProxySessionController.ts

@@ -143,10 +143,9 @@ interface AppServerReleaseSchedule {
   runtime: AgentRuntime;
   status: AppServerReleaseCardView["status"];
   blockingTaskCount: number;
+  blockingTaskTitles: string[];
   targets: Map<string, AppServerReleaseCardTarget>;
   forced: boolean;
-  releaseAt?: number;
-  releaseCountdownSeconds?: number;
   releaseStarted?: boolean;
   error?: string;
   timer?: NodeJS.Timeout;
@@ -184,7 +183,6 @@ 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 = "请参考引用消息回复用户";
@@ -454,7 +452,6 @@ export interface ControlTaskReleaseResult {
   agentName: string;
   status: "waiting" | "released";
   blockingTaskCount: number;
-  releaseInSeconds?: number;
 }
 
 export interface ProxyLifecycle {
@@ -1287,7 +1284,6 @@ export class ProxySessionController {
       agentName: result.agentName,
       status: result.status,
       blockingTaskCount: result.blockingTaskCount,
-      ...(result.releaseInSeconds !== undefined ? { releaseInSeconds: result.releaseInSeconds } : {}),
     };
   }
 
@@ -3041,7 +3037,7 @@ export class ProxySessionController {
       runtime = this.runtimes.forAgent(agentName);
     } else {
       if (!taskId) throw new Error("缺少要 fork 的 App Server 任务 ID。");
-      const resolved = await this.resolveRemoteCodexSession(taskId);
+      const resolved = await this.resolveRemoteCodexSession(taskId, { forFork: true });
       agentName = resolved.agentName;
       runtime = resolved.runtime;
       remote = resolved.remote;
@@ -6218,7 +6214,10 @@ export class ProxySessionController {
       : this.store.findSessionByRemoteSessionId(reference, contextKey);
   }
 
-  private async resolveRemoteCodexSession(reference: string): Promise<AgentRemoteSession> {
+  private async resolveRemoteCodexSession(
+    reference: string,
+    options: { forFork?: boolean } = {},
+  ): Promise<AgentRemoteSession> {
     const scoped = parseRemoteSessionReference(reference);
     const candidates = scoped
       ? [[scoped.agentName, this.runtimes.forAgent(scoped.agentName)] as const]
@@ -6229,10 +6228,13 @@ export class ProxySessionController {
       if (runtime.kind !== "codex" || !runtime.readRemoteSession) {
         throw new Error(`Agent ${agentName} 不支持读取远端任务。`);
       }
+      const remoteSessionId = scoped?.remoteSessionId ?? reference;
       return {
         agentName,
         runtime,
-        remote: await runtime.readRemoteSession(scoped?.remoteSessionId ?? reference),
+        remote: options.forFork && runtime.readRemoteForkSource
+          ? await runtime.readRemoteForkSource(remoteSessionId)
+          : await runtime.readRemoteSession(remoteSessionId),
       } satisfies AgentRemoteSession;
     }));
     const matches = reads
@@ -6968,7 +6970,6 @@ export class ProxySessionController {
     agentName: string;
     status: "waiting" | "released" | "failed";
     blockingTaskCount: number;
-    releaseInSeconds?: number;
     error?: string;
   }> {
     const record = requestedRecord ?? this.requireCurrentSession(contextKey);
@@ -6980,20 +6981,17 @@ export class ProxySessionController {
     let schedule = this.appServerReleaseSchedules.get(record.agentName);
     const created = !schedule;
     if (!schedule) {
-      const blockingTaskCount = this.appServerReleaseBlockers(record.agentName, runtime).length;
+      const blockers = this.appServerReleaseBlockers(record.agentName, runtime);
+      const blockingTaskCount = blockers.length;
       schedule = {
         id: this.nextAppServerReleaseScheduleId++,
         agentName: record.agentName,
         runtime,
         status: "waiting",
         blockingTaskCount,
+        blockingTaskTitles: this.appServerReleaseTaskTitles(blockers),
         targets: new Map(),
         forced: false,
-        ...(blockingTaskCount === 0
-          ? {
-              releaseCountdownSeconds: Math.ceil(APP_SERVER_RELEASE_IDLE_DELAY_MS / 1_000),
-            }
-          : {}),
       };
       this.appServerReleaseSchedules.set(record.agentName, schedule);
     }
@@ -7006,14 +7004,6 @@ export class ProxySessionController {
       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);
@@ -7026,9 +7016,6 @@ export class ProxySessionController {
       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 } : {}),
     };
   }
@@ -7040,7 +7027,7 @@ export class ProxySessionController {
     if (!Number.isSafeInteger(scheduleId) || !schedule || schedule.id !== scheduleId || schedule.status !== "waiting") {
       throw new Error("释放卡片已失效，请重新发送 /release。");
     }
-    await this.performAppServerRelease(schedule, true);
+    await this.performAppServerRelease(schedule);
   }
 
   private async cancelAppServerRelease(action: CardAction): Promise<void> {
@@ -7075,6 +7062,10 @@ export class ProxySessionController {
     });
   }
 
+  private appServerReleaseTaskTitles(blockers: SessionRecord[]): string[] {
+    return blockers.map((session) => session.title?.trim() || "未命名任务");
+  }
+
   private armAppServerReleaseCheck(schedule: AppServerReleaseSchedule): void {
     if (schedule.status !== "waiting" || schedule.timer || schedule.inFlight) return;
     schedule.timer = setTimeout(() => {
@@ -7089,36 +7080,22 @@ export class ProxySessionController {
 
   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;
-      }
+    const blockers = this.appServerReleaseBlockers(schedule.agentName, schedule.runtime);
+    const blockingTaskCount = blockers.length;
+    const blockingTaskTitles = this.appServerReleaseTaskTitles(blockers);
+    const titlesChanged = schedule.blockingTaskTitles.length !== blockingTaskTitles.length
+      || schedule.blockingTaskTitles.some((title, index) => title !== blockingTaskTitles[index]);
+    if (schedule.blockingTaskCount !== blockingTaskCount || titlesChanged) {
+      schedule.blockingTaskCount = blockingTaskCount;
+      schedule.blockingTaskTitles = blockingTaskTitles;
+      await this.publishAppServerReleaseSchedule(schedule);
     }
-    await this.performAppServerRelease(schedule, false);
+    this.armAppServerReleaseCheck(schedule);
   }
 
-  private async performAppServerRelease(schedule: AppServerReleaseSchedule, force: boolean): Promise<void> {
+  private async performAppServerRelease(schedule: AppServerReleaseSchedule): Promise<void> {
     if (schedule.inFlight) return schedule.inFlight;
-    const operation = this.performAppServerReleaseNow(schedule, force);
+    const operation = this.performAppServerReleaseNow(schedule);
     schedule.inFlight = operation;
     try {
       await operation;
@@ -7128,31 +7105,17 @@ export class ProxySessionController {
     }
   }
 
-  private async performAppServerReleaseNow(schedule: AppServerReleaseSchedule, force: boolean): Promise<void> {
+  private async performAppServerReleaseNow(schedule: AppServerReleaseSchedule): 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;
-      }
-    }
+    const interruptedWork = this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length > 0;
+    await this.cancelQueuedPromptsForAppServerRelease(schedule.agentName);
 
     schedule.status = "releasing";
     schedule.blockingTaskCount = 0;
-    schedule.releaseAt = undefined;
-    schedule.releaseCountdownSeconds = undefined;
+    schedule.blockingTaskTitles = [];
     schedule.releaseStarted = false;
     schedule.forced = interruptedWork;
     await this.publishAppServerReleaseSchedule(schedule);
@@ -7162,18 +7125,18 @@ export class ProxySessionController {
     ) return;
     schedule.releaseStarted = true;
     try {
-      const result = await schedule.runtime.release?.({ force });
+      const result = await schedule.runtime.release?.({ force: true });
       if (!result) throw new Error("当前 Agent 不支持释放 App Server。");
       if (result.status === "busy") {
+        const blockers = this.appServerReleaseBlockers(schedule.agentName, schedule.runtime);
         schedule.status = "waiting";
         schedule.blockingTaskCount = Math.max(
           result.activeSessionIds?.length ?? 0,
-          this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length,
+          blockers.length,
           1,
         );
+        schedule.blockingTaskTitles = this.appServerReleaseTaskTitles(blockers);
         schedule.forced = false;
-        schedule.releaseAt = undefined;
-        schedule.releaseCountdownSeconds = undefined;
         schedule.releaseStarted = false;
         await this.publishAppServerReleaseSchedule(schedule);
         this.armAppServerReleaseCheck(schedule);
@@ -7233,9 +7196,7 @@ export class ProxySessionController {
       scheduleId: schedule.id,
       agentName: schedule.agentName,
       ...(schedule.blockingTaskCount > 0 ? { blockingTaskCount: schedule.blockingTaskCount } : {}),
-      ...(schedule.releaseCountdownSeconds !== undefined
-        ? { releaseInSeconds: schedule.releaseCountdownSeconds }
-        : {}),
+      ...(schedule.blockingTaskTitles.length > 0 ? { blockingTaskTitles: schedule.blockingTaskTitles } : {}),
       ...(schedule.forced ? { forced: true } : {}),
       ...(schedule.error ? { error: schedule.error } : {}),
     };

package/src/runtime/types.ts

@@ -230,6 +230,7 @@ export interface AgentRuntime {
   readSessionMetadata(remoteSessionId: string): Promise<RuntimeSessionMetadata>;
   listRemoteSessions?(input?: { searchTerm?: string; cursor?: string; limit?: number }): Promise<RemoteSessionPage>;
   readRemoteSession?(remoteSessionId: string): Promise<RemoteSessionSummary>;
+  readRemoteForkSource?(remoteSessionId: string): Promise<RemoteSessionSummary>;
   inspectRemoteSessionActivity?(remoteSessionId: string): Promise<RemoteSessionActivity>;
   synchronizeSession(sessionId: string): Promise<RuntimeSession>;
   startTurn(sessionId: string, prompt: RuntimePrompt): Promise<string>;