@keyou007/agent-bot 0.1.15-alpha.4 → 0.1.15-alpha.5

package/src/feishu/CardRenderer.ts

@@ -240,11 +240,12 @@ export interface DismissGroupCardView {
 }
 
 export interface ShellCommandCardView {
+  jobId?: string;
+  contextKey?: string;
   command: string;
   cwd: string;
-  stdout: string;
-  stderr: string;
-  status: "running" | "completed" | "failed" | "timed_out";
+  output: string;
+  status: "running" | "cancelling" | "completed" | "failed" | "cancelled" | "timed_out";
   exitCode?: number | null;
   elapsedMs: number;
   outputTruncated: boolean;
@@ -258,12 +259,7 @@ export class CardRenderer {
   }
 
   renderShellCommandCard(view: ShellCommandCardView): Record<string, unknown> {
-    const stdout = normalizeTerminalOutput(view.stdout).trimEnd();
-    const stderr = normalizeTerminalOutput(view.stderr).trimEnd();
-    const rawOutput = [
-      stdout,
-      stderr ? `[stderr]\n${stderr}` : "",
-    ].filter(Boolean).join("\n");
+    const rawOutput = normalizeTerminalOutput(view.output).trimEnd();
     const displayOutput = truncateMiddle(
       rawOutput,
       6_000,
@@ -273,15 +269,32 @@ export class CardRenderer {
     const output = displayOutput || (view.status === "running" ? "等待输出..." : "（无输出）");
     const status = shellCommandStatus(view);
     const outputWasTruncated = view.outputTruncated || rawOutput.length > 6_000;
+    const elements = [
+      markdown(codeBlock(`$  ${command}\n${output}`, 6_700)),
+      markdown([
+        `${inlineCode(view.cwd)} · ${status.label} · ${formatTurnDuration(view.elapsedMs)}`,
+        ...(outputWasTruncated ? ["输出过长，已保留开头和结尾并截断中间内容。"] : []),
+      ].join("\n")),
+    ];
+    if (view.status === "running" && view.jobId && view.contextKey) {
+      elements.push({
+        tag: "button",
+        text: { tag: "plain_text", content: "Cancel" },
+        type: "danger",
+        size: "small",
+        behaviors: [{
+          type: "callback",
+          value: {
+            action: "shell_command_cancel",
+            jobId: view.jobId,
+            contextKey: view.contextKey,
+          },
+        }],
+      });
+    }
     return sectionCard(
       status.title,
-      [
-        markdown(codeBlock(`$  ${command}\n${output}`, 6_700)),
-        markdown([
-          `${inlineCode(view.cwd)} · ${status.label} · ${formatTurnDuration(view.elapsedMs)}`,
-          ...(outputWasTruncated ? ["输出过长，已保留开头和结尾并截断中间内容。"] : []),
-        ].join("\n")),
-      ],
+      elements,
       status.template,
     );
   }
@@ -2052,11 +2065,66 @@ function renderToolDetails(tool: ToolState, projectCwd?: string): string {
   const displayCommand = tool.kind === "command"
     ? unwrapShellCommand(normalizedCommand) ?? normalizedCommand
     : normalizedCommand;
-  const commandText = truncateText(displayCommand, 600);
+  const commandText = truncateText(
+    tool.kind === "command" ? formatShellCommandForDisplay(displayCommand) : displayCommand,
+    600,
+  );
   const resultText = result ? truncateToolResult(normalizeTerminalOutput(result).trim()) : undefined;
   return codeBlock([`$ ${commandText}`, resultText].filter((part): part is string => part !== undefined).join("\n"), 2_003);
 }
 
+function formatShellCommandForDisplay(command: string): string {
+  const normalized = command.replace(/\r\n/g, "\n");
+  let result = "";
+  let quote: "'" | "\"" | undefined;
+
+  for (let index = 0; index < normalized.length; index += 1) {
+    const character = normalized[index] ?? "";
+
+    if (quote) {
+      result += character;
+      if ((character === "\\" || character === "`") && quote === "\"") {
+        if (index + 1 < normalized.length) result += normalized[++index];
+      } else if (character === quote) {
+        quote = undefined;
+      }
+      continue;
+    }
+
+    if (character === "'" || character === "\"") {
+      quote = character;
+      result += character;
+      continue;
+    }
+
+    if (character === "\\" || character === "`" || character === "^") {
+      result += character;
+      if (index + 1 < normalized.length) result += normalized[++index];
+      continue;
+    }
+
+    const operator = readShellDisplayOperator(normalized, index);
+    if (!operator) {
+      result += character;
+      continue;
+    }
+
+    result += operator;
+    index += operator.length - 1;
+    while (index + 1 < normalized.length && /\s/.test(normalized[index + 1] ?? "")) index += 1;
+    if (index + 1 < normalized.length) result += " \\\n  ";
+  }
+
+  return result;
+}
+
+function readShellDisplayOperator(command: string, index: number): string | undefined {
+  for (const operator of ["&&", "||", "|&", ";", "|"]) {
+    if (command.startsWith(operator, index)) return operator;
+  }
+  return undefined;
+}
+
 function normalizeTerminalOutput(value: string): string {
   const clean = stripAnsi(value).replace(/\r\n/g, "\n");
   return clean
@@ -2167,6 +2235,12 @@ function shellCommandStatus(view: ShellCommandCardView): {
   if (view.status === "running") {
     return { title: "正在执行命令", label: "运行中", template: "blue" };
   }
+  if (view.status === "cancelling") {
+    return { title: "正在取消命令", label: "正在取消", template: "orange" };
+  }
+  if (view.status === "cancelled") {
+    return { title: "命令已取消", label: "已取消", template: "grey" };
+  }
   if (view.status === "timed_out") {
     return { title: "命令执行超时", label: "已超时（120s）", template: "orange" };
   }

package/src/feishu/FinalResponseBranding.ts

@@ -1,4 +1,5 @@
-export const FINAL_RESPONSE_BRANDING = "> Powered by [AgentBot](https://github.com/keyou/agent-bot)";
+export const FINAL_RESPONSE_BRANDING =
+  "> Powered by [AgentBot](https://bytedance.larkoffice.com/docx/UTukdYBopojSivxRVeUcCXTtnid)";
 export const FINAL_RESPONSE_BRANDING_BLOCK = `----\n\n${FINAL_RESPONSE_BRANDING}`;
 
 export function splitFinalResponseBranding(markdown: string): {

package/src/proxy/ProxySessionController.ts

@@ -47,6 +47,12 @@ import type {
   RuntimePrompt,
   RuntimeSession,
 } from "../runtime/types.js";
+import {
+  isActiveShellCommandJob,
+  ShellCommandJobManager,
+  type ShellCommandJobManagerLike,
+  type ShellCommandJobSnapshot,
+} from "../shell/ShellCommandJobManager.js";
 import {
   StateStore,
   type CardActionBinding,
@@ -63,7 +69,6 @@ import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import {
   executeShellCommand,
   type ShellCommandOptions,
-  type ShellCommandOutputSnapshot,
   type ShellCommandResult,
 } from "../utils/executeShellCommand.js";
 
@@ -94,6 +99,12 @@ interface ForwardAttachmentReservation {
   registry: Map<string, PendingForwardAttachment>;
 }
 
+interface ShellCommandJobMonitor {
+  scheduler: CardUpdateScheduler<ShellCommandCardView>;
+  timer: NodeJS.Timeout;
+  refreshing: boolean;
+}
+
 const MESSAGE_RECEIVED_REACTION = "OnIt";
 const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
@@ -105,7 +116,8 @@ const RESET_HISTORY_PAGE_SIZE = 10;
 const MAX_LLM_TURN_RETRIES = 3;
 const RECOVERY_ACTIVITY_WINDOW_MS = 5 * 60 * 1_000;
 const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
-const SHELL_COMMAND_ELAPSED_UPDATE_INTERVAL_MS = 3_000;
+const SHELL_COMMAND_JOB_POLL_INTERVAL_MS = 1_000;
+const SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS = 5_000;
 const FORWARD_ATTACHMENT_WINDOW_MS = 800;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
@@ -150,6 +162,12 @@ const HELP_COMMAND_SECTIONS: Array<{
         usage: "[目录]",
         description: "浏览、发送文件，并从选定目录创建任务或群",
       },
+      {
+        command: "/file",
+        usage: "&#60;文件路径&#62;",
+        description: "将指定文件发送到当前飞书会话",
+        requiresArgument: true,
+      },
       {
         command: "/forkgroup",
         usage: "[title]",
@@ -404,6 +422,7 @@ export class ProxySessionController {
   private readonly pendingMergedForwards = new Map<string, PendingForwardAttachment>();
   private readonly pendingResourceForwards = new Map<string, PendingForwardAttachment>();
   private readonly relatedReactionMessageIds = new Map<string, string[]>();
+  private readonly shellCommandJobMonitors = new Map<string, ShellCommandJobMonitor>();
   private readonly unsubscribe: Array<() => void> = [];
   private readonly recoveryActivityHeartbeat: NodeJS.Timeout;
   private startupRecovery?: Promise<void>;
@@ -418,6 +437,9 @@ export class ProxySessionController {
     private readonly lifecycle?: ProxyLifecycle,
     private readonly shellCommandExecutor: ShellCommandExecutor = executeShellCommand,
     private readonly windowsDriveLister: WindowsDriveLister = listWindowsDriveRoots,
+    private readonly shellCommandJobs: ShellCommandJobManagerLike = new ShellCommandJobManager(
+      path.join(path.dirname(config.storage.sqlitePath), "command-jobs"),
+    ),
   ) {
     for (const [, runtime] of this.runtimes.entries()) {
       this.unsubscribe.push(
@@ -708,7 +730,9 @@ export class ProxySessionController {
             message.userId,
             message,
           );
-          if (!isPromptCommand(command)) await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+          if (!commandDefersReactionFinalization(command)) {
+            await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+          }
         } catch (error) {
           await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
           await this.sendError(message.contextKey, error);
@@ -731,7 +755,9 @@ export class ProxySessionController {
             message.userId,
             message,
           );
-          if (!isPromptCommand(command)) await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+          if (!commandDefersReactionFinalization(command)) {
+            await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+          }
         } catch (error) {
           await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
           await this.sendError(message.contextKey, error);
@@ -786,6 +812,11 @@ export class ProxySessionController {
         } else if (kind === "turn_cancel") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.cancelSession(this.requireSession(contextKey, sessionId));
+        } else if (kind === "shell_command_cancel") {
+          await this.cancelShellCommandJob(
+            contextKey,
+            String(scopedAction.value.jobId ?? ""),
+          );
         } else if (kind === "turn_reset") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.resetCurrentSessionToTurn(
@@ -1057,6 +1088,7 @@ export class ProxySessionController {
     this.relatedReactionMessageIds.clear();
     for (const timer of this.recoveryRetryTimers.values()) clearTimeout(timer);
     this.recoveryRetryTimers.clear();
+    for (const [jobId] of this.shellCommandJobMonitors) this.stopShellCommandJobMonitor(jobId);
     clearInterval(this.recoveryActivityHeartbeat);
   }
 
@@ -1700,11 +1732,14 @@ export class ProxySessionController {
     }
     switch (command.type) {
       case "shell":
-        await this.runShellCommand(contextKey, command.command);
+        await this.runShellCommand(contextKey, command.command, messageId);
         return;
       case "dir":
         await this.openDirectoryBrowser(contextKey, command.directory);
         return;
+      case "file":
+        await this.sendCurrentTaskFile(contextKey, command.filePath);
+        return;
       case "new":
         if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "app-server") {
           throw new Error("/new --nodir 仅支持 App Server Agent。");
@@ -1872,6 +1907,7 @@ export class ProxySessionController {
   }
 
   private async runStartupRecovery(): Promise<void> {
+    await this.recoverShellCommandJobs();
     this.backfillTurnAttemptsForUpgrade();
     const attempts = this.store.listIncompleteTurnAttempts();
     const recoveryCutoff = Date.now() - RECOVERY_ACTIVITY_WINDOW_MS;
@@ -4510,106 +4546,155 @@ export class ProxySessionController {
     }
   }
 
-  private async runShellCommand(contextKey: string, command: string): Promise<void> {
+  private async runShellCommand(
+    contextKey: string,
+    command: string,
+    sourceMessageId?: string,
+  ): Promise<void> {
     const cwd = this.currentSession(contextKey)?.cwd ?? this.config.defaults.cwd;
-    const startedAt = Date.now();
-    let latestOutput: ShellCommandOutputSnapshot = {
-      stdout: "",
-      stderr: "",
-      outputTruncated: false,
-    };
-    let runningState: ShellCommandCardView = {
+    const created = await this.shellCommandJobs.createJob({ contextKey, sourceMessageId, command, cwd });
+    let cardMessageId: string | undefined;
+    const initialState: ShellCommandCardView = {
+      jobId: created.id,
+      contextKey,
       command,
       cwd,
-      ...latestOutput,
+      output: "",
+      outputTruncated: false,
       status: "running",
       elapsedMs: 0,
     };
-    const cardMessageId = await this.outbound.sendInteractiveCard(
-      contextKey,
-      this.cardRenderer.renderShellCommandCard(runningState),
-    );
-    const scheduler = cardMessageId
-      ? new CardUpdateScheduler<ShellCommandCardView>({
-          render: (state) => this.cardRenderer.renderShellCommandCard(state),
-          write: (card) => this.outbound.updateInteractiveCard(contextKey, cardMessageId, card),
-          onError: (error) => this.logger.warn(
-            { error, contextKey, messageId: cardMessageId },
-            "Failed to update a shell command card.",
-          ),
-        })
-      : undefined;
-    scheduler?.seed(runningState);
-    const elapsedTimer = scheduler ? setInterval(() => {
-      runningState = { ...runningState, elapsedMs: Date.now() - startedAt };
-      scheduler.update(runningState);
-    }, SHELL_COMMAND_ELAPSED_UPDATE_INTERVAL_MS) : undefined;
-    elapsedTimer?.unref?.();
-
-    const updateRunningOutput = (snapshot: ShellCommandOutputSnapshot): void => {
-      latestOutput = snapshot;
-      runningState = {
-        ...runningState,
-        ...snapshot,
-        elapsedMs: Date.now() - startedAt,
-      };
-      scheduler?.update(runningState);
-    };
-
-    let result: ShellCommandResult;
     try {
-      result = await this.shellCommandExecutor(command, cwd, { onOutput: updateRunningOutput });
+      cardMessageId = await this.outbound.sendInteractiveCard(
+        contextKey,
+        this.cardRenderer.renderShellCommandCard(initialState),
+      );
+      if (!cardMessageId) throw new Error("Failed to create the shell command card.");
+      const bound = await this.shellCommandJobs.bindCard(created.id, cardMessageId);
+      await this.shellCommandJobs.startJob(created.id);
+      this.monitorShellCommandJob(bound, initialState);
     } catch (error) {
-      if (elapsedTimer) clearInterval(elapsedTimer);
-      const failedCard = this.cardRenderer.renderShellCommandCard({
-        command,
-        cwd,
-        ...latestOutput,
-        stderr: [latestOutput.stderr.trimEnd(), runtimeErrorMessage(error)].filter(Boolean).join("\n"),
-        status: "failed",
-        elapsedMs: Date.now() - startedAt,
-      });
-      if (scheduler) {
+      await this.shellCommandJobs.failJob(created.id, runtimeErrorMessage(error)).catch(() => undefined);
+      if (cardMessageId) {
         try {
-          await scheduler.flush({
-            ...runningState,
-            stderr: [latestOutput.stderr.trimEnd(), runtimeErrorMessage(error)].filter(Boolean).join("\n"),
-            status: "failed",
-            elapsedMs: Date.now() - startedAt,
-          });
+          const failed = await this.shellCommandJobs.readJob(created.id);
+          await this.outbound.updateInteractiveCard(
+            contextKey,
+            cardMessageId,
+            this.cardRenderer.renderShellCommandCard(shellCommandJobCardView(failed)),
+          );
+          await this.shellCommandJobs.markPresented(created.id);
         } catch (cardError) {
           this.logger.warn(
-            { error: cardError, contextKey, messageId: cardMessageId },
-            "Failed to finalize a shell command card.",
+            { error: cardError, jobId: created.id, contextKey, messageId: cardMessageId },
+            "Failed to finalize a shell command card after the runner failed to start.",
           );
-        } finally {
-          scheduler.dispose();
         }
       } else {
-        await this.outbound.sendInteractiveCard(contextKey, failedCard);
+        await this.shellCommandJobs.markPresented(created.id).catch(() => undefined);
       }
       throw error;
     }
+  }
 
-    if (elapsedTimer) clearInterval(elapsedTimer);
-    const finalState: ShellCommandCardView = {
-      command,
-      cwd,
-      stdout: result.stdout,
-      stderr: result.stderr,
-      status: result.timedOut ? "timed_out" : result.exitCode === 0 ? "completed" : "failed",
-      exitCode: result.exitCode,
-      elapsedMs: Date.now() - startedAt,
-      outputTruncated: result.outputTruncated,
+  private monitorShellCommandJob(
+    job: ShellCommandJobSnapshot,
+    seededState?: ShellCommandCardView,
+  ): void {
+    if (!job.cardMessageId || this.shellCommandJobMonitors.has(job.id)) return;
+    const scheduler = new CardUpdateScheduler<ShellCommandCardView>({
+      render: (state) => this.cardRenderer.renderShellCommandCard(state),
+      write: (card) => this.outbound.updateInteractiveCard(job.contextKey, job.cardMessageId!, card),
+      onError: (error) => this.logger.warn(
+        { error, jobId: job.id, contextKey: job.contextKey, messageId: job.cardMessageId },
+        "Failed to update a background shell command card.",
+      ),
+    });
+    if (seededState) scheduler.seed(seededState);
+    const monitor: ShellCommandJobMonitor = {
+      scheduler,
+      refreshing: false,
+      timer: setInterval(() => {
+        void this.refreshShellCommandJob(job.id);
+      }, SHELL_COMMAND_JOB_POLL_INTERVAL_MS),
     };
-    if (scheduler) {
-      try {
-        await scheduler.flush(finalState);
-      } finally {
-        scheduler.dispose();
+    monitor.timer.unref?.();
+    this.shellCommandJobMonitors.set(job.id, monitor);
+    void this.refreshShellCommandJob(job.id, seededState === undefined);
+  }
+
+  private async refreshShellCommandJob(jobId: string, critical = false): Promise<void> {
+    const monitor = this.shellCommandJobMonitors.get(jobId);
+    if (!monitor || monitor.refreshing) return;
+    monitor.refreshing = true;
+    try {
+      const job = await this.shellCommandJobs.readJob(jobId);
+      const view = shellCommandJobCardView(job);
+      if (isActiveShellCommandJob(job.status)) {
+        monitor.scheduler.update(view, critical ? "critical" : "normal");
+        return;
       }
-    } else {
-      await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderShellCommandCard(finalState));
+      await monitor.scheduler.flush(view);
+      if (job.sourceMessageId) {
+        await this.finalizeStandaloneMessageReaction(
+          job.sourceMessageId,
+          job.status === "completed" ? "completed" : job.status === "cancelled" ? "cancelled" : "failed",
+        );
+      }
+      await this.shellCommandJobs.markPresented(jobId);
+      this.stopShellCommandJobMonitor(jobId);
+    } catch (error) {
+      this.logger.warn({ error, jobId }, "Failed to refresh a background shell command job.");
+    } finally {
+      const current = this.shellCommandJobMonitors.get(jobId);
+      if (current) current.refreshing = false;
+    }
+  }
+
+  private stopShellCommandJobMonitor(jobId: string): void {
+    const monitor = this.shellCommandJobMonitors.get(jobId);
+    if (!monitor) return;
+    clearInterval(monitor.timer);
+    monitor.scheduler.dispose();
+    this.shellCommandJobMonitors.delete(jobId);
+  }
+
+  private async cancelShellCommandJob(contextKey: string, jobId: string): Promise<void> {
+    if (!jobId) throw new Error("命令任务无效，请使用最新的命令卡片。");
+    const job = await this.shellCommandJobs.readJob(jobId);
+    if (job.contextKey !== contextKey) throw new Error("该命令不属于当前会话。");
+    const requested = await this.shellCommandJobs.requestCancellation(jobId);
+    if (!requested) {
+      await this.outbound.sendText(contextKey, "该命令已经结束。");
+      return;
+    }
+    if (!this.shellCommandJobMonitors.has(jobId)) this.monitorShellCommandJob(job);
+    await this.refreshShellCommandJob(jobId, true);
+  }
+
+  private async recoverShellCommandJobs(): Promise<void> {
+    const jobs = await this.shellCommandJobs.listRecoverableJobs();
+    if (jobs.length > 0) {
+      this.logger.warn(
+        { jobIds: jobs.map((job) => job.id) },
+        "Recovering background shell command jobs after startup.",
+      );
+    }
+    for (const job of jobs) {
+      if (!job.cardMessageId || !this.outbound.canRoute(job.contextKey)) continue;
+      if (
+        job.status === "starting"
+        && job.runnerPid === undefined
+        && Date.now() - job.updatedAt >= SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS
+      ) {
+        try {
+          await this.shellCommandJobs.startJob(job.id);
+        } catch (error) {
+          await this.shellCommandJobs.failJob(job.id, runtimeErrorMessage(error)).catch(() => undefined);
+        }
+      }
+      const refreshed = await this.shellCommandJobs.readJob(job.id);
+      this.monitorShellCommandJob(refreshed);
     }
   }
 
@@ -4990,6 +5075,13 @@ export class ProxySessionController {
     if (!stats.isFile()) throw new Error(`这不是普通文件：${filePath}`);
   }
 
+  private async sendCurrentTaskFile(contextKey: string, requestedFilePath: string): Promise<void> {
+    const record = this.requireCurrentSession(contextKey);
+    const filePath = resolveUserPath(requestedFilePath, record.cwd);
+    await this.assertSendableFile(filePath);
+    await this.outbound.sendFile(contextKey, filePath);
+  }
+
   private async listSessions(
     contextKey: string,
     searchTerm?: string,
@@ -6505,14 +6597,29 @@ function isBotOwnedActiveTurn(record: SessionRecord, remote: RemoteSessionSummar
 }
 
 function isQueueIndependentCommand(command: Command): boolean {
-  if (["archive", "dismiss", "stop", "status", "restart", "mute", "help", "sessions", "dir", "goal", "nosteer"].includes(command.type)) return true;
+  if (["archive", "dismiss", "stop", "status", "restart", "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;
 }
 
+function shellCommandJobCardView(job: ShellCommandJobSnapshot): ShellCommandCardView {
+  const status = job.status === "starting" ? "running" : job.status;
+  return {
+    jobId: job.id,
+    contextKey: job.contextKey,
+    command: job.command,
+    cwd: job.cwd,
+    output: [job.output.trimEnd(), job.error].filter(Boolean).join("\n"),
+    status,
+    exitCode: job.exitCode,
+    elapsedMs: Math.max(0, (job.completedAt ?? Date.now()) - job.startedAt),
+    outputTruncated: job.outputTruncated,
+  };
+}
+
 function commandRequiresCurrentSession(command: Command): boolean {
-  if (["dismiss", "stop", "title", "turns", "model", "provider", "thinking", "permissions", "nosteer"].includes(command.type)) {
+  if (["dismiss", "stop", "title", "turns", "file", "model", "provider", "thinking", "permissions", "nosteer"].includes(command.type)) {
     return true;
   }
   if (command.type === "archive" || command.type === "fork") return command.sessionId === undefined;
@@ -6696,8 +6803,8 @@ async function listWindowsDriveRoots(): Promise<WindowsDriveInfo[]> {
   return drives;
 }
 
-function isPromptCommand(command: Command): boolean {
-  return command.type === "prompt" || command.type === "nosteer";
+function commandDefersReactionFinalization(command: Command): boolean {
+  return command.type === "prompt" || command.type === "nosteer" || command.type === "shell";
 }
 
 function runtimePrompt(text: string, localImagePaths?: string[]): RuntimePrompt {