🤖 fix: defer bash-monitor wakes until the active turn ends

src/browser/features/ChatInput/index.tsx

@@ -78,6 +78,7 @@ import {
 } from "@/browser/utils/workflowRunMessages";
 import { Button } from "@/browser/components/Button/Button";
 import { CUSTOM_EVENTS } from "@/common/constants/events";
+import { useChatErrorToasts } from "@/browser/utils/chatErrorToasts";
 import { EXPERIMENT_IDS } from "@/common/constants/experiments";
 import { extractInlineSkillReferenceCandidates } from "@/browser/utils/agentSkills/inlineSkillReferences";
 import {
@@ -1467,23 +1468,7 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
       window.removeEventListener(CUSTOM_EVENTS.THINKING_LEVEL_TOAST, handler as EventListener);
   }, [variant, props, pushToast]);
 
-  // Show the backend's one-shot child-budget warning on the matching parent workspace.
-  useEffect(() => {
-    if (variant !== "workspace") return;
-
-    const handler = (event: Event) => {
-      const detail = (event as CustomEvent<{ workspaceId: string; message: string }>).detail;
-      if (detail?.workspaceId !== workspaceId || !detail.message) {
-        return;
-      }
-
-      pushToast({ type: "error", message: detail.message });
-    };
-
-    window.addEventListener(CUSTOM_EVENTS.GOAL_CHILD_BUDGET_TOAST, handler as EventListener);
-    return () =>
-      window.removeEventListener(CUSTOM_EVENTS.GOAL_CHILD_BUDGET_TOAST, handler as EventListener);
-  }, [variant, workspaceId, pushToast]);
+  useChatErrorToasts(workspaceId, toast?.message ?? null, pushToast);
 
   // Show toast feedback for analytics rebuild command palette action.
   useEffect(() => {

src/browser/features/Messages/ChatBarrier/RetryBarrier.test.tsx

@@ -72,6 +72,7 @@ function createDeferred<T>() {
 let resumeStreamResult: ResumeStreamResult = { success: true, data: { started: true } };
 let previousAutoRetryEnabled = false;
 const resumeStream = mock((_input: unknown) => Promise.resolve(resumeStreamResult));
+const interruptStream = mock((_input: unknown) => Promise.resolve({ success: true as const }));
 const setAutoRetryEnabled = mock((input: unknown) => {
   if (
     typeof input === "object" &&
@@ -107,6 +108,7 @@ void mock.module("@/browser/contexts/API", () => ({
     api: {
       workspace: {
         resumeStream,
+        interruptStream,
         setAutoRetryEnabled,
       },
     },
@@ -152,6 +154,7 @@ describe("RetryBarrier", () => {
     resumeStreamResult = { success: true, data: { started: true } };
     previousAutoRetryEnabled = false;
     resumeStream.mockClear();
+    interruptStream.mockClear();
     setAutoRetryEnabled.mockClear();
   });
 
@@ -394,4 +397,27 @@ describe("RetryBarrier", () => {
     });
     expect(resumeStream).toHaveBeenCalledTimes(1);
   });
+
+  test("the Stop button opts out of auto-retry inside the same attention-retiring Stop as its shortcut", async () => {
+    currentWorkspaceState = createWorkspaceState({
+      autoRetryStatus: {
+        type: "auto-retry-scheduled",
+        attempt: 1,
+        delayMs: 5_000,
+        scheduledAt: Date.now(),
+      },
+    });
+
+    const view = render(<RetryBarrier workspaceId="ws-1" />);
+
+    fireEvent.click(view.getByRole("button", { name: /^Stop/ }));
+
+    await waitFor(() => expect(interruptStream).toHaveBeenCalledTimes(1));
+    expect(interruptStream).toHaveBeenCalledWith({
+      workspaceId: "ws-1",
+      options: { disableAutoRetry: true, retireBashMonitorAttention: true },
+    });
+    // No separate opt-out call: it would release the retry idle gate ahead of the Stop.
+    expect(setAutoRetryEnabled).not.toHaveBeenCalled();
+  });
 });

src/browser/features/Messages/ChatBarrier/RetryBarrier.tsx

@@ -8,6 +8,7 @@ import { KEYBINDS, formatKeybind } from "@/browser/utils/ui/keybinds";
 import { VIM_ENABLED_KEY } from "@/common/constants/storage";
 import { getSendOptionsFromStorage } from "@/browser/utils/messages/sendOptions";
 import { applyCompactionOverrides } from "@/browser/utils/messages/compactionOptions";
+import { stopStream } from "@/browser/utils/stopStream";
 import { formatSendMessageError } from "@/common/utils/errors/formatSendError";
 import { getErrorMessage } from "@/common/utils/errors";
 
@@ -233,10 +234,11 @@ export const RetryBarrier: React.FC<RetryBarrierProps> = (props) => {
     }
   };
 
-  const handleStopAutoRetry = () => {
+  const handleStopAutoRetry = async () => {
     setCountdown(0);
     setManualRetryError(null);
-    void api?.workspace.setAutoRetryEnabled?.({ workspaceId: props.workspaceId, enabled: false });
+    if (!api) return;
+    await stopStream(api, props.workspaceId, { disableAutoRetry: true });
   };
 
   const lastMessage = getLastMainRetryCandidateMessage(workspaceState.messages);
@@ -301,7 +303,9 @@ export const RetryBarrier: React.FC<RetryBarrierProps> = (props) => {
     actionButton = (
       <button
         className="border-warning font-primary text-warning hover:bg-warning-overlay cursor-pointer rounded border bg-transparent px-4 py-2 text-xs font-semibold whitespace-nowrap transition-all duration-200 hover:-translate-y-px active:translate-y-0 disabled:cursor-not-allowed disabled:opacity-50"
-        onClick={handleStopAutoRetry}
+        onClick={() => {
+          void handleStopAutoRetry();
+        }}
       >
         Stop <span className="mobile-hide-shortcut-hints">({stopKeybind})</span>
       </button>

src/browser/features/Messages/ChatBarrier/StreamingBarrier.test.tsx

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { cleanup, fireEvent, render } from "@testing-library/react";
+import { cleanup, fireEvent, render, waitFor } from "@testing-library/react";
 import { GlobalWindow } from "happy-dom";
 
 import type * as WorkspaceStoreModule from "@/browser/stores/WorkspaceStore";
@@ -163,7 +163,7 @@ describe("StreamingBarrier", () => {
     globalThis.document = undefined as unknown as Document;
   });
 
-  test("clicking stop during normal streaming interrupts with default options", () => {
+  test("clicking stop during normal streaming interrupts with default options", async () => {
     currentWorkspaceState = createWorkspaceState({
       canInterrupt: true,
       isCompacting: false,
@@ -175,12 +175,17 @@ describe("StreamingBarrier", () => {
 
     fireEvent.click(view.getByRole("button", { name: "Stop streaming" }));
 
-    expect(setAutoRetryEnabled).toHaveBeenCalledWith({ workspaceId: "ws-1", enabled: false });
     expect(setInterrupting).toHaveBeenCalledWith("ws-1");
-    expect(interruptStream).toHaveBeenCalledWith({ workspaceId: "ws-1" });
+    await waitFor(() =>
+      expect(interruptStream).toHaveBeenCalledWith({
+        workspaceId: "ws-1",
+        options: { disableAutoRetry: true, retireBashMonitorAttention: true },
+      })
+    );
+    expect(setAutoRetryEnabled).not.toHaveBeenCalled();
   });
 
-  test("clicking stop during stream-start interrupts without setting interrupting state", () => {
+  test("clicking stop during stream-start interrupts without setting interrupting state", async () => {
     currentWorkspaceState = createWorkspaceState({
       canInterrupt: false,
       pendingStreamStartTime: Date.now(),
@@ -195,9 +200,13 @@ describe("StreamingBarrier", () => {
 
     fireEvent.click(stopButton);
 
-    expect(setAutoRetryEnabled).toHaveBeenCalledWith({ workspaceId: "ws-1", enabled: false });
     expect(setInterrupting).not.toHaveBeenCalled();
-    expect(interruptStream).toHaveBeenCalledWith({ workspaceId: "ws-1" });
+    await waitFor(() =>
+      expect(interruptStream).toHaveBeenCalledWith({
+        workspaceId: "ws-1",
+        options: { disableAutoRetry: true, retireBashMonitorAttention: true },
+      })
+    );
   });
 
   test("shows the barrier immediately on first appearance", () => {
@@ -358,13 +367,14 @@ describe("StreamingBarrier", () => {
 
     fireEvent.click(view.getByRole("button", { name: "Stop streaming" }));
 
-    expect(setAutoRetryEnabled).toHaveBeenCalledWith({ workspaceId: "ws-1", enabled: false });
+    // The compaction-cancel flow owns the retry opt-out along with its Stop.
     expect(onCancelCompaction).toHaveBeenCalledTimes(1);
+    expect(setAutoRetryEnabled).not.toHaveBeenCalled();
     expect(setInterrupting).not.toHaveBeenCalled();
     expect(interruptStream).not.toHaveBeenCalled();
   });
 
-  test("clicking stop during compaction falls back to abandonPartial interrupt", () => {
+  test("clicking stop during compaction falls back to abandonPartial interrupt", async () => {
     currentWorkspaceState = createWorkspaceState({
       canInterrupt: true,
       isCompacting: true,
@@ -374,12 +384,13 @@ describe("StreamingBarrier", () => {
 
     fireEvent.click(view.getByRole("button", { name: "Stop streaming" }));
 
-    expect(setAutoRetryEnabled).toHaveBeenCalledWith({ workspaceId: "ws-1", enabled: false });
     expect(setInterrupting).not.toHaveBeenCalled();
-    expect(interruptStream).toHaveBeenCalledWith({
-      workspaceId: "ws-1",
-      options: { abandonPartial: true },
-    });
+    await waitFor(() =>
+      expect(interruptStream).toHaveBeenCalledWith({
+        workspaceId: "ws-1",
+        options: { abandonPartial: true, disableAutoRetry: true, retireBashMonitorAttention: true },
+      })
+    );
   });
 
   test("resets to new workspace text immediately on workspace switch", () => {

src/browser/features/Messages/ChatBarrier/StreamingBarrier.tsx

@@ -14,6 +14,7 @@ import {
 import { getDefaultModel } from "@/browser/hooks/useModelsFromSettings";
 import { useSettings } from "@/browser/contexts/SettingsContext";
 import { useAPI } from "@/browser/contexts/API";
+import { stopStream } from "@/browser/utils/stopStream";
 
 type StreamingPhase =
   | "starting" // Message sent, waiting for stream-start
@@ -264,8 +265,6 @@ export const StreamingBarrier: React.FC<StreamingBarrierProps> = ({
       return;
     }
 
-    void api.workspace.setAutoRetryEnabled?.({ workspaceId, enabled: false });
-
     if (phase === "compacting") {
       // Reuse the established compaction-cancel flow from keyboard shortcuts so we keep
       // edit restoration + follow-up content behavior consistent across input methods.
@@ -274,18 +273,15 @@ export const StreamingBarrier: React.FC<StreamingBarrierProps> = ({
         return;
       }
 
-      void api.workspace.interruptStream({
-        workspaceId,
-        options: { abandonPartial: true },
-      });
+      void stopStream(api, workspaceId, { abandonPartial: true, disableAutoRetry: true });
       return;
     }
 
     if (phase === "streaming") {
       storeRaw.setInterrupting(workspaceId);
     }
 
-    void api.workspace.interruptStream({ workspaceId });
+    void stopStream(api, workspaceId, { disableAutoRetry: true });
   };
 
   // Show settings hint during compaction if no custom compaction model is configured

src/browser/hooks/useAIViewKeybinds.test.tsx

@@ -1,6 +1,6 @@
 import type { ReactNode, RefObject } from "react";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { cleanup, renderHook } from "@testing-library/react";
+import { cleanup, renderHook, waitFor } from "@testing-library/react";
 import { copyFile, readFile, rm, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
@@ -90,7 +90,7 @@ describe("useAIViewKeybinds", () => {
     isolatedModulePaths = [];
   });
 
-  test("Escape interrupts an active stream in normal mode", () => {
+  test("Escape interrupts an active stream in normal mode", async () => {
     const interruptStream = mock(() =>
       Promise.resolve({ success: true as const, data: undefined })
     );
@@ -124,7 +124,7 @@ describe("useAIViewKeybinds", () => {
       })
     );
 
-    expect(interruptStream.mock.calls.length).toBe(1);
+    await waitFor(() => expect(interruptStream.mock.calls.length).toBe(1));
   });
 
   test("Escape does not interrupt when the event target is an <input>", () => {
@@ -168,7 +168,7 @@ describe("useAIViewKeybinds", () => {
     expect(interruptStream.mock.calls.length).toBe(0);
   });
 
-  test("Escape interrupts when an editable element opts in", () => {
+  test("Escape interrupts when an editable element opts in", async () => {
     const interruptStream = mock(() =>
       Promise.resolve({ success: true as const, data: undefined })
     );
@@ -207,10 +207,10 @@ describe("useAIViewKeybinds", () => {
       })
     );
 
-    expect(interruptStream.mock.calls.length).toBe(1);
+    await waitFor(() => expect(interruptStream.mock.calls.length).toBe(1));
   });
 
-  test("Ctrl+C interrupts in vim mode even when an <input> is focused", () => {
+  test("Ctrl+C interrupts in vim mode even when an <input> is focused", async () => {
     const interruptStream = mock(() =>
       Promise.resolve({ success: true as const, data: undefined })
     );
@@ -249,7 +249,56 @@ describe("useAIViewKeybinds", () => {
       })
     );
 
-    expect(interruptStream.mock.calls.length).toBe(1);
+    await waitFor(() => expect(interruptStream.mock.calls.length).toBe(1));
+  });
+
+  test("Escape on the retry barrier opts out of auto-retry inside the Stop itself", async () => {
+    const interruptStream = mock(() =>
+      Promise.resolve({ success: true as const, data: undefined })
+    );
+    const setAutoRetryEnabled = mock(() =>
+      Promise.resolve({
+        success: true as const,
+        data: { previousEnabled: true, enabled: false },
+      })
+    );
+    currentClientMock = {
+      workspace: {
+        interruptStream,
+        setAutoRetryEnabled,
+      },
+    };
+
+    const chatInputAPI: RefObject<ChatInputAPI | null> = { current: null };
+
+    renderUseAIViewKeybinds({
+      workspaceId: "ws",
+      canInterrupt: false,
+      showRetryBarrier: true,
+      chatInputAPI,
+      jumpToBottom: () => undefined,
+      loadOlderHistory: null,
+      handleOpenTerminal: () => undefined,
+      handleOpenInEditor: () => undefined,
+      aggregator: undefined,
+      setEditingMessage: () => undefined,
+      vimEnabled: false,
+    });
+
+    document.body.dispatchEvent(
+      new window.KeyboardEvent("keydown", {
+        key: "Escape",
+        bubbles: true,
+        cancelable: true,
+      })
+    );
+
+    await waitFor(() => expect(interruptStream.mock.calls.length).toBe(1));
+    expect(interruptStream).toHaveBeenCalledWith({
+      workspaceId: "ws",
+      options: { disableAutoRetry: true, retireBashMonitorAttention: true },
+    });
+    expect(setAutoRetryEnabled).not.toHaveBeenCalled();
   });
 
   test.each([

src/browser/hooks/useAIViewKeybinds.ts

@@ -12,6 +12,7 @@ import {
 } from "@/browser/utils/ui/keybinds";
 import type { StreamingMessageAggregator } from "@/browser/utils/messages/StreamingMessageAggregator";
 import { isCompactingStream, cancelCompaction } from "@/browser/utils/compaction/handler";
+import { stopStream } from "@/browser/utils/stopStream";
 import { useAPI } from "@/browser/contexts/API";
 import type { EditingMessageState } from "@/browser/utils/chatEditing";
 
@@ -111,7 +112,6 @@ export function useAIViewKeybinds({
           if (api) {
             void cancelCompaction(api, workspaceId, aggregator, setEditingMessage);
           }
-          void api?.workspace.setAutoRetryEnabled?.({ workspaceId, enabled: false });
           return;
         }
 
@@ -120,8 +120,9 @@ export function useAIViewKeybinds({
         // Non-vim mode: Esc interrupts (except when typing in inputs, unless explicitly opted in)
         if (canInterrupt || showRetryBarrier) {
           e.preventDefault();
-          void api?.workspace.setAutoRetryEnabled?.({ workspaceId, enabled: false });
-          void api?.workspace.interruptStream({ workspaceId });
+          if (api) {
+            void stopStream(api, workspaceId, { disableAutoRetry: true });
+          }
           return;
         }
       }