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.

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

@@ -98,6 +98,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>>>,
@@ -321,7 +333,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')
         }
@@ -334,7 +350,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
@@ -478,7 +494,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/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,10 +2208,10 @@ 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')
+        throw new Error('The desktop action has no lifetime')
       return { ...chat, toolSignal, replays }
     }
 
@@ -2202,7 +2224,7 @@ describe('useChat remount send recovery', () => {
     })
 
     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 +2239,15 @@ 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 cancelled when the user stops the chat', async () => {
-      const { toolSignal, getResult } = await startBrowserAction()
+      const { toolSignal, getResult } = await startDesktopAction()
 
       await act(async () => {
         await getResult().stopGeneration()

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

@@ -457,11 +457,12 @@ export async function waitForDetachedChatResolution(
 const USER_STOP_ABORT_REASON = 'user_stop:client_stopGeneration'
 
 /**
- * The lifetime a browser action 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.
+ * 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 browserToolLifetime(streamSignal: AbortSignal | undefined): AbortSignal | undefined {
+function desktopToolLifetime(streamSignal: AbortSignal | undefined): AbortSignal | undefined {
   if (!streamSignal) return undefined
   const lifetime = new AbortController()
   const followStop = () => {
@@ -1595,7 +1596,7 @@ export function useChat(
       const options = {
         workspaceId,
         chatId: chatIdRef.current ?? selectedChatIdRef.current,
-        signal: abortControllerRef.current?.signal,
+        signal: desktopToolLifetime(abortControllerRef.current?.signal),
       }
       /**
        * Dynamic on purpose: the local-filesystem executor only runs for desktop-local
@@ -2171,7 +2172,7 @@ export function useChat(
         shouldContinue?: () => boolean
       }
     ) => {
-      const browserToolSignal = browserToolLifetime(abortControllerRef.current?.signal)
+      const browserToolSignal = desktopToolLifetime(abortControllerRef.current?.signal)
       const activityTracker = getResourceActivityTracker(
         expectedGen ?? streamGenRef.current,
         options?.targetChatId

apps/sim/lib/mothership/constants.ts

@@ -73,7 +73,7 @@ export const COPILOT_WORKFLOW_TOOL_CLIENT_GRACE_MS = 30_000
  * 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
+ * run instead, so the call fails with a "never started" result rather than parking
  * until a watchdog calls it hung.
  */
 export const DESKTOP_TOOL_PICKUP_GRACE_MS = 15_000

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 chat is not open in the Sim desktop app, so nothing picked up this call and nothing happened on the user’s computer. It is safe to retry once the user opens this chat in the Sim desktop app.'
+  '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.'
 
 /** 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

@@ -919,7 +919,7 @@ describe('watchdog completion provenance', () => {
 
     expect(toolCall.result).toEqual({
       success: false,
-      output: { error: expect.stringContaining('safe to retry'), notStarted: true },
+      output: { error: expect.stringContaining('never started'), notStarted: true },
     })
   })
 
@@ -940,6 +940,24 @@ describe('watchdog completion provenance', () => {
     })
   })
 
+  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)
+
+    await failPendingToolCall(toolCall.id, context, execContext)
+
+    expect(toolCall.result).toEqual({
+      success: false,
+      output: {
+        error: expect.stringContaining('may never have started'),
+        outcomeUnknown: true,
+        doNotRetry: true,
+      },
+    })
+  })
+
   it('preserves an actual completion that settles while encryption is pending', async () => {
     const { toolCall, context, execContext } = createHungClient()
     let finishEncryption: (value: { encrypted: string }) => void = () => {}

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

@@ -86,7 +86,7 @@ import {
   type ToolCallState,
 } from '@/lib/mothership/request/types'
 import { ensureHandlersRegistered, executeTool } from '@/lib/mothership/tool-executor'
-import { isDesktopToolCall } from '@/lib/mothership/tools/desktop-tools'
+import { isDesktopToolCall, isLocalReadToolCall } from '@/lib/mothership/tools/desktop-tools'
 import { withSandboxResourceScope } from '@/lib/mothership/tools/sandbox-resources'
 import { isMcpTool } from '@/executor/constants'
 
@@ -414,6 +414,12 @@ const TOOL_RESULT_LOST_MESSAGE =
   'This tool started, but its result never came back, so it was abandoned to let the conversation continue. Its outcome is unknown: it may already have taken effect, so inspect the current state before repeating it, and do not retry it automatically.'
 const DESKTOP_TOOL_RESULT_LOST_MESSAGE =
   'The Sim desktop app started this action, but its result never came back (the chat view closed or the app stopped responding). Its outcome is unknown: it may already have taken effect, so inspect the current state before repeating it, and do not retry it automatically.'
+/**
+ * A local read the server cannot see picked up (one an older desktop reads without claiming) may
+ * never have started; either way, reading changed nothing.
+ */
+const DESKTOP_LOCAL_READ_RESULT_MISSING_MESSAGE =
+  'No result came back from the Sim desktop app for this read: it may never have started (this chat may not be open there), or its result was lost. Reading changes nothing 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.'
 const UNAVAILABLE_TOOL_SETTLEMENT_MESSAGE =
   'The tool result could not be restored before the conversation resumed. Its outcome is unknown; do not retry it automatically.'
 
@@ -423,8 +429,8 @@ const UNAVAILABLE_TOOL_SETTLEMENT_MESSAGE =
  * Execution ownership remains held while retained work cleans up.
  *
  * Without an explicit `failureMessage` the model learns which of two things happened: a desktop
- * call nothing claimed never started (`notStarted`, safe to retry), and anything else started and
- * lost its result (`outcomeUnknown`, `doNotRetry`).
+ * call nothing claimed never started (`notStarted`), and anything else started (or could not be
+ * seen starting) and lost its result (`outcomeUnknown`, `doNotRetry`).
  */
 export async function failPendingToolCall(
   toolCallId: string,
@@ -444,7 +450,12 @@ export async function failPendingToolCall(
     if (settled) return
   }
   const message =
-    failureMessage ?? (desktopCall ? DESKTOP_TOOL_RESULT_LOST_MESSAGE : TOOL_RESULT_LOST_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)
   await settleAbandonedToolCall(toolCall, context, execContext, {
     message,
     data: { error: message, outcomeUnknown: true, doNotRetry: true },

apps/sim/lib/mothership/tools/client-executed-tools.ts

@@ -1,6 +1,4 @@
-import { isCurrentBrowserToolName } from '@sim/browser-protocol'
-import { isTerminalToolName } from '@sim/terminal-protocol'
-import { isNativeFileTool, isUserLocalVfsToolCall } from '@/lib/mothership/tools/local-filesystem'
+import { isDesktopToolCall } from '@/lib/mothership/tools/desktop-tools'
 
 const WORKFLOW_TOOL_NAMES = new Set<string>([
   'run_workflow',
@@ -13,22 +11,6 @@ export function isWorkflowToolName(name: string): boolean {
   return WORKFLOW_TOOL_NAMES.has(name)
 }
 
-/**
- * Client-executed calls only the desktop app can run: local file access, the agent browser, and
- * the terminal. A web tab watching the same chat must leave them to the desktop app.
- */
-export function isDesktopExecutedToolCall(
-  name: string,
-  args: Record<string, unknown> | undefined
-): boolean {
-  return (
-    isNativeFileTool(name) ||
-    isUserLocalVfsToolCall(name, args) ||
-    isCurrentBrowserToolName(name) ||
-    isTerminalToolName(name)
-  )
-}
-
 /**
  * Tool calls the browser starts from the call frame's own arguments: workflow
  * runs, local file access, browser actions, and terminal commands. The stream
@@ -38,5 +20,5 @@ export function isClientExecutedToolCall(
   name: string,
   args: Record<string, unknown> | undefined
 ): boolean {
-  return isWorkflowToolName(name) || isDesktopExecutedToolCall(name, args)
+  return isWorkflowToolName(name) || isDesktopToolCall(name, args)
 }