fix(mothership): fail unclaimed desktop calls fast and stop dropping them silently

A desktop call reaches the user's machine only through the chat view showing
that chat, so one issued while the user is elsewhere was never claimed and
the turn waited out a 90-160 s watchdog that called it hung. After a 15 s
pickup grace the still-pending call is now settled as never started with the
inverse of the desktop's claim (pending -> failed), so a late claim is
refused and a call claimed in time keeps its full budget.

The single 'hung and was abandoned' result becomes two: notStarted (safe to
retry) for an unclaimed call, and outcomeUnknown/doNotRetry for a call that
started and lost its result. A terminal run's server budget now follows the
wait the desktop holds it for.

In the renderer, a browser action whose chat view closes reports what became
of it instead of returning silently, recovering the stream when the window
returns to view no longer aborts running actions, and a terminal call
delivered too late is reported as not started instead of skipped.

Author: waleedlatif1

apps/desktop/src/main/terminal/index.ts

@@ -14,11 +14,10 @@ import { homedir } from 'node:os'
 import type { TerminalShortcutCommand } from '@sim/desktop-bridge'
 import { createLogger } from '@sim/logger'
 import {
-  DEFAULT_RUN_WAIT_MS,
   isTerminalControlKey,
   MAX_INPUT_KEYS,
-  MAX_RUN_WAIT_MS,
   MAX_TOOL_OUTPUT_CHARS,
+  resolveRunWaitMs,
   type TerminalCommandEvent,
   type TerminalControlKey,
   type TerminalCwdResult,
@@ -109,14 +108,6 @@ const HANDOFF_MAX_MS = 12 * 60 * 60 * 1000
  */
 const HANDOFF_SETTLE_MS = 5_000
 
-/** How long to hold the turn before handing a still-running command back. */
-function resolveWaitMs(waitSeconds: number | undefined): number {
-  const requested = Number(waitSeconds)
-  return Number.isFinite(requested) && requested > 0
-    ? Math.min(requested * 1000, MAX_RUN_WAIT_MS)
-    : DEFAULT_RUN_WAIT_MS
-}
-
 function elideOutput(value: string): { text: string; truncated: boolean } {
   return elide(value, MAX_TOOL_OUTPUT_CHARS)
 }
@@ -1097,7 +1088,7 @@ export class TerminalService {
     const handle = await startRun(session, command, terminal.currentCwd, terminal.env)
     if ('error' in handle) throw new TerminalError('SPAWN_FAILED', handle.error)
 
-    const waitMs = resolveWaitMs(args.waitSeconds)
+    const waitMs = resolveRunWaitMs(args.waitSeconds)
     const outcome = await awaitRun(handle, waitMs)
     if (outcome.done) {
       await closeRunWindow(handle, terminal.env)
@@ -1149,7 +1140,7 @@ export class TerminalService {
       )
     }
 
-    return session.runCommand(command, toolCallId, resolveWaitMs(args.waitSeconds))
+    return session.runCommand(command, toolCallId, resolveRunWaitMs(args.waitSeconds))
   }
 
   private spawn(

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.dom.test.tsx

@@ -21,13 +21,15 @@
 
 import { act, type ReactNode, StrictMode, useEffect, useState } from 'react'
 import { authClientMock, authClientMockFns } from '@sim/testing/mocks/auth-client.mock'
+import { libDesktopMock, libDesktopMockFns } from '@sim/testing/mocks/lib-desktop.mock'
 import { nextNavigationMock, nextNavigationMockFns } from '@sim/testing/mocks/next-navigation.mock'
 import { sleep } from '@sim/utils/helpers'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockRequestJson, mockExecuteWorkflow } = vi.hoisted(() => ({
+const { mockRequestJson, mockExecuteWorkflow, mockExecuteBrowserToolOnClient } = vi.hoisted(() => ({
+  mockExecuteBrowserToolOnClient: vi.fn(),
   mockRequestJson: vi.fn(),
   mockExecuteWorkflow:
     vi.fn<
@@ -44,6 +46,11 @@ vi.mock('@/app/workspace/[workspaceId]/providers/feature-flags-provider', () =>
 }))
 
 vi.mock('next/navigation', () => nextNavigationMock)
+vi.mock('@/lib/desktop', () => libDesktopMock)
+vi.mock('@/lib/mothership/tools/client/browser-tool-execution', () => ({
+  CHAT_VIEW_CLOSED_ABORT_REASON: 'chat_view_closed',
+  executeBrowserToolOnClient: mockExecuteBrowserToolOnClient,
+}))
 vi.mock('@/lib/auth/auth-client', () => authClientMock)
 vi.unmock('@/stores/execution/store')
 vi.unmock('@/stores/terminal')
@@ -76,6 +83,7 @@ import { MothershipHandoffStorage } from '@/lib/core/utils/browser-storage'
 import { MOTHERSHIP_STREAM_REPLAY_HEADER } from '@/lib/mothership/constants'
 import type { MothershipStreamV1EventEnvelope } from '@/lib/mothership/generated/mothership-stream-v1'
 import { getChatResourceSelectionId } from '@/lib/mothership/resources/types'
+import { CHAT_VIEW_CLOSED_ABORT_REASON } from '@/lib/mothership/tools/client/browser-tool-execution'
 import { collectCitedMessageSources } from '@/app/workspace/[workspaceId]/home/components/message-content/message-sources'
 import {
   readQueuedSendHandoffState,
@@ -2039,4 +2047,100 @@ describe('useChat remount send recovery', () => {
         ?.messages.map((message) => message.id)
     ).toEqual(['saved-user', 'saved-assistant'])
   })
+  describe('a desktop browser action in flight', () => {
+    const chatId = 'chat-browser-action'
+    const history: MothershipChatHistory = {
+      id: chatId,
+      mode: 'agent',
+      title: 'Browser action',
+      messages: [],
+      activeStreamId: null,
+      resources: [],
+    }
+
+    /** Opens a turn whose stream delivers one desktop browser call and stays open. */
+    async function startBrowserAction() {
+      let streamId: string | undefined
+      const replays: string[] = []
+      mockRequestJson.mockImplementation((contract: AnyApiRouteContract) =>
+        Promise.resolve(
+          contract.path === '/api/mothership/chats/[chatId]'
+            ? { chat: { ...history, activeStreamId: streamId ?? null } }
+            : { chats: [] }
+        )
+      )
+      vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = String(input)
+        if (url.includes('/api/mothership/chat/stream')) replays.push(url)
+        if (url !== '/api/mothership/chat' || init?.method !== 'POST') {
+          return fetchStub(input, init)
+        }
+        streamId = JSON.parse(String(init.body)).userMessageId
+        const call: MothershipStreamV1EventEnvelope = {
+          v: 1,
+          seq: 1,
+          ts: new Date().toISOString(),
+          type: 'tool',
+          stream: { streamId: streamId ?? '' },
+          payload: {
+            phase: 'call',
+            executor: 'client',
+            mode: 'async',
+            toolName: 'browser_list_tabs',
+            toolCallId: 'browser-call',
+            arguments: {},
+          },
+        }
+        return new Response(
+          new ReadableStream<Uint8Array>({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(call)}\n\n`))
+            },
+          }),
+          { headers: { 'Content-Type': 'text/event-stream', 'x-mothership-chat-id': chatId } }
+        )
+      })
+      const chat = renderUseChatInChat(chatId, history)
+      await act(async () => {
+        void chat.getResult().sendMessage('List my tabs')
+      })
+      await waitFor(() => mockExecuteBrowserToolOnClient.mock.calls.length === 1)
+      const toolSignal = mockExecuteBrowserToolOnClient.mock.calls[0]?.[5]
+      if (!(toolSignal instanceof AbortSignal))
+        throw new Error('The browser action has no lifetime')
+      return { ...chat, toolSignal, replays }
+    }
+
+    beforeEach(() => {
+      libDesktopMockFns.mockIsDesktopApp.mockReturnValue(true)
+    })
+
+    afterEach(() => {
+      libDesktopMockFns.mockIsDesktopApp.mockReset()
+    })
+
+    it('keeps running when the window returns to view and the stream is recovered', async () => {
+      const { toolSignal, replays } = await startBrowserAction()
+
+      Object.defineProperty(document, 'visibilityState', {
+        configurable: true,
+        get: () => 'visible',
+      })
+      await act(async () => {
+        document.dispatchEvent(new Event('visibilitychange'))
+      })
+      await waitFor(() => replays.length > 0)
+
+      expect(toolSignal.aborted).toBe(false)
+    })
+
+    it('ends as a closed chat view, not a Stop, when the chat view unmounts', async () => {
+      const { toolSignal, unmount } = await startBrowserAction()
+
+      unmount()
+
+      expect(toolSignal.aborted).toBe(true)
+      expect(toolSignal.reason).toBe(CHAT_VIEW_CLOSED_ABORT_REASON)
+    })
+  })
 })

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts

@@ -78,7 +78,10 @@ import {
   reorderStoredChatResources,
   sanitizeChatResources,
 } from '@/lib/mothership/resources/types'
-import { executeBrowserToolOnClient } from '@/lib/mothership/tools/client/browser-tool-execution'
+import {
+  CHAT_VIEW_CLOSED_ABORT_REASON,
+  executeBrowserToolOnClient,
+} from '@/lib/mothership/tools/client/browser-tool-execution'
 import {
   bindRunToolToExecution,
   executeRunToolOnClient,
@@ -452,6 +455,35 @@ export async function waitForDetachedChatResolution(
   }
 }
 
+/** Aborts that only replace the stream reader; the turn and its running tools carry on. */
+const SUPERSEDED_RECOVERY_ABORT_REASON = 'superseded_recovery'
+const SUPERSEDED_HISTORY_RECONNECT_ABORT_REASON = 'superseded_chat_history_reconnect'
+const REPLACED_RECOVERY_SUBJECT_ABORT_REASON = 'replaced_by_new_recovery_subject'
+const READER_REPLACEMENT_ABORT_REASONS: ReadonlySet<unknown> = new Set([
+  SUPERSEDED_RECOVERY_ABORT_REASON,
+  SUPERSEDED_HISTORY_RECONNECT_ABORT_REASON,
+  REPLACED_RECOVERY_SUBJECT_ABORT_REASON,
+])
+const UNMOUNT_ABORT_REASON = 'unmount:client_cleanup'
+
+/**
+ * The lifetime a browser tool started from one stream observes. Replacing the reader (a window
+ * returning to view, a history reconnect) leaves an in-flight action running; an unmount ends it
+ * as a closed chat view, which still reports its outcome; a Stop ends it silently.
+ */
+function browserToolLifetime(streamSignal: AbortSignal | undefined): AbortSignal | undefined {
+  if (!streamSignal) return undefined
+  const lifetime = new AbortController()
+  const follow = () => {
+    const reason: unknown = streamSignal.reason
+    if (READER_REPLACEMENT_ABORT_REASONS.has(reason)) return
+    lifetime.abort(reason === UNMOUNT_ABORT_REASON ? CHAT_VIEW_CLOSED_ABORT_REASON : reason)
+  }
+  if (streamSignal.aborted) follow()
+  else streamSignal.addEventListener('abort', follow, { once: true })
+  return lifetime.signal
+}
+
 /**
  * Runs a browser tool on the desktop client. The agent's tab reaches the
  * resource strip through the desktop tab list, so nothing is opened here.
@@ -1014,7 +1046,7 @@ export function useChat(
   const cancelActiveStreamRecovery = useCallback(() => {
     const recovery = activeStreamReturnRecoveryRef.current
     if (!recovery) return
-    recovery.controller.abort('superseded_recovery')
+    recovery.controller.abort(SUPERSEDED_RECOVERY_ABORT_REASON)
     activeStreamReturnRecoveryRef.current = null
   }, [])
 
@@ -2073,7 +2105,7 @@ export function useChat(
       cancelActiveStreamRecovery()
       const replacedController = abortControllerRef.current
       if (replacedController && !replacedController.signal.aborted) {
-        replacedController.abort('superseded_chat_history_reconnect')
+        replacedController.abort(SUPERSEDED_HISTORY_RECONNECT_ABORT_REASON)
       }
       cancelActiveStreamReader()
       abortControllerRef.current = abortController
@@ -2151,7 +2183,7 @@ export function useChat(
         shouldContinue?: () => boolean
       }
     ) => {
-      const streamAbortSignal = abortControllerRef.current?.signal
+      const browserToolSignal = browserToolLifetime(abortControllerRef.current?.signal)
       const activityTracker = getResourceActivityTracker(
         expectedGen ?? streamGenRef.current,
         options?.targetChatId
@@ -2172,7 +2204,7 @@ export function useChat(
         eventTs?: string
       ) => {
         const scopeId = activityScopeId()
-        startClientBrowserTool(toolCallId, toolName, toolArgs, scopeId, eventTs, streamAbortSignal)
+        startClientBrowserTool(toolCallId, toolName, toolArgs, scopeId, eventTs, browserToolSignal)
       }
       const startClientTerminalToolForStream = (
         toolCallId: string,
@@ -2965,7 +2997,7 @@ export function useChat(
         return existingRecovery.promise
       }
       if (existingRecovery) {
-        existingRecovery.controller.abort('replaced_by_new_recovery_subject')
+        existingRecovery.controller.abort(REPLACED_RECOVERY_SUBJECT_ABORT_REASON)
         activeStreamReturnRecoveryRef.current = null
       }
 
@@ -3005,7 +3037,7 @@ export function useChat(
 
         const replacedController = abortControllerRef.current
         if (replacedController && !replacedController.signal.aborted) {
-          replacedController.abort('superseded_recovery')
+          replacedController.abort(SUPERSEDED_RECOVERY_ABORT_REASON)
         }
 
         const replacedReader = streamReaderRef.current
@@ -3895,7 +3927,7 @@ export function useChat(
         const sendWasAborted =
           (err instanceof Error && err.name === 'AbortError') || sendAbortSignal?.aborted === true
         if (sendWasAborted) {
-          if (sendAbortSignal?.reason === 'unmount:client_cleanup' && !sendReachedServer) {
+          if (sendAbortSignal?.reason === UNMOUNT_ABORT_REASON && !sendReachedServer) {
             /* A remount ran the unmount cleanup before this send's response
                arrived — a chat-route `key` change, or StrictMode's dev
                double-mount. Nothing was rendered from it, so withdraw the
@@ -4971,7 +5003,7 @@ export function useChat(
       clearQueueDispatchState()
       streamGenRef.current++
       cancelActiveStreamReader()
-      abortControllerRef.current?.abort('unmount:client_cleanup')
+      abortControllerRef.current?.abort(UNMOUNT_ABORT_REASON)
       abortControllerRef.current = null
       for (const controller of detachedChatResolutionControllers) {
         controller.abort('unmount:detached_chat_resolution')

apps/sim/lib/mothership/constants.ts

@@ -66,6 +66,18 @@ export const CHAT_RUN_DEADLINE_MS = 3_600_000
  */
 export const COPILOT_WORKFLOW_TOOL_CLIENT_GRACE_MS = 30_000
 
+/**
+ * How long a desktop tool call (browser, terminal, local import) waits for the desktop app to
+ * claim it before it fails as never started.
+ *
+ * Same cause as the workflow grace: only the chat view showing this chat starts the call, so a
+ * call issued while the user is on another chat or page is claimed by nobody. A live view claims
+ * within a second or two (stream frame -> IPC -> authorize), and there is no server fallback to
+ * run instead, so the call fails with a "not started, safe to retry" result rather than parking
+ * until a watchdog calls it hung.
+ */
+export const DESKTOP_TOOL_PICKUP_GRACE_MS = 15_000
+
 /** SessionStorage key for persisting active stream metadata across page reloads. */
 export const STREAM_STORAGE_KEY = 'copilot_active_stream'
 

apps/sim/lib/mothership/request/handlers/tool.ts

@@ -11,6 +11,7 @@ import { upsertAsyncToolCall } from '@/lib/mothership/async-runs/repository'
 import {
   CLIENT_TOOL_RESULT_TIMEOUT_MS,
   COPILOT_WORKFLOW_TOOL_CLIENT_GRACE_MS,
+  DESKTOP_TOOL_PICKUP_GRACE_MS,
 } from '@/lib/mothership/constants'
 import {
   MothershipStreamV1AsyncToolRecordStatus,
@@ -32,6 +33,10 @@ import { markToolResultSeen, wasToolResultSeen } from '@/lib/mothership/request/
 import { setTerminalToolCallState } from '@/lib/mothership/request/tool-call-state'
 import { waitForClientToolCompletion } from '@/lib/mothership/request/tools/client'
 import { sealClientToolContext } from '@/lib/mothership/request/tools/client-completion-seal.server'
+import {
+  isDesktopPickupTool,
+  waitForDesktopToolPickup,
+} from '@/lib/mothership/request/tools/desktop-pickup'
 import { executeToolAndReport } from '@/lib/mothership/request/tools/executor'
 import {
   runGatedToolExecution,
@@ -938,6 +943,16 @@ async function dispatchToolExecution(
             return race.signal ?? errorCompletion('Tool completion missing')
           }
           completion = race.completion ?? null
+        } else if (isDesktopPickupTool(toolName)) {
+          completion = await waitForDesktopToolPickup({
+            toolCallId,
+            runId: context.runId,
+            userId: execContext.userId,
+            timeoutMs,
+            graceMs: DESKTOP_TOOL_PICKUP_GRACE_MS,
+            abortSignal: options.abortSignal,
+            registry: execContext.resolvedSecretTraceRegistry,
+          })
         } else {
           completion = await waitForClientToolCompletion({
             toolCallId,