fix(mothership): scope a desktop tool's Stop to its turn

A desktop tool outlives the chat view that started it, so its Stop belongs
to the turn, not the view: tools are keyed by the turn's stream id, which
survives reader replacement and remounts and differs between chats. Stop in
another chat leaves them running, and Stop from a view reopened on the turn
still reaches them.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/hooks/desktop-tool-lifetimes.ts

@@ -0,0 +1,28 @@
+import { LRUCache } from 'lru-cache'
+
+/**
+ * Turns whose desktop tools may still be running in this tab. A tool outlives the chat view that
+ * started it (and any stream reader), so the turn, not the view, owns its Stop. Bounded: a tool
+ * runs for minutes, far fewer turns than this.
+ */
+const turnStops = new LRUCache<string, AbortController>({ max: 64 })
+
+/**
+ * The lifetime of a desktop tool (a browser action, a local file read or import) started for a
+ * turn: only the user's Stop of that turn ends it. Replacing the stream reader, leaving the chat
+ * view, or stopping another chat's turn leaves it running to finish and report its own result.
+ */
+export function desktopToolLifetime(streamId: string): AbortSignal {
+  let stop = turnStops.get(streamId)
+  if (!stop) {
+    stop = new AbortController()
+    turnStops.set(streamId, stop)
+  }
+  return stop.signal
+}
+
+/** Cancels the desktop tools of a turn the user stopped, from whichever view started them. */
+export function stopDesktopTools(streamId: string, reason: string): void {
+  turnStops.get(streamId)?.abort(reason)
+  turnStops.delete(streamId)
+}

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

@@ -2212,7 +2212,7 @@ describe('useChat remount send recovery', () => {
       const toolSignal = lifetimeOf()
       if (!(toolSignal instanceof AbortSignal))
         throw new Error('The desktop action has no lifetime')
-      return { ...chat, toolSignal, replays }
+      return { ...chat, toolSignal, replays, streamId: () => streamId }
     }
 
     beforeEach(() => {
@@ -2264,6 +2264,36 @@ describe('useChat remount send recovery', () => {
       expect(toolSignal.aborted).toBe(true)
     })
 
+    it('keeps running when the user stops a turn in another chat', async () => {
+      const { toolSignal, navigate, getResult } = await startDesktopAction()
+      navigate('chat-other', { ...history, id: 'chat-other' })
+      await act(async () => {
+        void getResult().sendMessage('Something else')
+      })
+
+      await act(async () => {
+        await getResult().stopGeneration()
+      })
+
+      expect(toolSignal.aborted).toBe(false)
+    })
+
+    it('is still cancelled by Stop from the chat view reopened on its turn', async () => {
+      const { toolSignal, unmount, streamId } = await startDesktopAction()
+      unmount()
+      const reopened = renderUseChatInChat(chatId, {
+        ...history,
+        activeStreamId: streamId() ?? null,
+      })
+      await waitFor(() => reopened.getResult().isSending)
+
+      await act(async () => {
+        await reopened.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

@@ -91,6 +91,10 @@ import { isNativeFileTool, isUserLocalVfsToolCall } from '@/lib/mothership/tools
 import { initTerminalTransport } from '@/lib/terminal/transport'
 import { getQueryClient } from '@/app/_shell/providers/get-query-client'
 import { chatUrl } from '@/app/workspace/[workspaceId]/home/hooks/chat-url'
+import {
+  desktopToolLifetime,
+  stopDesktopTools,
+} from '@/app/workspace/[workspaceId]/home/hooks/desktop-tool-lifetimes'
 import { useFilePreviewController } from '@/app/workspace/[workspaceId]/home/hooks/preview'
 import {
   captureResourceActivityScope,
@@ -925,13 +929,6 @@ 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())
@@ -1586,7 +1583,7 @@ export function useChat(
       const options = {
         workspaceId,
         chatId: chatIdRef.current ?? selectedChatIdRef.current,
-        signal: (desktopToolStopRef.current ??= new AbortController()).signal,
+        signal: streamIdRef.current ? desktopToolLifetime(streamIdRef.current) : undefined,
       }
       /**
        * Dynamic on purpose: the local-filesystem executor only runs for desktop-local
@@ -2162,7 +2159,9 @@ export function useChat(
         shouldContinue?: () => boolean
       }
     ) => {
-      const browserToolSignal = (desktopToolStopRef.current ??= new AbortController()).signal
+      const browserToolSignal = streamIdRef.current
+        ? desktopToolLifetime(streamIdRef.current)
+        : undefined
       const activityTracker = getResourceActivityTracker(
         expectedGen ?? streamGenRef.current,
         options?.targetChatId
@@ -4434,8 +4433,7 @@ export function useChat(
         )
       }
       clearResourceActivity(stopActivityTracker, true)
-      desktopToolStopRef.current?.abort(USER_STOP_ABORT_REASON)
-      desktopToolStopRef.current = null
+      if (sid) stopDesktopTools(sid, USER_STOP_ABORT_REASON)
 
       // Establish the stream boundary immediately after synchronous activity
       // settlement. Native cancellation above is deliberately fire-and-forget,