fix(mothership): Stop reaches every desktop tool of the view, and results say what is known

Desktop tools now take one lifetime the view owns and only the user's Stop
ends, so Stop still reaches a tool that a replaced stream reader started. A
held-call 409 is final on the trimmed retry of an oversized report too. The
not-started result no longer asserts why nothing picked the call up, and a
local read the desktop claimed is described as started when its result is
lost.

Author: waleedlatif1

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

@@ -2246,6 +2246,24 @@ describe('useChat remount send recovery', () => {
       expect(toolSignal.aborted).toBe(false)
     })
 
+    it('is still cancelled by Stop after the stream was recovered', async () => {
+      const { toolSignal, replays, getResult } = await startDesktopAction()
+      Object.defineProperty(document, 'visibilityState', {
+        configurable: true,
+        get: () => 'visible',
+      })
+      await act(async () => {
+        document.dispatchEvent(new Event('visibilitychange'))
+      })
+      await waitFor(() => replays.length > 0)
+
+      await act(async () => {
+        await getResult().stopGeneration()
+      })
+
+      expect(toolSignal.aborted).toBe(true)
+    })
+
     it('is cancelled when the user stops the chat', async () => {
       const { toolSignal, getResult } = await startDesktopAction()
 

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

@@ -456,23 +456,6 @@ export async function waitForDetachedChatResolution(
 /** The abort reason of the user's Stop. */
 const USER_STOP_ABORT_REASON = 'user_stop:client_stopGeneration'
 
-/**
- * The lifetime a desktop tool (a browser action, a local file read or import) started from one
- * stream observes: only the user's Stop cancels it. Replacing the stream reader (the window
- * returning to view, a history reconnect) or leaving the chat view leaves it running, so it
- * finishes and reports its own result.
- */
-function desktopToolLifetime(streamSignal: AbortSignal | undefined): AbortSignal | undefined {
-  if (!streamSignal) return undefined
-  const lifetime = new AbortController()
-  const followStop = () => {
-    if (streamSignal.reason === USER_STOP_ABORT_REASON) lifetime.abort(USER_STOP_ABORT_REASON)
-  }
-  if (streamSignal.aborted) followStop()
-  else streamSignal.addEventListener('abort', followStop, { 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.
@@ -942,6 +925,13 @@ export function useChat(
   const reconnectExhaustedRecheckTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
   const abortControllerRef = useRef<AbortController | null>(null)
+  /**
+   * The lifetime of the desktop tools (browser actions, local file reads and imports) this view
+   * starts: only the user's Stop ends it. It belongs to no stream reader, so replacing the reader
+   * (the window returning to view, a history reconnect) or leaving the chat view leaves a running
+   * tool alone to finish and report, and a Stop still reaches tools a replaced reader started.
+   */
+  const desktopToolStopRef = useRef<AbortController | null>(null)
   const detachedChatResolutionControllersRef = useRef<Set<AbortController> | null>(null)
   const detachedChatResolutionControllers = (detachedChatResolutionControllersRef.current ??=
     new Set())
@@ -1596,7 +1586,7 @@ export function useChat(
       const options = {
         workspaceId,
         chatId: chatIdRef.current ?? selectedChatIdRef.current,
-        signal: desktopToolLifetime(abortControllerRef.current?.signal),
+        signal: (desktopToolStopRef.current ??= new AbortController()).signal,
       }
       /**
        * Dynamic on purpose: the local-filesystem executor only runs for desktop-local
@@ -2172,7 +2162,7 @@ export function useChat(
         shouldContinue?: () => boolean
       }
     ) => {
-      const browserToolSignal = desktopToolLifetime(abortControllerRef.current?.signal)
+      const browserToolSignal = (desktopToolStopRef.current ??= new AbortController()).signal
       const activityTracker = getResourceActivityTracker(
         expectedGen ?? streamGenRef.current,
         options?.targetChatId
@@ -4444,6 +4434,8 @@ export function useChat(
         )
       }
       clearResourceActivity(stopActivityTracker, true)
+      desktopToolStopRef.current?.abort(USER_STOP_ABORT_REASON)
+      desktopToolStopRef.current = null
 
       // Establish the stream boundary immediately after synchronous activity
       // settlement. Native cancellation above is deliberately fire-and-forget,

apps/sim/lib/mothership/request/tools/desktop-wait.ts

@@ -11,7 +11,7 @@ import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secr
 const logger = createLogger('CopilotDesktopToolWait')
 
 const DESKTOP_TOOL_NOT_STARTED_MESSAGE =
-  'Not run: this action never started, because nothing in the Sim desktop app picked it up (this chat is not open there). Nothing happened on the user’s computer. Do not retry it in this turn; tell the user to keep this chat open in the Sim desktop app, or to ask again later.'
+  'Not run: this action never started, because nothing in the Sim desktop app picked it up. Nothing happened on the user’s computer. Do not retry it in this turn; tell the user to keep this chat open in the Sim desktop app, or to ask again later.'
 
 /** The model-facing result of a desktop call that was never picked up. */
 export function desktopToolNotStarted(): { message: string; data: Record<string, unknown> } {

apps/sim/lib/mothership/request/tools/executor.test.ts

@@ -940,11 +940,37 @@ describe('watchdog completion provenance', () => {
     })
   })
 
+  it('says a local read the desktop claimed started before its result was lost', async () => {
+    const { toolCall, context, execContext } = createHungClient()
+    toolCall.name = 'read_local_file'
+    toolCall.params = { path: '/Users/me/notes.txt' }
+    completePendingAsyncToolCall.mockResolvedValueOnce(null)
+    mothershipAsyncRunsMockFns.mockGetAsyncToolCall.mockResolvedValueOnce({
+      toolCallId: toolCall.id,
+      claimedBy: 'desktop-files',
+    })
+
+    await failPendingToolCall(toolCall.id, context, execContext)
+
+    expect(toolCall.result).toEqual({
+      success: false,
+      output: {
+        error: expect.stringContaining('desktop app started this action'),
+        outcomeUnknown: true,
+        doNotRetry: true,
+      },
+    })
+  })
+
   it('does not claim a local read the server never saw picked up had started', async () => {
     const { toolCall, context, execContext } = createHungClient()
     toolCall.name = 'read_local_file'
     toolCall.params = { path: '/Users/me/notes.txt' }
     completePendingAsyncToolCall.mockResolvedValueOnce(null)
+    mothershipAsyncRunsMockFns.mockGetAsyncToolCall.mockResolvedValueOnce({
+      toolCallId: toolCall.id,
+      claimedBy: null,
+    })
 
     await failPendingToolCall(toolCall.id, context, execContext)
 

apps/sim/lib/mothership/request/tools/executor.ts

@@ -10,6 +10,7 @@ import type {
 } from '@/lib/mothership/async-runs/lifecycle'
 import {
   type CompleteAsyncToolCallInput,
+  getAsyncToolCall,
   markAsyncToolRunning,
   upsertAsyncToolCall,
 } from '@/lib/mothership/async-runs/repository'
@@ -451,11 +452,7 @@ export async function failPendingToolCall(
   }
   const message =
     failureMessage ??
-    (!desktopCall
-      ? TOOL_RESULT_LOST_MESSAGE
-      : isLocalReadToolCall(toolCall.execName ?? toolCall.name, toolCall.params)
-        ? DESKTOP_LOCAL_READ_RESULT_MISSING_MESSAGE
-        : DESKTOP_TOOL_RESULT_LOST_MESSAGE)
+    (desktopCall ? await desktopResultLostMessage(toolCall) : TOOL_RESULT_LOST_MESSAGE)
   await settleAbandonedToolCall(toolCall, context, execContext, {
     message,
     data: { error: message, outcomeUnknown: true, doNotRetry: true },
@@ -464,6 +461,20 @@ export async function failPendingToolCall(
   })
 }
 
+/**
+ * What a desktop call that lost its result tells the model. Only a local read can be in flight
+ * without a claim (an older desktop reads without claiming), and such a read may never have
+ * started; anything the desktop claimed did start.
+ */
+async function desktopResultLostMessage(toolCall: ToolCallState): Promise<string> {
+  if (!isLocalReadToolCall(toolCall.execName ?? toolCall.name, toolCall.params))
+    return DESKTOP_TOOL_RESULT_LOST_MESSAGE
+  const stored = await getAsyncToolCall(toolCall.id).catch(() => null)
+  return stored?.claimedBy
+    ? DESKTOP_TOOL_RESULT_LOST_MESSAGE
+    : DESKTOP_LOCAL_READ_RESULT_MISSING_MESSAGE
+}
+
 /**
  * Settles one abandoned tool locally once its durable failure is decided. With `unclaimedOnly`
  * it applies only while the call is still unclaimed and reports whether it did.

apps/sim/lib/mothership/tools/client/completion.test.ts

@@ -53,6 +53,23 @@ describe('client tool completion reporting', () => {
     expect(settled).toBe(true)
   })
 
+  it('stops at once when the trimmed retry of an oversized report learns the call is held', async () => {
+    vi.useFakeTimers()
+    fetchMock
+      .mockResolvedValueOnce(new Response(null, { status: 413 }))
+      .mockResolvedValueOnce(new Response(null, { status: 409 }))
+    let settled = false
+
+    void reportClientToolCompletion('tool-1', 'error', 'Failed', {
+      logs: 'x'.repeat(11 * 1024 * 1024),
+    }).then(() => {
+      settled = true
+    })
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(settled).toBe(true)
+  })
+
   it('uses a keepalive request with the exact terminal payload', async () => {
     await reportClientToolCompletionOnPageExit('tool-1', 'success', 'Browser action completed', {
       url: 'https://example.com',

apps/sim/lib/mothership/tools/client/completion.ts

@@ -32,6 +32,19 @@ async function fetchCompletion(input: RequestInfo | URL, init: RequestInit): Pro
   }
 }
 
+/**
+ * Whether a delivery attempt needs no retry: the server took it, or answered 409 because the
+ * desktop app holds the call and only its own result settles it.
+ */
+function isSettledDelivery(response: Response, toolCallId: string): boolean {
+  if (response.ok) return true
+  if (response.status !== 409) return false
+  logger.info('Client tool completion was not needed: another reporter holds the call', {
+    toolCallId,
+  })
+  return true
+}
+
 /**
  * Persist a client-executed tool result and wake the server-side async waiter.
  * Shared by workflow execution and desktop-native client tools.
@@ -71,14 +84,7 @@ export async function reportClientToolCompletion(
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
       const response = await send(body)
-      if (response.ok) return
-      if (response.status === 409) {
-        // The desktop app holds this call; its own result settles it, so retrying cannot help.
-        logger.info('Client tool completion was not needed: another reporter holds the call', {
-          toolCallId,
-        })
-        return
-      }
+      if (isSettledDelivery(response, toolCallId)) return
 
       if (isRecordLike(data) && bodySize > largePayloadThreshold) {
         const { logs: _logs, ...dataWithoutLogs } = data
@@ -96,7 +102,7 @@ export async function reportClientToolCompletion(
             data: dataWithoutLogs,
           })
         )
-        if (retryResponse.ok) return
+        if (isSettledDelivery(retryResponse, toolCallId)) return
         lastError = new Error(`Completion retry failed with status ${retryResponse.status}`)
       } else {
         lastError = new Error(`Completion failed with status ${response.status}`)