diff --git a/apps/sim/app/o/[organizationId]/home/components/composer/composer.test.tsx b/apps/sim/app/o/[organizationId]/home/components/composer/composer.test.tsx
index a59f9923b53..ba6ff3de48b 100644
--- a/apps/sim/app/o/[organizationId]/home/components/composer/composer.test.tsx
+++ b/apps/sim/app/o/[organizationId]/home/components/composer/composer.test.tsx
@@ -193,7 +193,7 @@ async function render(
   requestMode: 'agent' | 'assistant' = 'assistant',
   controls: Pick<
     ComponentProps<typeof Composer>,
-    'isSending' | 'showModeSelector' | 'onModeChange' | 'restoredContexts'
+    'isSending' | 'showModeSelector' | 'onModeChange' | 'restoredContexts' | 'onSendQueuedHead'
   > = { isSending: false }
 ) {
   function Harness() {
@@ -215,6 +215,7 @@ async function render(
         isInitialView={isInitialView}
         isSending={controls.isSending}
         onStop={vi.fn()}
+        onSendQueuedHead={controls.onSendQueuedHead}
         onSubmit={(text, contexts) => {
           mocks.submit(text, files.attachedFiles)
           mocks.contexts(contexts)
@@ -919,3 +920,42 @@ it('offers the advanced models and each model’s supported efforts', async () =
     )
   ).toEqual(['Low', 'Medium', 'High', 'Extra High', 'Max'])
 })
+
+it.each([
+  ['agent', false],
+  ['assistant', false],
+  ['agent', true],
+  ['assistant', true],
+] as const)(
+  'queues once then sends immediately on rapid double Enter (%s, attachment: %s)',
+  async (mode, withAttachment) => {
+    const sendHead = vi.fn()
+    await render(false, withAttachment ? '' : 'Use the latest report', mode, {
+      isSending: true,
+      onSendQueuedHead: sendHead,
+    })
+    if (withAttachment) await paste([new File(['image'], 'follow-up.png', { type: 'image/png' })])
+    const input = container.querySelector<HTMLTextAreaElement>('[aria-label="Ask Sim"]')!
+    await act(async () => {
+      input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
+      expect(mocks.submit).toHaveBeenCalledTimes(1)
+      expect(sendHead).not.toHaveBeenCalled()
+      input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
+    })
+    expect(mocks.submit).toHaveBeenCalledTimes(1)
+    expect(sendHead).toHaveBeenCalledExactlyOnceWith()
+    expect(input.value).toBe('')
+  }
+)
+
+it('does not send a queued head on empty Enter when idle', async () => {
+  const sendHead = vi.fn()
+  await render(false, '', 'assistant', { isSending: false, onSendQueuedHead: sendHead })
+  await act(async () => {
+    container
+      .querySelector<HTMLTextAreaElement>('[aria-label="Ask Sim"]')!
+      .dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
+  })
+  expect(sendHead).not.toHaveBeenCalled()
+  expect(mocks.submit).not.toHaveBeenCalled()
+})
diff --git a/apps/sim/app/o/[organizationId]/home/components/composer/composer.tsx b/apps/sim/app/o/[organizationId]/home/components/composer/composer.tsx
index 0193d2ae948..f1a20c6b433 100644
--- a/apps/sim/app/o/[organizationId]/home/components/composer/composer.tsx
+++ b/apps/sim/app/o/[organizationId]/home/components/composer/composer.tsx
@@ -46,6 +46,7 @@ interface ComposerProps {
   onChange: (value: string, contexts?: ChatContext[]) => void
   restoredContexts?: ChatContext[]
   onSubmit: (text: string, contexts?: ChatContext[]) => void
+  onSendQueuedHead?: () => void
   onStop: () => void
 }
 
@@ -65,9 +66,12 @@ export function Composer({
   isSending,
   onChange,
   onSubmit,
+  onSendQueuedHead,
   restoredContexts,
   onStop,
 }: ComposerProps) {
+  const attachedFilesRef = useRef(files.attachedFiles)
+  attachedFilesRef.current = files.attachedFiles
   const imagesOnly = requestMode === 'assistant'
   const { organization } = useOrganizationContext()
   const { data: allWorkspaces = [] } = useWorkspacesQuery(!imagesOnly)
@@ -147,7 +151,15 @@ export function Composer({
   const placeholder = isInitialView ? animatedPlaceholder : 'Send message to Sim'
 
   const submit = () => {
-    if (!canSubmit) return
+    if (attachedFilesRef.current.some((file) => file.uploading)) return
+    const hasPayload =
+      editor.getValue().trim().length > 0 || attachedFilesRef.current.some((file) => file.key)
+    if (!hasPayload) {
+      if (isSending) onSendQueuedHead?.()
+      return
+    }
+    /** Consume attachments synchronously so a second Enter cannot submit them twice. */
+    attachedFilesRef.current = []
     voice.resetTranscript()
     const contexts = imagesOnly ? [] : editor.getActiveContexts()
     onSubmit(editor.getPlainValue(), contexts.length ? contexts : undefined)
diff --git a/apps/sim/app/o/[organizationId]/home/organization-home.test.tsx b/apps/sim/app/o/[organizationId]/home/organization-home.test.tsx
index 459a1e2c432..1307fe05e22 100644
--- a/apps/sim/app/o/[organizationId]/home/organization-home.test.tsx
+++ b/apps/sim/app/o/[organizationId]/home/organization-home.test.tsx
@@ -1013,3 +1013,17 @@ it('keeps an attachment-only draft across remounts and clears it when its last f
   ).toBeUndefined()
   expect(composerProps().files.attachedFiles).toEqual([])
 })
+
+it('wires empty Enter to the live queue sender for an active organization chat', async () => {
+  const sendNow = vi.fn()
+  mocks.chat.mockReturnValue({
+    ...mocks.chat(),
+    messages: [{ id: 'user-1', role: 'user', content: 'First message' }],
+    isSending: true,
+    sendNow,
+  })
+  mocks.renderer.mockImplementation(({ composer }: { composer: ReactNode }) => composer)
+  await act(async () => renderHome(<OrganizationHome chatId='chat-a' />))
+  await act(async () => composerProps().onSendQueuedHead?.())
+  expect(sendNow).toHaveBeenCalledExactlyOnceWith()
+})
diff --git a/apps/sim/app/o/[organizationId]/home/organization-home.tsx b/apps/sim/app/o/[organizationId]/home/organization-home.tsx
index 70ded2007e9..1ea4df9bb9c 100644
--- a/apps/sim/app/o/[organizationId]/home/organization-home.tsx
+++ b/apps/sim/app/o/[organizationId]/home/organization-home.tsx
@@ -315,6 +315,9 @@ function OrganizationHomeContent({
         isSending={chat.isSending || chat.isReconnecting}
         onChange={setDraft}
         onSubmit={submit}
+        onSendQueuedHead={() => {
+          void chat.sendNow()
+        }}
         onStop={() => {
           void chat.stopGeneration()
         }}
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.test.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.test.tsx
index 5387f79ca10..736ebcfc01a 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.test.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.test.tsx
@@ -6,9 +6,10 @@ import { createRoot } from 'react-dom/client'
 import { expect, it, vi } from 'vitest'
 import type { ChatMessage } from '@/app/workspace/[workspaceId]/home/types'
 
-const { scrollToIndex, renderMessage } = vi.hoisted(() => ({
+const { scrollToIndex, renderMessage, renderInput } = vi.hoisted(() => ({
   scrollToIndex: vi.fn(),
   renderMessage: vi.fn(),
+  renderInput: vi.fn(),
 }))
 
 /** The measured range still covers the old turn while appended rows await measurement. */
@@ -39,7 +40,10 @@ vi.mock('@tanstack/react-virtual', async (importOriginal) => {
 })
 vi.mock('@/app/workspace/[workspaceId]/components', () => ({ MessageActions: () => null }))
 vi.mock('@/app/workspace/[workspaceId]/home/components/user-input', () => ({
-  UserInput: () => null,
+  UserInput: (props: { onSendQueuedHead: () => void }) => {
+    renderInput(props)
+    return null
+  },
 }))
 vi.mock('@/app/workspace/[workspaceId]/home/components/queued-messages', () => ({
   QueuedMessages: () => null,
@@ -231,3 +235,45 @@ it('never restarts the previous response while a new send waits for its deferred
     vi.unstubAllGlobals()
   }
 })
+
+it('delegates empty Enter to the live queue sender before the rendered queue updates', async () => {
+  vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true)
+  vi.stubGlobal(
+    'ResizeObserver',
+    class {
+      observe() {}
+      disconnect() {}
+    }
+  )
+  const container = document.createElement('div')
+  const root = createRoot(container)
+  const client = new QueryClient()
+  const sendNow = vi.fn().mockResolvedValue(undefined)
+  try {
+    await act(async () =>
+      root.render(
+        <QueryClientProvider client={client}>
+          <MothershipChat
+            messages={[]}
+            isSending
+            messageQueue={[]}
+            onSubmit={vi.fn()}
+            onStopGeneration={vi.fn()}
+            onSendQueuedMessage={sendNow}
+            editingQueuedId={null}
+            dispatchingHeadId={null}
+            onRemoveQueuedMessage={vi.fn()}
+            onEditQueuedMessage={vi.fn()}
+            onCancelQueueEdit={vi.fn()}
+          />
+        </QueryClientProvider>
+      )
+    )
+    await act(async () => renderInput.mock.lastCall![0].onSendQueuedHead())
+    expect(sendNow).toHaveBeenCalledExactlyOnceWith()
+  } finally {
+    await act(async () => root.unmount())
+    client.clear()
+    vi.unstubAllGlobals()
+  }
+})
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx
index a7496f90db6..7f5c020266b 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx
@@ -80,7 +80,7 @@ interface MothershipChatProps {
   editingQueuedId: string | null
   dispatchingHeadId: string | null
   onRemoveQueuedMessage: (id: string) => void
-  onSendQueuedMessage: (id: string) => Promise<void>
+  onSendQueuedMessage: (id?: string) => Promise<void>
   onEditQueuedMessage: (id: string) => QueuedMessage | undefined
   onCancelQueueEdit: () => void
   userId?: string
@@ -722,9 +722,8 @@ export function MothershipChat({
   }, [])
 
   const handleSendQueuedHead = useCallback(() => {
-    const topMessage = messageQueueRef.current[0]
-    if (!topMessage) return
-    void onSendQueuedMessage(topMessage.id)
+    /** The first Enter can enqueue before this component has rendered the new queue. */
+    void onSendQueuedMessage()
   }, [onSendQueuedMessage])
 
   const handleEditQueued = useCallback(
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.test.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.test.tsx
index d20e157ae2c..eca74197d0d 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.test.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.test.tsx
@@ -68,15 +68,18 @@ vi.mock('@/app/workspace/[workspaceId]/home/components/user-input/components', a
     PromptEditor: ({
       editor,
       placeholder,
+      onSubmit,
     }: {
       editor: PromptEditorInstance
       placeholder: string
+      onSubmit: () => void
     }) => (
       <textarea
         ref={editor.textareaRef}
         value={editor.value}
         placeholder={placeholder}
         onChange={editor.handleInputChange}
+        onKeyDown={(event) => editor.handleKeyDown(event, { onSubmit })}
       />
     ),
     SendButton: ({ onSubmit }: { onSubmit: () => void }) => (
@@ -109,7 +112,7 @@ const QUEUED_MESSAGE: QueuedMessage = {
 let root: Root | null = null
 let container: HTMLDivElement | null = null
 
-function mount() {
+function mount(isSending = false, onSendQueuedHead?: () => void) {
   const inputRef = createRef<UserInputHandle>()
 
   function Composer() {
@@ -127,7 +130,8 @@ function mount() {
           ref={inputRef}
           defaultValue='Initial draft'
           onSubmit={mockSubmit}
-          isSending={false}
+          isSending={isSending}
+          onSendQueuedHead={onSendQueuedHead}
           onStopGeneration={vi.fn()}
         />
       </>
@@ -218,3 +222,19 @@ describe('workspace composer', () => {
     expect(mockResetTranscript).toHaveBeenCalled()
   })
 })
+
+it.each([false, true])(
+  'sends a queued message on the second Enter without resubmitting attachments (%s)',
+  async (withAttachment) => {
+    const sendHead = vi.fn()
+    mount(true, sendHead)
+    if (withAttachment) await clickButton('Edit queued')
+    await act(async () => {
+      textarea().dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
+      textarea().dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
+    })
+    expect(mockSubmit).toHaveBeenCalledTimes(1)
+    expect(sendHead).toHaveBeenCalledExactlyOnceWith()
+    expect(textarea().value).toBe('')
+  }
+)
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx
index 76300944348..aa6cf08303b 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx
@@ -476,6 +476,7 @@ const UserInputImpl = forwardRef<UserInputHandle, UserInputProps>(function UserI
     prevSelectedContextsRef.current = []
     resetTranscript()
     filesRef.current.clearAttachedFiles()
+    filesRef.current = { ...filesRef.current, attachedFiles: [] }
   }, [resetTranscript])
 
   const handleSubmit = useCallback(() => {
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.mount-send.test.tsx b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.mount-send.test.tsx
index 980cedebae4..618e6e87624 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.mount-send.test.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.mount-send.test.tsx
@@ -1450,6 +1450,46 @@ describe('useChat remount send recovery', () => {
     }
   )
 
+  it('sends the live queue head once without waiting for a render, after Stop settles', async () => {
+    state.postBehavior = 'task'
+    const { getResult } = renderUseChatInChat('chat-a')
+    await act(async () => {
+      void getResult().sendMessage('Original request')
+    })
+    await waitFor(() => state.postBodies.length === 1 && getResult().isSending)
+    let releaseStop = () => {}
+    const stopGate = new Promise<void>((resolve) => {
+      releaseStop = resolve
+    })
+    let stopRequested = false
+    vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+      if (String(input).includes('/api/copilot/chat/abort')) {
+        stopRequested = true
+        await stopGate
+      }
+      return fetchStub(input, init)
+    })
+    state.postBehavior = 'hang'
+    const beforeRender = getResult()
+    await act(async () => {
+      void beforeRender.sendMessage('Use the latest report')
+      void beforeRender.sendNow()
+      void beforeRender.sendNow()
+    })
+    try {
+      await waitFor(() => stopRequested)
+      expect(state.postBodies).toHaveLength(1)
+    } finally {
+      await act(async () => {
+        releaseStop()
+      })
+    }
+    await waitFor(() => state.postBodies.length === 2)
+    expect(state.postBodies[1].message).toBe('Use the latest report')
+    expect(allQueuedMessages()).toHaveLength(0)
+    expect(state.abortBodies).toHaveLength(1)
+  })
+
   it('captures Search levels independently for each queued turn and omits it from Build requests', async () => {
     state.postBehavior = 'task'
     const { getResult } = renderUseChat({ organizationId: 'org-a' }, 'assistant')
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
index 115b17c9c45..ed353410510 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
@@ -271,7 +271,7 @@ export interface UseChatReturn {
   reorderResources: (resources: MothershipResource[]) => void
   messageQueue: QueuedMessage[]
   removeFromQueue: (id: string) => void
-  sendNow: (id: string) => Promise<void>
+  sendNow: (id?: string) => Promise<void>
   editQueuedMessage: (id: string) => QueuedMessage | undefined
   cancelQueueEdit: () => void
   editingQueuedId: string | null
@@ -4784,9 +4784,9 @@ export function useChat(
   }, [])
 
   const sendQueuedMessageImmediately = useCallback(
-    async (id: string) => {
+    async (id?: string) => {
       const queue = useMothershipQueueStore.getState().queues[chatKeyRef.current]
-      const msg = queue?.find((queued) => queued.id === id)
+      const msg = id === undefined ? queue?.[0] : queue?.find((queued) => queued.id === id)
       if (!msg) return
       if (queuedMessageDispatchIdsRef.current.has(msg.id)) return
       const admissionPending = hasPendingChatAdmission()
@@ -4844,7 +4844,7 @@ export function useChat(
   )
 
   const sendNow = useCallback(
-    async (id: string) => {
+    async (id?: string) => {
       await sendQueuedMessageImmediately(id)
     },
     [sendQueuedMessageImmediately]
diff --git a/apps/sim/lib/mothership/request/application/controls-boundary.test.ts b/apps/sim/lib/mothership/request/application/controls-boundary.test.ts
index c2590c2434f..ea04cbcea52 100644
--- a/apps/sim/lib/mothership/request/application/controls-boundary.test.ts
+++ b/apps/sim/lib/mothership/request/application/controls-boundary.test.ts
@@ -81,7 +81,7 @@ describe('abort authorization before service signaling', () => {
       streamId: 'stream',
       chatId: 'chat',
       userId: 'actor',
-      timeoutMs: 3000,
+      timeoutMs: 6000,
     })
     expect(mocks.permissions).not.toHaveBeenCalled()
   })
diff --git a/apps/sim/lib/mothership/request/application/controls.ts b/apps/sim/lib/mothership/request/application/controls.ts
index 123aeb7a56c..b1f3ad07131 100644
--- a/apps/sim/lib/mothership/request/application/controls.ts
+++ b/apps/sim/lib/mothership/request/application/controls.ts
@@ -162,7 +162,7 @@ export const abortRun = defineAuthorizedChatUseCase({
       streamId,
       userId,
       chatId,
-      timeoutMs: 3000,
+      timeoutMs: 6000,
     }).catch((error) => {
       logger.warn('Stop saved; worker delivery awaits reconciliation', {
         streamId,
diff --git a/apps/sim/lib/mothership/request/session/explicit-abort.test.ts b/apps/sim/lib/mothership/request/session/explicit-abort.test.ts
index 0b82361c66a..d1283158600 100644
--- a/apps/sim/lib/mothership/request/session/explicit-abort.test.ts
+++ b/apps/sim/lib/mothership/request/session/explicit-abort.test.ts
@@ -2,7 +2,7 @@
  * @vitest-environment node
  */
 import { resetEnvMock, setEnv } from '@sim/testing'
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
 beforeAll(() => {
   setEnv({ COPILOT_API_KEY: 'sim-agent-key' })
@@ -27,6 +27,7 @@ import { AbortRequest } from '@/lib/mothership/generated/protocol'
 import { requestExplicitStreamAbort } from '@/lib/mothership/request/session/explicit-abort'
 
 describe('requestExplicitStreamAbort', () => {
+  afterEach(() => vi.useRealTimers())
   beforeEach(() => {
     vi.clearAllMocks()
     mockFetchGo.mockImplementation(async (_url, request) => {
@@ -65,14 +66,79 @@ describe('requestExplicitStreamAbort', () => {
     expect(Object.keys(body)).toEqual(['messageId'])
   })
 
-  it.each([true, false])('preserves the worker settlement acknowledgement: %s', async (settled) => {
-    mockFetchGo.mockResolvedValue(Response.json({ stopped: true, settled }))
+  it('waits for a worker that acknowledges Stop before it has finished settling', async () => {
+    vi.useFakeTimers()
+    let attempts = 0
+    mockFetchGo.mockImplementation(async () =>
+      Response.json({ stopped: true, settled: ++attempts >= 3 })
+    )
+    const stopping = requestExplicitStreamAbort({
+      streamId: '11111111-1111-4111-8111-111111111111',
+      userId: 'user-1',
+      timeoutMs: 6000,
+    })
+    await vi.runAllTimersAsync()
+    await expect(stopping).resolves.toEqual({ settled: true })
+    expect(mockFetchGo).toHaveBeenCalledTimes(3)
+    expect(new Set(mockFetchGo.mock.calls.map(([, request]) => request.body)).size).toBe(1)
+  })
+
+  it('returns unsettled at its deadline instead of allowing the next turn to overlap', async () => {
+    vi.useFakeTimers()
+    mockFetchGo.mockImplementation(async () => Response.json({ stopped: true, settled: false }))
+    const stopping = requestExplicitStreamAbort({
+      streamId: '11111111-1111-4111-8111-111111111111',
+      userId: 'user-1',
+      timeoutMs: 600,
+    })
+    await vi.runAllTimersAsync()
+    await expect(stopping).resolves.toEqual({ settled: false })
+    expect(mockFetchGo.mock.calls.length).toBeGreaterThan(1)
+    expect(mockFetchGo.mock.lastCall?.[1].signal.aborted).toBe(true)
+  })
+
+  it('returns immediately once the worker reports settlement', async () => {
+    mockFetchGo.mockResolvedValue(Response.json({ stopped: true, settled: true }))
     await expect(
       requestExplicitStreamAbort({
         streamId: '11111111-1111-4111-8111-111111111111',
         userId: 'user-1',
       })
-    ).resolves.toEqual({ settled })
+    ).resolves.toEqual({ settled: true })
+    expect(mockFetchGo).toHaveBeenCalledTimes(1)
+  })
+
+  it('keeps a real worker error visible instead of retrying it as a pending stop', async () => {
+    mockFetchGo.mockResolvedValue(new Response(null, { status: 503 }))
+    await expect(
+      requestExplicitStreamAbort({
+        streamId: '11111111-1111-4111-8111-111111111111',
+        userId: 'user-1',
+      })
+    ).rejects.toThrow('Explicit abort marker request failed: 503')
+    expect(mockFetchGo).toHaveBeenCalledTimes(1)
+  })
+
+  it('bounds a hanging settlement recheck with the same deadline', async () => {
+    vi.useFakeTimers()
+    mockFetchGo
+      .mockImplementationOnce(async () => Response.json({ settled: false }))
+      .mockImplementation(
+        (_url, request) =>
+          new Promise((_resolve, reject) => {
+            request.signal.addEventListener('abort', () => reject(request.signal.reason), {
+              once: true,
+            })
+          })
+      )
+    const stopping = requestExplicitStreamAbort({
+      streamId: '11111111-1111-4111-8111-111111111111',
+      userId: 'user-1',
+      timeoutMs: 600,
+    })
+    await vi.runAllTimersAsync()
+    await expect(stopping).resolves.toEqual({ settled: false })
+    expect(mockFetchGo).toHaveBeenCalledTimes(2)
   })
 
   it.each([{ stopped: true }, { settled: 'true' }, null])(
@@ -85,6 +151,7 @@ describe('requestExplicitStreamAbort', () => {
           userId: 'user-1',
         })
       ).resolves.toEqual({ settled: false })
+      expect(mockFetchGo).toHaveBeenCalledTimes(1)
     }
   )
 })
diff --git a/apps/sim/lib/mothership/request/session/explicit-abort.ts b/apps/sim/lib/mothership/request/session/explicit-abort.ts
index 4b5d335a6a2..2411e85349e 100644
--- a/apps/sim/lib/mothership/request/session/explicit-abort.ts
+++ b/apps/sim/lib/mothership/request/session/explicit-abort.ts
@@ -1,4 +1,6 @@
 import type { Context } from '@opentelemetry/api'
+import { sleep } from '@sim/utils/helpers'
+import { toRecordOrNull } from '@sim/utils/object'
 import {
   COPILOT_BILLING_PROTOCOL,
   COPILOT_BILLING_PROTOCOL_HEADER,
@@ -45,36 +47,41 @@ export async function requestExplicitStreamAbort(params: {
     timeoutMs
   )
 
+  let awaitingSettlement = false
   try {
     const mothershipBaseURL = await getMothershipBaseURL({ userId })
-    const response = await fetchGo(`${mothershipBaseURL}/api/streams/explicit-abort`, {
-      method: 'POST',
-      headers,
-      signal: controller.signal,
-      /** Sim authorizes the actor and canonical run before this service-authenticated signal. */
-      body: JSON.stringify(AbortRequest.parse({ messageId: streamId })),
-      otelContext,
-      spanName: 'sim → go /api/streams/explicit-abort',
-      operation: 'explicit_abort',
-      attributes: {
-        [TraceAttr.StreamId]: streamId,
-        ...(chatId ? { [TraceAttr.ChatId]: chatId } : {}),
-      },
-    })
-
-    if (!response.ok) {
-      throw new Error(`Explicit abort marker request failed: ${response.status}`)
-    }
-    /** The Go service does not report worker settlement; an empty acknowledgement cannot prove it. */
-    const text = await response.text()
-    const acknowledgement: unknown = text ? JSON.parse(text) : null
-    return {
-      settled:
-        acknowledgement !== null &&
-        typeof acknowledgement === 'object' &&
-        'settled' in acknowledgement &&
-        acknowledgement.settled === true,
+    while (!controller.signal.aborted) {
+      const response = await fetchGo(`${mothershipBaseURL}/api/streams/explicit-abort`, {
+        method: 'POST',
+        headers,
+        signal: controller.signal,
+        /** Sim authorizes the actor and canonical run before this service-authenticated signal. */
+        body: JSON.stringify(AbortRequest.parse({ messageId: streamId })),
+        otelContext,
+        spanName: 'sim → go /api/streams/explicit-abort',
+        operation: 'explicit_abort',
+        attributes: {
+          [TraceAttr.StreamId]: streamId,
+          ...(chatId ? { [TraceAttr.ChatId]: chatId } : {}),
+        },
+      })
+      if (!response.ok) {
+        throw new Error(`Explicit abort marker request failed: ${response.status}`)
+      }
+      const text = await response.text()
+      const acknowledgement = toRecordOrNull(text ? JSON.parse(text) : null)
+      /** Only an explicit pending acknowledgement can be polled; legacy empty replies prove nothing. */
+      if (acknowledgement?.settled !== false) {
+        return { settled: acknowledgement?.settled === true }
+      }
+      /** Stop is idempotent. Its first acknowledgement can precede worker cleanup. */
+      awaitingSettlement = true
+      await sleep(200)
     }
+    return { settled: false }
+  } catch (error) {
+    if (awaitingSettlement && controller.signal.aborted) return { settled: false }
+    throw error
   } finally {
     clearTimeout(timeout)
   }