fix(mothership): keep closed-view reporting across stream recovery and never let a not-started report end a claimed call

Browser tools also follow a chat-view lifetime, so a tool started on a
reader that recovery replaced is still ended, and reported, as a closed view
when the view unmounts. A report that says the call never started can now
settle only an unclaimed call; one the desktop claimed is settled only by
its own result.

Author: waleedlatif1

apps/sim/app/api/copilot/confirm/route.ts

@@ -317,6 +317,17 @@ export const POST = withRouteHandler((req: NextRequest) => {
           span.setAttribute(TraceAttr.CopilotConfirmOutcome, CopilotConfirmOutcome.ToolCallNotFound)
           return createNotFoundResponse('Running client tool call not found')
         }
+        // A reporter that says the call never started (a stale replay, a closed view) cannot speak
+        // for a call the desktop claimed: only the claim's own result may settle it.
+        if (
+          isNativeClientTool &&
+          isPlainRecord(data) &&
+          data.notStarted === true &&
+          existing.status !== ASYNC_TOOL_STATUS.pending
+        ) {
+          span.setAttribute(TraceAttr.CopilotConfirmOutcome, CopilotConfirmOutcome.ToolCallNotFound)
+          return createNotFoundResponse('Pending client tool call not found')
+        }
 
         let effectiveStatus = status
         let executionId = submittedExecutionId

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

@@ -2134,6 +2134,23 @@ describe('useChat remount send recovery', () => {
       expect(toolSignal.aborted).toBe(false)
     })
 
+    it('still ends as a closed chat view when the view unmounts after a stream recovery', async () => {
+      const { toolSignal, replays, unmount } = await startBrowserAction()
+      Object.defineProperty(document, 'visibilityState', {
+        configurable: true,
+        get: () => 'visible',
+      })
+      await act(async () => {
+        document.dispatchEvent(new Event('visibilitychange'))
+      })
+      await waitFor(() => replays.length > 0)
+
+      unmount()
+
+      expect(toolSignal.aborted).toBe(true)
+      expect(toolSignal.reason).toBe(CHAT_VIEW_CLOSED_ABORT_REASON)
+    })
+
     it('ends as a closed chat view, not a Stop, when the chat view unmounts', async () => {
       const { toolSignal, unmount } = await startBrowserAction()
 

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

@@ -468,19 +468,25 @@ 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.
+ * returning to view, a history reconnect) leaves an in-flight action running. The chat view
+ * closing ends it as a closed view, which still reports its outcome, even when a later reader
+ * replaced the one that started it. A Stop ends it silently.
  */
-function browserToolLifetime(streamSignal: AbortSignal | undefined): AbortSignal | undefined {
-  if (!streamSignal) return undefined
+function browserToolLifetime(
+  streamSignal: AbortSignal | undefined,
+  chatViewSignal: AbortSignal | undefined
+): AbortSignal {
   const lifetime = new AbortController()
-  const follow = () => {
-    const reason: unknown = streamSignal.reason
+  const followStream = () => {
+    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 })
+  const followChatView = () => lifetime.abort(CHAT_VIEW_CLOSED_ABORT_REASON)
+  if (streamSignal?.aborted) followStream()
+  else streamSignal?.addEventListener('abort', followStream, { once: true })
+  if (chatViewSignal?.aborted) followChatView()
+  else chatViewSignal?.addEventListener('abort', followChatView, { once: true })
   return lifetime.signal
 }
 
@@ -953,6 +959,8 @@ export function useChat(
   const reconnectExhaustedRecheckTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
   const abortControllerRef = useRef<AbortController | null>(null)
+  /** Ends when this chat view unmounts, whichever stream reader started a tool. */
+  const chatViewLifetimeRef = useRef<AbortController | null>(null)
   const detachedChatResolutionControllersRef = useRef<Set<AbortController> | null>(null)
   const detachedChatResolutionControllers = (detachedChatResolutionControllersRef.current ??=
     new Set())
@@ -2183,7 +2191,10 @@ export function useChat(
         shouldContinue?: () => boolean
       }
     ) => {
-      const browserToolSignal = browserToolLifetime(abortControllerRef.current?.signal)
+      const browserToolSignal = browserToolLifetime(
+        abortControllerRef.current?.signal,
+        chatViewLifetimeRef.current?.signal
+      )
       const activityTracker = getResourceActivityTracker(
         expectedGen ?? streamGenRef.current,
         options?.targetChatId
@@ -4997,6 +5008,12 @@ export function useChat(
     remoteActiveStreamId,
   ])
 
+  useEffect(() => {
+    const chatViewLifetime = new AbortController()
+    chatViewLifetimeRef.current = chatViewLifetime
+    return () => chatViewLifetime.abort(CHAT_VIEW_CLOSED_ABORT_REASON)
+  }, [])
+
   useEffect(() => {
     return () => {
       cancelActiveStreamRecovery()

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

@@ -256,7 +256,7 @@ describe('pendingToolWaitBudgetMs', () => {
       pendingToolWaitBudgetMs({
         name: 'terminal',
         status: 'executing',
-        params: { operation: 'run', args: { command: 'npm install', waitSeconds: 120 } },
+        params: { operation: 'run', args: { command: 'bun install', waitSeconds: 120 } },
       })
     ).toBeGreaterThan(120_000)
     expect(

apps/sim/lib/mothership/tools/client/desktop-tool-pickup.integration.ts

@@ -217,4 +217,33 @@ describe.runIf(Boolean(redisUrl))('a desktop tool call nobody picks up', () => {
     },
     TURN_WAIT_MS + 10_000
   )
+
+  it(
+    'never lets a stale "not started" report end a call the desktop is running',
+    async () => {
+      const { toolCallId, answer } = await agentCalls('terminal', {
+        operation: 'run',
+        args: { command: 'bun run test' },
+      })
+      expect((await desktopClaims(toolCallId)).status).toBe(200)
+
+      const staleReport = await post(confirmPOST, '/api/copilot/confirm', {
+        toolCallId,
+        status: 'error',
+        message: 'Not run: delivered too late',
+        data: { error: 'Not run: delivered too late', notStarted: true },
+      })
+      const realResult = await post(confirmPOST, '/api/copilot/confirm', {
+        toolCallId,
+        status: 'success',
+        message: 'Done',
+        data: { output: 'tests passed' },
+      })
+
+      expect(staleReport.ok).toBe(false)
+      expect(realResult.status).toBe(200)
+      expect(await answer).toMatchObject({ status: 'success' })
+    },
+    TURN_WAIT_MS + 10_000
+  )
 })

apps/sim/lib/mothership/tools/client/terminal-tool-execution.test.ts

@@ -58,7 +58,7 @@ describe('terminal client execution', () => {
 
     executeTerminalToolOnClient(
       'terminal-stale',
-      { operation: 'run', args: { command: 'npm test' } },
+      { operation: 'run', args: { command: 'bun run test' } },
       'chat-1',
       emittedAt
     )