fix(mothership): keep local file tools running when the chat view changes (#8666)

* fix(mothership): keep local file tools running when the chat view changes

Local file reads and imports now take the same Stop-only lifetime as browser
actions: a history reconnect, a stream recovery or leaving the chat view
leaves them running so they finish and report, and only the user's Stop
cancels them.

The desktop-tool classifier in client-executed-tools.ts is removed in favour
of the single one in tools/desktop-tools.ts.

When the desktop app holds a call, confirm now answers 409 to any other
reporter (a stale replay, a lost race against the claim), and the client
treats 409 as final instead of retrying a 404 five times.

The not-started results now tell the model what it can act on: the action
never started; don't retry it in this turn; ask the user to keep the chat
open in the Sim desktop app. A local read the server cannot see picked up
is no longer described as started.

The obsolete admission probe script is deleted. Nothing ran it, it no longer
type-checked against the repository API, and the integration suites cover
the same admission behaviour against real Postgres.

* 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.

* 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.

* fix(mothership): hold a turn's Stop only while its desktop tools run

Replace the bounded LRU of turn controllers with leases: each running
browser action or local file tool holds its turn's Stop until it settles,
so a live turn can never be evicted and settled turns leave nothing behind.

* test(mothership): import the lease registry by its absolute path

Author: waleedlatif1

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

@@ -165,7 +165,7 @@ describe('Copilot Confirm API Route', () => {
       })
     )
 
-    expect(response.status).toBe(404)
+    expect(response.status).toBe(409)
     expect(completeAsyncToolCall).not.toHaveBeenCalled()
     expect(detachAsyncToolCall).not.toHaveBeenCalled()
     expect(encryptSecret).not.toHaveBeenCalled()
@@ -233,8 +233,10 @@ describe('Copilot Confirm API Route', () => {
         })
       )
 
-      expect(response.status).toBe(404)
-      expect(await response.json()).toEqual({ error: 'Pending client tool call not found' })
+      expect(response.status).toBe(409)
+      expect(await response.json()).toEqual({
+        error: 'The desktop app holds this tool call; only its own result settles it',
+      })
       expect(completePendingAsyncToolCall).toHaveBeenCalledOnce()
       expect(completeClaimedAsyncToolCall).not.toHaveBeenCalled()
       expect(completeAsyncToolCall).not.toHaveBeenCalled()
@@ -300,7 +302,7 @@ describe('Copilot Confirm API Route', () => {
       })
     )
 
-    expect(response.status).toBe(404)
+    expect(response.status).toBe(409)
     expect(completeClaimedAsyncToolCall).toHaveBeenCalledWith(expect.any(Object), 'desktop-browser')
     expect(publishToolConfirmation).not.toHaveBeenCalled()
   })

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

@@ -84,6 +84,18 @@ function acknowledgeSettledToolCall(
   return createConfirmationResponse(toolCallId, settledStatus, 'Tool call was already settled')
 }
 
