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

package/src/codex/ThreadWriterProcess.ts

@@ -0,0 +1,385 @@
+import { execFile } from "node:child_process";
+import { access, readdir } from "node:fs/promises";
+import path from "node:path";
+
+const PROCESS_INSPECTION_TIMEOUT_MS = 10_000;
+const MAX_PROCESS_OUTPUT_BYTES = 1024 * 1024;
+const LOCK_INSPECTION_CONCURRENCY = 4;
+const THREAD_WRITER_LOCK_FILE_PATTERN = /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.lock$/iu;
+
+export interface ThreadWriterProcess {
+  writerPid: number;
+  writerProcessName: string;
+  writerStartedAt?: string;
+  applicationPid: number;
+  applicationProcessName: string;
+  applicationStartedAt?: string;
+  displayName: string;
+  canClose: boolean;
+  commandLine?: string;
+}
+
+export interface ThreadWriterProcessController {
+  inspect(lockPath: string): Promise<ThreadWriterProcess[]>;
+  inspectApplicationThreadIds?(lockPath: string, owner: ThreadWriterProcess): Promise<string[]>;
+  close(process: ThreadWriterProcess, force: boolean): Promise<void>;
+}
+
+export class SystemThreadWriterProcessController implements ThreadWriterProcessController {
+  async inspect(lockPath: string): Promise<ThreadWriterProcess[]> {
+    try {
+      await access(lockPath);
+    } catch {
+      return [];
+    }
+    return process.platform === "win32"
+      ? inspectWindowsLockOwners(lockPath)
+      : inspectPosixLockOwners(lockPath);
+  }
+
+  async inspectApplicationThreadIds(lockPath: string, owner: ThreadWriterProcess): Promise<string[]> {
+    if (!owner.applicationStartedAt) return [];
+    let entries;
+    try {
+      entries = await readdir(path.dirname(lockPath), { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const candidates = entries.flatMap((entry) => {
+      if (!entry.isFile()) return [];
+      const match = THREAD_WRITER_LOCK_FILE_PATTERN.exec(entry.name);
+      return match?.[1] ? [{ threadId: match[1], lockPath: path.join(path.dirname(lockPath), entry.name) }] : [];
+    });
+    const ownedThreadIds: string[] = [];
+    for (let index = 0; index < candidates.length; index += LOCK_INSPECTION_CONCURRENCY) {
+      const batch = candidates.slice(index, index + LOCK_INSPECTION_CONCURRENCY);
+      const results = await Promise.all(batch.map(async (candidate) => {
+        const owners = samePath(candidate.lockPath, lockPath)
+          ? [owner]
+          : await this.inspect(candidate.lockPath);
+        return owners.some((candidateOwner) => sameApplication(candidateOwner, owner))
+          ? candidate.threadId
+          : undefined;
+      }));
+      ownedThreadIds.push(...results.filter((threadId): threadId is string => Boolean(threadId)));
+    }
+    return ownedThreadIds;
+  }
+
+  async close(owner: ThreadWriterProcess, force: boolean): Promise<void> {
+    const targetPid = owner.applicationPid;
+    if (!owner.canClose) throw new Error("The writer process is not recognized as a closable Agent application.");
+    if (!owner.applicationStartedAt) throw new Error("The writer process does not have a stable start-time fingerprint.");
+    if (!Number.isSafeInteger(targetPid) || targetPid <= 4 || targetPid === process.pid) {
+      throw new Error(`Refusing to close unsafe process PID ${targetPid}.`);
+    }
+    if (process.platform === "win32") {
+      await executeWindowsPowerShell(WINDOWS_CLOSE_PROCESS_SCRIPT, {
+        AGENT_BOT_CLOSE_PID: String(targetPid),
+        AGENT_BOT_CLOSE_STARTED_AT: owner.applicationStartedAt,
+        AGENT_BOT_FORCE_CLOSE: force ? "true" : "false",
+        AGENT_BOT_WRITER_PID: String(owner.writerPid),
+      });
+      return;
+    }
+    const current = await readPosixProcess(targetPid);
+    if (!current || current.startedAt !== owner.applicationStartedAt) {
+      throw new Error(`Process PID ${targetPid} no longer matches the inspected writer application.`);
+    }
+    process.kill(targetPid, force ? "SIGKILL" : "SIGTERM");
+  }
+}
+
+export function threadWriterLockPath(codexHome: string, threadId: string): string | undefined {
+  if (!THREAD_WRITER_LOCK_FILE_PATTERN.test(`${threadId}.lock`)) {
+    return undefined;
+  }
+  return path.join(codexHome, "thread-writer-locks", `${threadId}.lock`);
+}
+
+export function parseWindowsLockOwners(value: string): ThreadWriterProcess[] {
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+  const parsed: unknown = JSON.parse(trimmed);
+  const entries = Array.isArray(parsed) ? parsed : [parsed];
+  return entries.flatMap((entry) => {
+    if (!entry || typeof entry !== "object") return [];
+    const record = entry as Record<string, unknown>;
+    const writerPid = positiveInteger(record.writerPid);
+    const applicationPid = positiveInteger(record.applicationPid);
+    const writerProcessName = stringValue(record.writerProcessName);
+    const applicationProcessName = stringValue(record.applicationProcessName);
+    if (!writerPid || !applicationPid || !writerProcessName || !applicationProcessName) return [];
+    return [{
+      writerPid,
+      writerProcessName,
+      writerStartedAt: stringValue(record.writerStartedAt),
+      applicationPid,
+      applicationProcessName,
+      applicationStartedAt: stringValue(record.applicationStartedAt),
+      displayName: stringValue(record.displayName) ?? applicationProcessName,
+      canClose: record.canClose === true,
+      commandLine: stringValue(record.commandLine),
+    }];
+  });
+}
+
+async function inspectWindowsLockOwners(lockPath: string): Promise<ThreadWriterProcess[]> {
+  const output = await executeWindowsPowerShell(WINDOWS_LOCK_OWNER_SCRIPT, {
+    AGENT_BOT_THREAD_LOCK_PATH: lockPath,
+  });
+  return parseWindowsLockOwners(output);
+}
+
+async function inspectPosixLockOwners(lockPath: string): Promise<ThreadWriterProcess[]> {
+  const pids = await posixLockOwnerPids(lockPath);
+  const owners = await Promise.all(pids.map((pid) => inspectPosixProcess(pid)));
+  return owners.filter((owner): owner is ThreadWriterProcess => owner !== undefined);
+}
+
+async function posixLockOwnerPids(lockPath: string): Promise<number[]> {
+  const lsof = await tryExecuteFile("lsof", ["-t", "--", lockPath]);
+  const raw = lsof.ok ? lsof.stdout : (await tryExecuteFile("fuser", [lockPath])).stdout;
+  return [...new Set(raw.match(/\d+/gu)?.map(Number).filter((pid) => Number.isSafeInteger(pid) && pid > 0) ?? [])];
+}
+
+async function inspectPosixProcess(writerPid: number): Promise<ThreadWriterProcess | undefined> {
+  const writer = await readPosixProcess(writerPid);
+  if (!writer) return undefined;
+  let application = writer;
+  let cursor = writer;
+  for (let depth = 0; depth < 8 && cursor.parentPid > 1; depth += 1) {
+    const parent = await readPosixProcess(cursor.parentPid);
+    if (!parent) break;
+    if (/\/(?:Codex|ChatGPT)\.app\//iu.test(parent.commandLine)) {
+      application = parent;
+      break;
+    }
+    cursor = parent;
+  }
+  const canClose = isRecognizedWriter(writer.name, writer.commandLine);
+  return {
+    writerPid,
+    writerProcessName: writer.name,
+    writerStartedAt: writer.startedAt,
+    applicationPid: application.pid,
+    applicationProcessName: application.name,
+    applicationStartedAt: application.startedAt,
+    displayName: /\/(?:Codex|ChatGPT)\.app\//iu.test(application.commandLine)
+      ? "Codex Desktop"
+      : writer.name,
+    canClose,
+    commandLine: writer.commandLine,
+  };
+}
+
+interface PosixProcessInfo {
+  pid: number;
+  parentPid: number;
+  name: string;
+  startedAt?: string;
+  commandLine: string;
+}
+
+async function readPosixProcess(pid: number): Promise<PosixProcessInfo | undefined> {
+  const [parent, name, startedAt, commandLine] = await Promise.all([
+    tryExecuteFile("ps", ["-p", String(pid), "-o", "ppid="]),
+    tryExecuteFile("ps", ["-p", String(pid), "-o", "comm="]),
+    tryExecuteFile("ps", ["-p", String(pid), "-o", "lstart="]),
+    tryExecuteFile("ps", ["-p", String(pid), "-o", "command="]),
+  ]);
+  const parentPid = Number(parent.stdout.trim());
+  const processName = name.stdout.trim();
+  if (!parent.ok || !processName || !Number.isSafeInteger(parentPid)) return undefined;
+  return {
+    pid,
+    parentPid,
+    name: processName,
+    startedAt: startedAt.stdout.trim() || undefined,
+    commandLine: commandLine.stdout.trim(),
+  };
+}
+
+function isRecognizedWriter(name: string, commandLine: string): boolean {
+  const candidate = `${name} ${commandLine}`;
+  return /(?:^|[\\/\s])(?:codex|trae(?:x|cli)?)(?:\.exe|\.js)?(?:\s|$)/iu.test(candidate)
+    && /app-server/iu.test(candidate);
+}
+
+async function executeWindowsPowerShell(script: string, extraEnv: Record<string, string>): Promise<string> {
+  const encoded = Buffer.from(script, "utf16le").toString("base64");
+  return executeFile(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encoded],
+    extraEnv,
+  );
+}
+
+function executeFile(command: string, args: string[], extraEnv: Record<string, string> = {}): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, {
+      env: { ...process.env, ...extraEnv },
+      timeout: PROCESS_INSPECTION_TIMEOUT_MS,
+      maxBuffer: MAX_PROCESS_OUTPUT_BYTES,
+      windowsHide: true,
+      encoding: "utf8",
+    }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`${command} failed: ${stderr.trim() || error.message}`, { cause: error }));
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+
+function tryExecuteFile(command: string, args: string[]): Promise<{ ok: boolean; stdout: string }> {
+  return executeFile(command, args).then(
+    (stdout) => ({ ok: true, stdout }),
+    () => ({ ok: false, stdout: "" }),
+  );
+}
+
+function positiveInteger(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function sameApplication(left: ThreadWriterProcess, right: ThreadWriterProcess): boolean {
+  return left.applicationPid === right.applicationPid
+    && Boolean(left.applicationStartedAt)
+    && left.applicationStartedAt === right.applicationStartedAt;
+}
+
+function samePath(left: string, right: string): boolean {
+  const normalizedLeft = path.resolve(left);
+  const normalizedRight = path.resolve(right);
+  return process.platform === "win32"
+    ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+    : normalizedLeft === normalizedRight;
+}
+
+const WINDOWS_CLOSE_PROCESS_SCRIPT = String.raw`
+$ErrorActionPreference = 'Stop'
+$targetPid = [int]$env:AGENT_BOT_CLOSE_PID
+$writerPid = [int]$env:AGENT_BOT_WRITER_PID
+$expectedStartedAt = $env:AGENT_BOT_CLOSE_STARTED_AT
+$forceClose = $env:AGENT_BOT_FORCE_CLOSE -eq 'true'
+$process = Get-Process -Id $targetPid -ErrorAction Stop
+$actualStartedAt = $process.StartTime.ToUniversalTime().ToString('o')
+if ($actualStartedAt -ne $expectedStartedAt) {
+  throw "Process PID $targetPid no longer matches the inspected writer application."
+}
+if ($forceClose) {
+  & taskkill.exe /PID $targetPid /T /F | Out-Null
+  if ($LASTEXITCODE -ne 0) { throw "taskkill failed with exit code $LASTEXITCODE" }
+} elseif ($targetPid -ne $writerPid -and $process.MainWindowHandle -ne 0) {
+  if (-not $process.CloseMainWindow()) {
+    throw "The application did not accept a close request."
+  }
+} else {
+  Stop-Process -Id $targetPid -ErrorAction Stop
+}
+`;
+
+const WINDOWS_LOCK_OWNER_SCRIPT = String.raw`
+$ErrorActionPreference = 'Stop'
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class AgentBotRestartManager {
+  [StructLayout(LayoutKind.Sequential)]
+  public struct RM_UNIQUE_PROCESS {
+    public int dwProcessId;
+    public System.Runtime.InteropServices.ComTypes.FILETIME ProcessStartTime;
+  }
+  public enum RM_APP_TYPE { UnknownApp=0, MainWindow=1, OtherWindow=2, Service=3, Explorer=4, Console=5, Critical=1000 }
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+  public struct RM_PROCESS_INFO {
+    public RM_UNIQUE_PROCESS Process;
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)] public string strAppName;
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst=64)] public string strServiceShortName;
+    public RM_APP_TYPE ApplicationType;
+    public uint AppStatus;
+    public uint TSSessionId;
+    [MarshalAs(UnmanagedType.Bool)] public bool bRestartable;
+  }
+  [DllImport("rstrtmgr.dll", CharSet=CharSet.Unicode)]
+  public static extern int RmStartSession(out uint sessionHandle, int sessionFlags, StringBuilder sessionKey);
+  [DllImport("rstrtmgr.dll", CharSet=CharSet.Unicode)]
+  public static extern int RmRegisterResources(uint sessionHandle, uint fileCount, string[] files, uint applicationCount, RM_UNIQUE_PROCESS[] applications, uint serviceCount, string[] services);
+  [DllImport("rstrtmgr.dll")]
+  public static extern int RmGetList(uint sessionHandle, out uint needed, ref uint count, [In, Out] RM_PROCESS_INFO[] processes, ref uint rebootReasons);
+  [DllImport("rstrtmgr.dll")]
+  public static extern int RmEndSession(uint sessionHandle);
+}
+'@
+
+function Get-AgentBotProcess([int]$processId) {
+  Get-CimInstance Win32_Process -Filter ("ProcessId=" + $processId) -ErrorAction SilentlyContinue
+}
+
+function Get-AgentBotStartTime([int]$processId) {
+  try { (Get-Process -Id $processId -ErrorAction Stop).StartTime.ToUniversalTime().ToString('o') } catch { $null }
+}
+
+$lockPath = $env:AGENT_BOT_THREAD_LOCK_PATH
+$key = New-Object Text.StringBuilder 64
+[uint32]$handle = 0
+$result = [AgentBotRestartManager]::RmStartSession([ref]$handle, 0, $key)
+if ($result -ne 0) { throw "RmStartSession failed: $result" }
+try {
+  $result = [AgentBotRestartManager]::RmRegisterResources($handle, 1, [string[]]@($lockPath), 0, $null, 0, $null)
+  if ($result -ne 0) { throw "RmRegisterResources failed: $result" }
+  [uint32]$needed = 0
+  [uint32]$count = 0
+  [uint32]$rebootReasons = 0
+  $result = [AgentBotRestartManager]::RmGetList($handle, [ref]$needed, [ref]$count, $null, [ref]$rebootReasons)
+  if ($result -eq 0) {
+    ConvertTo-Json -Compress -InputObject @()
+    return
+  }
+  if ($result -ne 234) { throw "RmGetList failed: $result" }
+  $items = New-Object 'AgentBotRestartManager+RM_PROCESS_INFO[]' $needed
+  $count = $needed
+  $result = [AgentBotRestartManager]::RmGetList($handle, [ref]$needed, [ref]$count, $items, [ref]$rebootReasons)
+  if ($result -ne 0) { throw "RmGetList failed: $result" }
+  $owners = @()
+  for ($index = 0; $index -lt $count; $index++) {
+    $writerPid = $items[$index].Process.dwProcessId
+    $writer = Get-AgentBotProcess $writerPid
+    if ($null -eq $writer) { continue }
+    $application = $writer
+    $cursor = $writer
+    for ($depth = 0; $depth -lt 8 -and $cursor.ParentProcessId -gt 1; $depth++) {
+      $parent = Get-AgentBotProcess $cursor.ParentProcessId
+      if ($null -eq $parent) { break }
+      if ($parent.Name -ieq 'ChatGPT.exe' -and $parent.ExecutablePath -match 'OpenAI[.\\]Codex') {
+        $application = $parent
+        break
+      }
+      $cursor = $parent
+    }
+    $recognized = (($writer.Name -match '^(codex|trae|traex|traecli)(.exe)?$') -or ($writer.CommandLine -match '(codex|trae|traex|traecli).*(app-server)'))
+    $desktop = $application.Name -ieq 'ChatGPT.exe' -and $application.ExecutablePath -match 'OpenAI[.\\]Codex'
+    $owners += [pscustomobject]@{
+      writerPid = $writerPid
+      writerProcessName = $writer.Name
+      writerStartedAt = Get-AgentBotStartTime $writerPid
+      applicationPid = [int]$application.ProcessId
+      applicationProcessName = $application.Name
+      applicationStartedAt = Get-AgentBotStartTime $application.ProcessId
+      displayName = $(if ($desktop) { 'Codex Desktop' } else { $writer.Name })
+      canClose = [bool]$recognized
+      commandLine = $writer.CommandLine
+    }
+  }
+  ConvertTo-Json -Compress -InputObject @($owners)
+} finally {
+  [void][AgentBotRestartManager]::RmEndSession($handle)
+}
+`;

package/src/commands/CommandRouter.ts

@@ -18,6 +18,7 @@ export const COMMAND_NAMES = [
   "permissions",
   "provider",
   "queue",
+  "release",
   "restart",
   "sessions",
   "status",
@@ -114,6 +115,9 @@ export class CommandRouter {
         if (args.length === 0) return { type: "restart" };
         if (args.length === 1 && args[0] === "--force") return { type: "restart", force: true };
         throw new Error("/restart 只接受一个可选的 --force 参数。");
+      case "release":
+        if (args.length > 0) throw new Error("/release 不接受参数。");
+        return { type: "release" };
       case "mute": {
         if (args.length === 0 || (args.length === 1 && args[0]!.toLowerCase() === "on")) {
           return { type: "mute", enabled: true };

package/src/commands/commandTypes.ts

@@ -19,6 +19,7 @@ export type Command =
   | { type: "goal"; action: "set" | "edit"; objective: string }
   | { type: "goal"; action: "pause" | "resume" | "clear" }
   | { type: "restart"; force?: boolean }
+  | { type: "release" }
   | { type: "mute"; enabled: boolean }
   | { type: "turns" }
   | { type: "model" }

package/src/console/ConsoleTurnPresenter.ts

@@ -32,9 +32,10 @@ export class ConsoleTurnPresenter implements TurnPresenter {
     return undefined;
   }
 
-  async failPendingTurn(sessionId: string, message: string): Promise<void> {
+  async failPendingTurn(sessionId: string, message: string): Promise<boolean> {
     const contextKey = this.contexts.get(sessionId);
     if (contextKey) await this.outbound.sendText(contextKey, `${this.agentLabel(sessionId)} failed to start: ${message}`);
+    return false;
   }
 
   async interruptTurnForRecovery(): Promise<void> {}

package/src/feishu/CardRenderer.ts

@@ -255,6 +255,37 @@ export interface ShellCommandCardView {
   outputTruncated: boolean;
 }
 
+export interface ThreadWriterConflictCardView {
+  status: "occupied" | "force_required" | "released";
+  contextKey: string;
+  sessionId: string;
+  threadId: string;
+  taskTitle?: string;
+  notice?: string;
+  applicationIdle?: boolean;
+  owner?: {
+    displayName: string;
+    writerPid: number;
+    writerProcessName: string;
+    writerStartedAt?: string;
+    applicationPid: number;
+    applicationProcessName: string;
+    applicationStartedAt?: string;
+    canClose: boolean;
+  };
+}
+
+export interface AppServerReleaseCardView {
+  status: "waiting" | "releasing" | "released" | "cancelled" | "failed";
+  contextKey: string;
+  scheduleId: number;
+  agentName: string;
+  blockingTaskCount?: number;
+  releaseInSeconds?: number;
+  forced?: boolean;
+  error?: string;
+}
+
 export class CardRenderer {
   private readonly thinkingCardLayout: ThinkingCardLayout;
 
@@ -262,6 +293,180 @@ export class CardRenderer {
     this.thinkingCardLayout = options.thinkingCardLayout ?? "grouped";
   }
 
+  renderThreadWriterConflict(view: ThreadWriterConflictCardView): Record<string, unknown> {
+    if (view.status === "released") {
+      return sectionCard("任务占用已解除", [markdown([
+        view.taskTitle ? `**任务**：${inlineCode(view.taskTitle)}` : undefined,
+        view.notice ?? "请重新发送消息。",
+      ].filter((line): line is string => Boolean(line)).join("\n"))], "green");
+    }
+
+    const owner = view.owner;
+    const lines = [
+      view.taskTitle ? `**任务**：${inlineCode(view.taskTitle)}` : undefined,
+      owner ? `**进程**：${inlineCode(`${owner.applicationProcessName} (${owner.applicationPid})`)}` : undefined,
+      view.notice,
+      owner
+        ? view.applicationIdle === true
+          ? "> 无执行中任务，可安全关闭；也可 **Fork** 后继续发送消息。"
+          : view.applicationIdle === false
+            ? "> 有任务执行中，关闭会中断任务；可 **Fork** 后继续发送消息。"
+            : "> 可 **Fork** 后继续发送消息；关闭进程后请重发消息。"
+        : "> 可 **Fork** 后继续发送消息；或手动关闭占用任务。",
+    ].filter((line): line is string => Boolean(line));
+    const elements: Record<string, unknown>[] = [markdown(lines.join("\n"))];
+    const canClose = owner?.canClose
+      && Boolean(owner.writerStartedAt)
+      && Boolean(owner.applicationStartedAt);
+    const actions: Record<string, unknown>[] = [{
+      tag: "button",
+      text: {
+        tag: "plain_text",
+        content: "Fork",
+      },
+      type: "default",
+      size: "small",
+      behaviors: [{
+        type: "callback",
+        value: {
+          action: "thread_writer_fork",
+          contextKey: view.contextKey,
+          sessionId: view.sessionId,
+          threadId: view.threadId,
+        },
+      }],
+    }];
+    if (canClose && owner) {
+      actions.push({
+        tag: "button",
+        text: {
+          tag: "plain_text",
+          content: view.status === "force_required"
+            ? `Force ${owner.applicationPid}`
+            : `Close ${owner.applicationPid}`,
+        },
+        type: "danger",
+        size: "small",
+        behaviors: [{
+          type: "callback",
+          value: {
+            action: "thread_writer_close",
+            contextKey: view.contextKey,
+            sessionId: view.sessionId,
+            threadId: view.threadId,
+            writerPid: owner.writerPid,
+            writerStartedAt: owner.writerStartedAt,
+            applicationPid: owner.applicationPid,
+            applicationStartedAt: owner.applicationStartedAt,
+            force: view.status === "force_required",
+          },
+        }],
+      });
+    }
+    elements.push({
+      tag: "column_set",
+      flex_mode: "none",
+      horizontal_spacing: "8px",
+      vertical_align: "center",
+      columns: actions.map((button) => ({
+        tag: "column",
+        width: "auto",
+        vertical_align: "center",
+        elements: [button],
+      })),
+    });
+    return sectionCard(
+      view.status === "force_required" ? "仍被占用" : "任务被占用",
+      elements,
+      view.status === "force_required" ? "red" : "orange",
+    );
+  }
+
+  renderAppServerRelease(view: AppServerReleaseCardView): Record<string, unknown> {
+    const agent = inlineCode(view.agentName);
+    if (view.status === "released") {
+      return sectionCard("任务已释放", [markdown([
+        `**Agent**：${agent}`,
+        view.forced ? "执行中的任务已中断。" : undefined,
+        "> 请在 Codex Desktop 点击 **Retry**。",
+      ].filter((line): line is string => Boolean(line)).join("\n"))], "green");
+    }
+    if (view.status === "cancelled") {
+      return sectionCard("已取消释放", [markdown(`**Agent**：${agent}\n> Agent Bot 将继续保持当前任务连接。`)], "grey");
+    }
+    if (view.status === "failed") {
+      return sectionCard("释放失败", [markdown([
+        `**Agent**：${agent}`,
+        view.error ? truncateText(view.error, 500) : "无法释放 App Server。",
+      ].join("\n"))], "red");
+    }
+    if (view.status === "releasing") {
+      return sectionCard("正在释放", [markdown(`**Agent**：${agent}\n正在停止 Agent Bot 的 App Server。`)], "blue");
+    }
+
+    const blockingTaskCount = Math.max(0, view.blockingTaskCount ?? 0);
+    const releaseInSeconds = Math.max(1, view.releaseInSeconds ?? 1);
+    return sectionCard("等待释放", [
+      markdown([
+        `**Agent**：${agent}`,
+        blockingTaskCount > 0
+          ? `**等待任务**：${blockingTaskCount}`
+          : `**自动释放**：${releaseInSeconds} 秒后`,
+        blockingTaskCount > 0
+          ? "> 任务结束后自动释放；立即释放会中断执行。"
+          : "> 可立即释放或取消。",
+      ].join("\n")),
+      {
+        tag: "column_set",
+        flex_mode: "none",
+        horizontal_spacing: "8px",
+        vertical_align: "center",
+        columns: [
+          {
+            tag: "column",
+            width: "auto",
+            vertical_align: "center",
+            elements: [{
+              tag: "button",
+              text: { tag: "plain_text", content: "Release Now" },
+              type: "danger",
+              size: "small",
+              behaviors: [{
+                type: "callback",
+                value: {
+                  action: "app_server_release_now",
+                  contextKey: view.contextKey,
+                  scheduleId: view.scheduleId,
+                  agentName: view.agentName,
+                },
+              }],
+            }],
+          },
+          {
+            tag: "column",
+            width: "auto",
+            vertical_align: "center",
+            elements: [{
+              tag: "button",
+              text: { tag: "plain_text", content: "Cancel" },
+              type: "default",
+              size: "small",
+              behaviors: [{
+                type: "callback",
+                value: {
+                  action: "app_server_release_cancel",
+                  contextKey: view.contextKey,
+                  scheduleId: view.scheduleId,
+                  agentName: view.agentName,
+                },
+              }],
+            }],
+          },
+        ],
+      },
+    ], "orange");
+  }
+
   renderShellCommandCard(view: ShellCommandCardView): Record<string, unknown> {
     const rawOutput = normalizeTerminalOutput(view.output).trimEnd();
     const displayOutput = truncateMiddle(

package/src/feishu/FeishuTurnPresenter.ts

@@ -164,9 +164,13 @@ export class FeishuTurnPresenter {
     }
   }
 
-  async failPendingTurn(sessionId: string, message: string): Promise<void> {
+  async failPendingTurn(
+    sessionId: string,
+    message: string,
+    replacementCard?: Record<string, unknown>,
+  ): Promise<boolean> {
     const entry = this.pendingEntries.get(sessionId);
-    if (!entry) return;
+    if (!entry) return false;
     this.pendingEntries.delete(sessionId);
     this.stopElapsedUpdates(entry);
     const completedAt = Date.now();
@@ -183,9 +187,18 @@ export class FeishuTurnPresenter {
       await entry.scheduler?.flush(entry.state);
     } catch (error) {
       this.options.onError?.(error);
-      return;
+      return false;
+    }
+    if (replacementCard && entry.messageId) {
+      try {
+        await this.outbound.updateInteractiveCard(entry.messageId, replacementCard);
+      } catch (error) {
+        this.options.onError?.(error);
+        return false;
+      }
     }
     await this.syncThinkingCardReaction(entry);
+    return Boolean(replacementCard && entry.messageId);
   }
 
   async interruptTurnForRecovery(

package/src/feishu/MergedForwardMessage.ts

@@ -273,8 +273,12 @@ function renderPost(
     for (const rawElement of row) {
       if (!isRecord(rawElement)) continue;
       const tag = textValue(rawElement.tag);
-      if (tag === "text" || tag === "a") {
+      if (tag === "text") {
         rowText += textValue(rawElement.text);
+      } else if (tag === "a") {
+        const text = textValue(rawElement.text);
+        const href = textValue(rawElement.href);
+        rowText += href && href !== text ? `${text || href} (${href})` : text || href;
       } else if (tag === "at") {
         rowText += renderMention(rawElement, mentions);
       } else if (tag === "img") {