🤖 feat: allow unlimited bash_output timeout with queued message interruption (#1053)

## Summary

Allow `bash_output` to wait for any amount of time (removing the
previous 15-second limit), while ensuring the chat stays responsive by
detecting when users queue new messages.

## Changes

### 1. Remove timeout limit
- Removed `.max(15)` constraint from the schema
- Updated description to guide agents: "Only use long timeouts (>15s)
when no other useful work can be done in parallel"

### 2. Add abort signal support
- `getOutput()` accepts optional `abortSignal` parameter
- Returns `status: "interrupted"` when stream is cancelled

### 3. Add queued message detection
- Added `setMessageQueued()` / `hasQueuedMessage()` to
`BackgroundProcessManager`
- `queueMessage()` sets the flag; `sendQueuedMessages()` /
`clearQueue()` clears it
- `getOutput()` checks for queued messages in polling loop and returns
early

### Flow when user sends message during `bash_output` wait:
1. `queueMessage()` → `setMessageQueued(workspaceId, true)`
2. `bash_output`'s `getOutput()` polling loop detects
`hasQueuedMessage() = true`
3. Returns `{ status: "interrupted", output: "(waiting interrupted)" }`
4. `tool-call-end` fires → `sendQueuedMessages()` processes queued
message

### 4. UI update
- `ProcessStatusBadge` now supports "interrupted" status with warning
color

## Testing
- Added test for abort signal interruption
- Added test for queued message interruption
- All 14 `bash_output` tests pass

---
_Generated with `mux`_

Author: ammar-agent

src/browser/components/tools/shared/ToolPrimitives.tsx

@@ -215,10 +215,10 @@ export const ExitCodeBadge: React.FC<ExitCodeBadgeProps> = ({ exitCode, classNam
 );
 
 /**
- * Badge for displaying process status (exited, killed, failed)
+ * Badge for displaying process status (exited, killed, failed, interrupted)
  */
 interface ProcessStatusBadgeProps {
-  status: "exited" | "killed" | "failed";
+  status: "exited" | "killed" | "failed" | "interrupted";
   exitCode?: number;
   className?: string;
 }
@@ -233,7 +233,9 @@ export const ProcessStatusBadge: React.FC<ProcessStatusBadgeProps> = ({
       "inline-block shrink-0 rounded px-1.5 py-0.5 text-[10px] font-medium whitespace-nowrap",
       status === "exited" && exitCode === 0
         ? "bg-success text-on-success"
-        : "bg-danger text-on-danger",
+        : status === "interrupted"
+          ? "bg-warning text-on-warning"
+          : "bg-danger text-on-danger",
       className
     )}
   >

src/common/types/tools.ts

@@ -235,7 +235,7 @@ export interface BashOutputToolArgs {
 export type BashOutputToolResult =
   | {
       success: true;
-      status: "running" | "exited" | "killed" | "failed";
+      status: "running" | "exited" | "killed" | "failed" | "interrupted";
       output: string;
       exitCode?: number;
       note?: string; // Agent-only message (not displayed in UI)

src/common/utils/tools/toolDefinitions.ts

@@ -257,12 +257,11 @@ export const TOOL_DEFINITIONS = {
       timeout_secs: z
         .number()
         .min(0)
-        .max(15)
         .describe(
-          "Seconds to wait for new output (0-15). " +
+          "Seconds to wait for new output. " +
             "If no output is immediately available and process is still running, " +
             "blocks up to this duration. Returns early when output arrives or process exits. " +
-            "Use this instead of polling in a loop."
+            "Only use long timeouts (>15s) when no other useful work can be done in parallel."
         ),
     }),
   },

src/node/services/agentSession.ts

@@ -659,12 +659,15 @@ export class AgentSession {
     this.assertNotDisposed("queueMessage");
     this.messageQueue.add(message, options);
     this.emitQueuedMessageChanged();
+    // Signal to bash_output that it should return early to process the queued message
+    this.backgroundProcessManager.setMessageQueued(this.workspaceId, true);
   }
 
   clearQueue(): void {
     this.assertNotDisposed("clearQueue");
     this.messageQueue.clear();
     this.emitQueuedMessageChanged();
+    this.backgroundProcessManager.setMessageQueued(this.workspaceId, false);
   }
 
   /**
@@ -703,6 +706,9 @@ export class AgentSession {
    * Called when tool execution completes, stream ends, or user clicks send immediately.
    */
   sendQueuedMessages(): void {
+    // Clear the queued message flag (even if queue is empty, to handle race conditions)
+    this.backgroundProcessManager.setMessageQueued(this.workspaceId, false);
+
     if (!this.messageQueue.isEmpty()) {
       const { message, options } = this.messageQueue.produceMessage();
       this.messageQueue.clear();

src/node/services/backgroundProcessManager.ts

@@ -99,12 +99,33 @@ export class BackgroundProcessManager extends EventEmitter<BackgroundProcessMana
   // Tracks foreground processes (started via runtime.exec) that can be backgrounded
   // Key is toolCallId to support multiple parallel foreground processes per workspace
   private foregroundProcesses = new Map<string, ForegroundProcess>();
+  // Tracks workspaces with queued messages (for bash_output to return early)
+  private queuedMessageWorkspaces = new Set<string>();
 
   constructor(bgOutputDir: string) {
     super();
     this.bgOutputDir = bgOutputDir;
   }
 
+  /**
+   * Mark whether a workspace has a queued user message.
+   * Used by bash_output to return early when user has sent a new message.
+   */
+  setMessageQueued(workspaceId: string, queued: boolean): void {
+    if (queued) {
+      this.queuedMessageWorkspaces.add(workspaceId);
+    } else {
+      this.queuedMessageWorkspaces.delete(workspaceId);
+    }
+  }
+
+  /**
+   * Check if a workspace has a queued user message.
+   */
+  hasQueuedMessage(workspaceId: string): boolean {
+    return this.queuedMessageWorkspaces.has(workspaceId);
+  }
+
   /** Emit a change event for a workspace */
   private emitChange(workspaceId: string): void {
     this.emit("change", workspaceId);
@@ -409,23 +430,27 @@ export class BackgroundProcessManager extends EventEmitter<BackgroundProcessMana
    * Returns only NEW output since the last call (tracked per process).
    * @param processId Process ID to get output from
    * @param filter Optional regex pattern to filter output lines (non-matching lines are discarded permanently)
-   * @param timeout Seconds to wait for output if none available (0-15, default 0 = non-blocking)
+   * @param timeout Seconds to wait for output if none available (default 0 = non-blocking)
+   * @param abortSignal Optional signal to abort waiting early (e.g., when stream is cancelled)
+   * @param workspaceId Optional workspace ID to check for queued messages (return early to process them)
    */
   async getOutput(
     processId: string,
     filter?: string,
-    timeout?: number
+    timeout?: number,
+    abortSignal?: AbortSignal,
+    workspaceId?: string
   ): Promise<
     | {
         success: true;
-        status: "running" | "exited" | "killed" | "failed";
+        status: "running" | "exited" | "killed" | "failed" | "interrupted";
         output: string;
         exitCode?: number;
         elapsed_ms: number;
       }
     | { success: false; error: string }
   > {
-    const timeoutSecs = Math.min(Math.max(timeout ?? 0, 0), 15); // Clamp to 0-15
+    const timeoutSecs = Math.max(timeout ?? 0, 0);
     log.debug(
       `BackgroundProcessManager.getOutput(${processId}, filter=${filter ?? "none"}, timeout=${timeoutSecs}s) called`
     );
@@ -470,10 +495,21 @@ export class BackgroundProcessManager extends EventEmitter<BackgroundProcessMana
       // 1. We have output
       // 2. Process is no longer running (exited/killed/failed)
       // 3. Timeout elapsed
+      // 4. Abort signal received (user sent a new message)
       if (output.length > 0 || currentStatus !== "running") {
         break;
       }
 
+      if (abortSignal?.aborted || (workspaceId && this.hasQueuedMessage(workspaceId))) {
+        const elapsed_ms = Date.now() - startTime;
+        return {
+          success: true,
+          status: "interrupted",
+          output: "(waiting interrupted)",
+          elapsed_ms,
+        };
+      }
+
       const elapsed = Date.now() - startTime;
       if (elapsed >= timeoutMs) {
         break;

src/node/services/tools/bash_output.test.ts

@@ -481,4 +481,104 @@ describe("bash_output tool", () => {
     await manager.cleanup("test-workspace");
     tempDir[Symbol.dispose]();
   });
+
+  it("should return early with 'interrupted' status when abortSignal is triggered", async () => {
+    const tempDir = new TestTempDir("test-bash-output");
+    const manager = new BackgroundProcessManager(tempDir.path);
+
+    const runtime = createTestRuntime();
+    const config = createTestToolConfig(process.cwd(), { sessionsDir: tempDir.path });
+    config.runtimeTempDir = tempDir.path;
+    config.backgroundProcessManager = manager;
+
+    const processId = `abort-test-${Date.now()}`;
+
+    // Spawn a long-running process with no output
+    const spawnResult = await manager.spawn(runtime, "test-workspace", "sleep 60", {
+      cwd: process.cwd(),
+      displayName: processId,
+    });
+
+    if (!spawnResult.success) {
+      throw new Error("Failed to spawn process");
+    }
+
+    const tool = createBashOutputTool(config);
+    const abortController = new AbortController();
+
+    // Abort after 200ms
+    setTimeout(() => abortController.abort(), 200);
+
+    // Call with long timeout - should be interrupted by abort signal
+    const start = Date.now();
+    const result = (await tool.execute!(
+      { process_id: spawnResult.processId, timeout_secs: 30 },
+      { ...mockToolCallOptions, abortSignal: abortController.signal }
+    )) as BashOutputToolResult;
+    const elapsed = Date.now() - start;
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.status).toBe("interrupted");
+      expect(result.output).toBe("(waiting interrupted)");
+      // Should have returned quickly after abort, not waiting full 30s
+      expect(elapsed).toBeLessThan(1000);
+      expect(elapsed).toBeGreaterThan(150); // At least waited until abort
+    }
+
+    // Cleanup
+    await manager.terminate(spawnResult.processId);
+    await manager.cleanup("test-workspace");
+    tempDir[Symbol.dispose]();
+  });
+
+  it("should return early with 'interrupted' status when message is queued", async () => {
+    const tempDir = new TestTempDir("test-bash-output");
+    const manager = new BackgroundProcessManager(tempDir.path);
+
+    const runtime = createTestRuntime();
+    const config = createTestToolConfig(process.cwd(), { sessionsDir: tempDir.path });
+    config.runtimeTempDir = tempDir.path;
+    config.backgroundProcessManager = manager;
+
+    const processId = `queued-msg-test-${Date.now()}`;
+
+    // Spawn a long-running process with no output
+    const spawnResult = await manager.spawn(runtime, "test-workspace", "sleep 60", {
+      cwd: process.cwd(),
+      displayName: processId,
+    });
+
+    if (!spawnResult.success) {
+      throw new Error("Failed to spawn process");
+    }
+
+    const tool = createBashOutputTool(config);
+
+    // Queue a message after 200ms
+    setTimeout(() => manager.setMessageQueued("test-workspace", true), 200);
+
+    // Call with long timeout - should be interrupted by queued message
+    const start = Date.now();
+    const result = (await tool.execute!(
+      { process_id: spawnResult.processId, timeout_secs: 30 },
+      mockToolCallOptions
+    )) as BashOutputToolResult;
+    const elapsed = Date.now() - start;
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.status).toBe("interrupted");
+      expect(result.output).toBe("(waiting interrupted)");
+      // Should have returned quickly after queued message, not waiting full 30s
+      expect(elapsed).toBeLessThan(1000);
+      expect(elapsed).toBeGreaterThan(150); // At least waited until message was queued
+    }
+
+    // Cleanup
+    manager.setMessageQueued("test-workspace", false);
+    await manager.terminate(spawnResult.processId);
+    await manager.cleanup("test-workspace");
+    tempDir[Symbol.dispose]();
+  });
 });

src/node/services/tools/bash_output.ts

@@ -11,7 +11,10 @@ export const createBashOutputTool: ToolFactory = (config: ToolConfiguration) =>
   return tool({
     description: TOOL_DEFINITIONS.bash_output.description,
     inputSchema: TOOL_DEFINITIONS.bash_output.schema,
-    execute: async ({ process_id, filter, timeout_secs }): Promise<BashOutputToolResult> => {
+    execute: async (
+      { process_id, filter, timeout_secs },
+      { abortSignal }
+    ): Promise<BashOutputToolResult> => {
       if (!config.backgroundProcessManager) {
         return {
           success: false,
@@ -36,7 +39,14 @@ export const createBashOutputTool: ToolFactory = (config: ToolConfiguration) =>
       }
 
       // Get incremental output with blocking wait
-      return await config.backgroundProcessManager.getOutput(process_id, filter, timeout_secs);
+      // Pass workspaceId so getOutput can check for queued messages
+      return await config.backgroundProcessManager.getOutput(
+        process_id,
+        filter,
+        timeout_secs,
+        abortSignal,
+        config.workspaceId
+      );
     },
   });
 };