+/**
+ * A desktop call this report may not settle: the desktop app holds it under its claim (or a
+ * report raced that claim and lost), so only the claim's own result settles it. Final, not
+ * retryable: the reporter stops.
+ */
+function heldByAnotherReporterResponse(): NextResponse {
+  return NextResponse.json(
+    { error: 'The desktop app holds this tool call; only its own result settles it' },
+    { status: 409 }
+  )
+}
+
 /** Atomically finalize or detach a client tool before publishing its wakeup event. */
 async function updateToolCallStatus(
   existing: NonNullable<Awaited<ReturnType<typeof getAsyncToolCall>>>,
@@ -272,7 +284,11 @@ export const POST = withRouteHandler((req: NextRequest) => {
         const isMutableClientToolCall = isWorkflowTool
           ? isWorkflowToolExecutionClaimable(existing.status, existing.permissionDecision)
           : existing.status === ASYNC_TOOL_STATUS.running || isPreclaimNativeTerminalOutcome
-        if ((isNativeClientTool || isWorkflowTool) && !isMutableClientToolCall) {
+        if (isNativeClientTool && !isMutableClientToolCall) {
+          span.setAttribute(TraceAttr.CopilotConfirmOutcome, CopilotConfirmOutcome.ToolCallNotFound)
+          return heldByAnotherReporterResponse()
+        }
+        if (isWorkflowTool && !isMutableClientToolCall) {
           span.setAttribute(TraceAttr.CopilotConfirmOutcome, CopilotConfirmOutcome.ToolCallNotFound)
           return createNotFoundResponse('Running client tool call not found')
         }
@@ -285,7 +301,7 @@ export const POST = withRouteHandler((req: NextRequest) => {
           existing.status !== ASYNC_TOOL_STATUS.pending
         ) {
           span.setAttribute(TraceAttr.CopilotConfirmOutcome, CopilotConfirmOutcome.ToolCallNotFound)
-          return createNotFoundResponse('Pending client tool call not found')
+          return heldByAnotherReporterResponse()
         }
 
         let effectiveStatus = status
@@ -422,7 +438,7 @@ export const POST = withRouteHandler((req: NextRequest) => {
 
         if (reconciledOutcome === 'conflict' && isPreclaimNativeTerminalOutcome) {
           span.setAttribute(TraceAttr.CopilotConfirmOutcome, CopilotConfirmOutcome.ToolCallNotFound)
-          return createNotFoundResponse('Pending client tool call not found')
+          return heldByAnotherReporterResponse()
         }
 
         if (reconciledOutcome !== 'updated') {

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

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest'
+import {
+  leaseDesktopTool,
+  stopDesktopTools,
+} from '@/app/workspace/[workspaceId]/home/hooks/desktop-tool-lifetimes'
+
+describe('desktop tool leases', () => {
+  it('cancels every running tool of the stopped turn and no other turn', () => {
+    const first = leaseDesktopTool('turn-a')
+    const second = leaseDesktopTool('turn-a')
+    const other = leaseDesktopTool('turn-b')
+
+    stopDesktopTools('turn-a', 'user_stop')
+
+    expect(first.signal.aborted).toBe(true)
+    expect(second.signal.aborted).toBe(true)
+    expect(first.signal.reason).toBe('user_stop')
+    expect(other.signal.aborted).toBe(false)
+    other.release()
+  })
+
+  it('keeps a turn reachable by Stop while any of its tools still runs', () => {
+    const settled = leaseDesktopTool('turn-c')
+    const running = leaseDesktopTool('turn-c')
+    for (let turn = 0; turn < 500; turn++) leaseDesktopTool(`busy-${turn}`).release()
+
+    settled.release()
+    settled.release()
+    stopDesktopTools('turn-c', 'user_stop')
+
+    expect(running.signal.aborted).toBe(true)
+  })
+
+  it('gives a turn whose tools all settled a fresh lifetime for its next tool', () => {
+    const settled = leaseDesktopTool('turn-d')
+    settled.release()
+    stopDesktopTools('turn-d', 'user_stop')
+
+    const next = leaseDesktopTool('turn-d')
+
+    expect(settled.signal.aborted).toBe(false)
+    expect(next.signal).not.toBe(settled.signal)
+    expect(next.signal.aborted).toBe(false)
+    next.release()
+  })
+
+  it('does not let a tool that settles after Stop release a newer lease on the turn', () => {
+    const stopped = leaseDesktopTool('turn-e')
+    stopDesktopTools('turn-e', 'user_stop')
+    const next = leaseDesktopTool('turn-e')
+
+    stopped.release()
+    stopDesktopTools('turn-e', 'user_stop')
+
+    expect(next.signal.aborted).toBe(true)
+  })
+})

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

@@ -0,0 +1,51 @@
+/** The desktop tools of one turn that are still running in this tab, and the Stop that ends them. */
+interface RunningTurnTools {
+  stop: AbortController
+  running: number
+}
+
+/**
+ * Turns with a desktop tool still running in this tab, keyed by the turn's stream id. A tool
+ * outlives the chat view that started it (and any stream reader), so the turn, not the view, owns
+ * its Stop. A turn is held only while one of its tools runs: each tool releases it as it settles.
+ */
+const runningTurns = new Map<string, RunningTurnTools>()
+
+/** A running desktop tool's hold on its turn. */
+interface DesktopToolLease {
+  /** Aborted only by the user's Stop of the turn. */
+  signal: AbortSignal
+  /** Called once when the tool settles. */
+  release(): void
+}
+
+/**
+ * Starts a desktop tool (a browser action, a local file read or import) for a turn. Only the
+ * user's Stop of that turn cancels 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 leaseDesktopTool(streamId: string): DesktopToolLease {
+  let turn = runningTurns.get(streamId)
+  if (!turn) {
+    turn = { stop: new AbortController(), running: 0 }
+    runningTurns.set(streamId, turn)
+  }
+  turn.running += 1
+  const held = turn
+  let released = false
+  return {
+    signal: held.stop.signal,
+    release() {
+      if (released) return
+      released = true
+      held.running -= 1
+      if (held.running === 0 && runningTurns.get(streamId) === held) runningTurns.delete(streamId)
+    },
+  }
+}
+
+/** Cancels the running desktop tools of a turn the user stopped, from whichever view started them. */
+export function stopDesktopTools(streamId: string, reason: string): void {
+  runningTurns.get(streamId)?.stop.abort(reason)
+  runningTurns.delete(streamId)
+}

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts

@@ -17,9 +17,9 @@ import {
 } from '@/lib/mothership/resources/extraction'
 import {
   isClientExecutedToolCall,
-  isDesktopExecutedToolCall,
   isWorkflowToolName,
 } from '@/lib/mothership/tools/client-executed-tools'
+import { isDesktopToolCall } from '@/lib/mothership/tools/desktop-tools'
 import { invalidateResourceQueries } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry'
 import type { StreamLoopContext } from '@/app/workspace/[workspaceId]/home/hooks/stream/stream-context'
 import {
@@ -197,7 +197,7 @@ export function handleToolEvent(ctx: StreamLoopContext, parsed: ToolEvent): void
   // tools to it: its answer could only be an error, and that error would beat the real result.
   const shouldStartClientTool =
     isClientExecutedToolCall(name, args) &&
-    (isDesktopApp() || !isDesktopExecutedToolCall(name, args)) &&
+    (isDesktopApp() || !isDesktopToolCall(name, args)) &&
     !isPartial &&
     !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
     node?.kind === 'tool' &&

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

@@ -28,8 +28,14 @@ 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, mockExecuteBrowserToolOnClient } = vi.hoisted(() => ({
+const {
+  mockRequestJson,
+  mockExecuteWorkflow,
+  mockExecuteBrowserToolOnClient,
+  mockExecuteLocalFilesystemTool,
+} = vi.hoisted(() => ({
   mockExecuteBrowserToolOnClient: vi.fn(),
+  mockExecuteLocalFilesystemTool: vi.fn(),
   mockRequestJson: vi.fn(),
   mockExecuteWorkflow:
     vi.fn<
@@ -47,6 +53,9 @@ 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/local-filesystem', () => ({
+  executeLocalFilesystemTool: mockExecuteLocalFilesystemTool,
+}))
 vi.mock('@/lib/mothership/tools/client/browser-tool-execution', () => ({
   executeBrowserToolOnClient: mockExecuteBrowserToolOnClient,
 }))
@@ -2129,8 +2138,21 @@ 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'
+  describe.each([
+    {
+      kind: 'browser action',
+      toolName: 'browser_list_tabs',
+      arguments: {},
+      lifetimeOf: () => mockExecuteBrowserToolOnClient.mock.calls[0]?.[5],
+    },
+    {
+      kind: 'local file read',
+      toolName: 'read_local_file',
+      arguments: { path: '/Users/me/notes.txt' },
+      lifetimeOf: () => mockExecuteLocalFilesystemTool.mock.calls[0]?.[3]?.signal,
+    },
+  ])('a desktop $kind in flight', ({ toolName, arguments: toolArguments, lifetimeOf }) => {
+    const chatId = 'chat-desktop-action'
     const history: MothershipChatHistory = {
       id: chatId,
       mode: 'agent',
@@ -2140,8 +2162,8 @@ describe('useChat remount send recovery', () => {
       resources: [],
     }
 
-    /** Opens a turn whose stream delivers one desktop browser call and stays open. */
-    async function startBrowserAction() {
+    /** Opens a turn whose stream delivers one desktop tool call and stays open. */
+    async function startDesktopAction() {
       let streamId: string | undefined
       const replays: string[] = []
       mockRequestJson.mockImplementation((contract: AnyApiRouteContract) =>
@@ -2168,9 +2190,9 @@ describe('useChat remount send recovery', () => {
             phase: 'call',
             executor: 'client',
             mode: 'async',
-            toolName: 'browser_list_tabs',
-            toolCallId: 'browser-call',
-            arguments: {},
+            toolName,
+            toolCallId: 'desktop-call',
+            arguments: toolArguments,
           },
         }
         return new Response(
@@ -2186,23 +2208,26 @@ describe('useChat remount send recovery', () => {
       await act(async () => {
         void chat.getResult().sendMessage('List my tabs')
       })
-      await waitFor(() => mockExecuteBrowserToolOnClient.mock.calls.length === 1)
-      const toolSignal = mockExecuteBrowserToolOnClient.mock.calls[0]?.[5]
+      await waitFor(() => lifetimeOf() !== undefined)
+      const toolSignal = lifetimeOf()
       if (!(toolSignal instanceof AbortSignal))
-        throw new Error('The browser action has no lifetime')
-      return { ...chat, toolSignal, replays }
+        throw new Error('The desktop action has no lifetime')
+      return { ...chat, toolSignal, replays, streamId: () => streamId }
     }
 
     beforeEach(() => {
       libDesktopMockFns.mockIsDesktopApp.mockReturnValue(true)
+      const stillRunning = () => new Promise<void>(() => {})
+      mockExecuteBrowserToolOnClient.mockImplementation(stillRunning)
+      mockExecuteLocalFilesystemTool.mockImplementation(stillRunning)
     })
 
     afterEach(() => {
       libDesktopMockFns.mockIsDesktopApp.mockReset()
     })
 
     it('keeps running when the window returns to view and the stream is recovered', async () => {
-      const { toolSignal, replays } = await startBrowserAction()
+      const { toolSignal, replays } = await startDesktopAction()
 
       Object.defineProperty(document, 'visibilityState', {
         configurable: true,
@@ -2217,15 +2242,63 @@ describe('useChat remount send recovery', () => {
     })
 
     it('keeps running when the chat view unmounts, so it finishes and reports its result', async () => {
-      const { toolSignal, unmount } = await startBrowserAction()
+      const { toolSignal, unmount } = await startDesktopAction()
 
       unmount()
 
       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('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 startBrowserAction()
+      const { toolSignal, getResult } = await startDesktopAction()
 
       await act(async () => {
         await getResult().stopGeneration()