@@ -485,7 +485,7 @@ describe('registerIpcHandlers', () => {
     expect(mounts).not.toHaveBeenCalled()
     expect(fetchAuthorization).toHaveBeenCalledWith(
       `${APP}/api/desktop/tool/authorize`,
-      expect.objectContaining({ body: JSON.stringify({ toolCallId: 'tool-native' }) })
+      expect.objectContaining({ body: JSON.stringify({ toolCallId: 'tool-native', claim: true }) })
     )
     expect(
       await handler?.(evilEvent, { operation: 'read', toolCallId: 'tool-native' })
@@ -569,7 +569,7 @@ describe('registerIpcHandlers', () => {
       expect.objectContaining({
         method: 'POST',
         credentials: 'include',
-        body: JSON.stringify({ toolCallId: 'tool-1' }),
+        body: JSON.stringify({ toolCallId: 'tool-1', claim: true }),
       })
     )
   })
 
@@ -578,10 +578,13 @@ async function authorizeLocalFilesystemTool(
   request: unknown
 ): Promise<boolean> {
   if (typeof request !== 'object' || request === null) return false
+  // Claimed like an import: the server sees the read picked up, and refuses one it already
+  // failed as never started.
   const authorization = await fetchDesktopToolAuthorization(
     event,
     deps,
-    (request as { requestId?: unknown }).requestId
+    (request as { requestId?: unknown }).requestId,
+    true
   )
   return authorization
     ? deps.localFilesystem.isAuthorizedClientToolRequest(request, authorization)
@@ -2113,7 +2116,7 @@ export function registerIpcHandlers(deps: IpcDeps): void {
             event,
             deps,
             request.toolCallId,
-            request.operation === 'manifest',
+            request.operation === 'manifest' || request.operation === 'read',
             (status) => {
               failureStatus = status
             }
 
@@ -14,11 +14,10 @@ import { homedir } from 'node:os'
 import type { TerminalShortcutCommand } from '@sim/desktop-bridge'
 import { createLogger } from '@sim/logger'
 import {
-  DEFAULT_RUN_WAIT_MS,
   isTerminalControlKey,
   MAX_INPUT_KEYS,
-  MAX_RUN_WAIT_MS,
   MAX_TOOL_OUTPUT_CHARS,
+  resolveRunWaitMs,
   type TerminalCommandEvent,
   type TerminalControlKey,
   type TerminalCwdResult,
@@ -109,14 +108,6 @@ const HANDOFF_MAX_MS = 12 * 60 * 60 * 1000
  */
 const HANDOFF_SETTLE_MS = 5_000
 
-/** How long to hold the turn before handing a still-running command back. */
-function resolveWaitMs(waitSeconds: number | undefined): number {
-  const requested = Number(waitSeconds)
-  return Number.isFinite(requested) && requested > 0
-    ? Math.min(requested * 1000, MAX_RUN_WAIT_MS)
-    : DEFAULT_RUN_WAIT_MS
-}
-
 function elideOutput(value: string): { text: string; truncated: boolean } {
   return elide(value, MAX_TOOL_OUTPUT_CHARS)
 }
@@ -1097,7 +1088,7 @@ export class TerminalService {
     const handle = await startRun(session, command, terminal.currentCwd, terminal.env)
     if ('error' in handle) throw new TerminalError('SPAWN_FAILED', handle.error)
 
-    const waitMs = resolveWaitMs(args.waitSeconds)
+    const waitMs = resolveRunWaitMs(args.waitSeconds)
     const outcome = await awaitRun(handle, waitMs)
     if (outcome.done) {
       await closeRunWindow(handle, terminal.env)
@@ -1149,7 +1140,7 @@ export class TerminalService {
       )
     }
 
-    return session.runCommand(command, toolCallId, resolveWaitMs(args.waitSeconds))
+    return session.runCommand(command, toolCallId, resolveRunWaitMs(args.waitSeconds))
   }
 
   private spawn(
 
@@ -156,6 +156,7 @@ const api: SimDesktopApi = {
     ipcRenderer.invoke('desktop:local-filesystem', request),
   localFiles: (request: DesktopLocalFileRequest): Promise<DesktopLocalFileResponse> =>
     ipcRenderer.invoke('desktop:local-files', request),
+  localReadClaims: true,
   onCommand: (callback: (command: DesktopCommand) => void): (() => void) => {
     const listener = (_event: unknown, command: DesktopCommand) => callback(command)
     ipcRenderer.on('desktop:command', listener)
 
@@ -330,6 +330,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
 
@@ -19,6 +19,7 @@ import {
   createNotFoundResponse,
   createUnauthorizedResponse,
 } from '@/lib/mothership/request/http'
+import { isLocalReadToolCall } from '@/lib/mothership/tools/desktop-tools'
 import { isUserLocalVfsToolCall } from '@/lib/mothership/tools/local-filesystem'
 
 const admissionClosedResponse = () =>
@@ -129,6 +130,23 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       return createNotFoundResponse('The import must be started before reading file bytes')
   }
 
+  // A desktop that claims local reads claims each one before its first read; its later reads of
+  // the same call ride on that claim. A call persisted running (an older desktop's turn) is read
+  // as before.
+  if (parsed.data.body.claim && isLocalReadToolCall(toolCall.toolName, args)) {
+    const notPending = () => createNotFoundResponse('Pending client tool call not found')
+    if (toolCall.status === 'pending') {
+      const { outcome } = await claimToolExecution({
+        toolCallId: toolCall.toolCallId,
+        runId: toolCall.runId,
+        userId,
+        claimedBy: DESKTOP_TOOL_CLAIM_OWNER.files,
+      })
+      if (outcome !== 'claimed') return refusedClaimResponse(outcome, notPending)
+    } else if (toolCall.claimedBy !== null && toolCall.claimedBy !== DESKTOP_TOOL_CLAIM_OWNER.files)
+      return notPending()
+  }
+
   // Browser and terminal actions are one-shot side effects on the user's own
   // machine, so the pending call is claimed here, atomically, before crossing
   // the Electron boundary — a replayed renderer event must not run a command
 
@@ -21,13 +21,15 @@
 
 import { act, type ReactNode, StrictMode, useEffect, useState } from 'react'
 import { authClientMock, authClientMockFns } from '@sim/testing/mocks/auth-client.mock'
+import { libDesktopMock, libDesktopMockFns } from '@sim/testing/mocks/lib-desktop.mock'
 import { nextNavigationMock, nextNavigationMockFns } from '@sim/testing/mocks/next-navigation.mock'
 import { sleep } from '@sim/utils/helpers'
 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 } = vi.hoisted(() => ({
+const { mockRequestJson, mockExecuteWorkflow, mockExecuteBrowserToolOnClient } = vi.hoisted(() => ({
+  mockExecuteBrowserToolOnClient: vi.fn(),
   mockRequestJson: vi.fn(),
   mockExecuteWorkflow:
     vi.fn<
@@ -44,6 +46,10 @@ 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/browser-tool-execution', () => ({
+  executeBrowserToolOnClient: mockExecuteBrowserToolOnClient,
+}))
 vi.mock('@/lib/auth/auth-client', () => authClientMock)
 vi.unmock('@/stores/execution/store')
 vi.unmock('@/stores/terminal')
@@ -2039,4 +2045,109 @@ 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'
+    const history: MothershipChatHistory = {
+      id: chatId,
+      mode: 'agent',
+      title: 'Browser action',
+      messages: [],
+      activeStreamId: null,
+      resources: [],
+    }
+
+    /** Opens a turn whose stream delivers one desktop browser call and stays open. */
+    async function startBrowserAction() {
+      let streamId: string | undefined
+      const replays: string[] = []
+      mockRequestJson.mockImplementation((contract: AnyApiRouteContract) =>
+        Promise.resolve(
+          contract.path === '/api/mothership/chats/[chatId]'
+            ? { chat: { ...history, activeStreamId: streamId ?? null } }
+            : { chats: [] }
+        )
+      )
+      vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+        const url = String(input)
+        if (url.includes('/api/mothership/chat/stream')) replays.push(url)
+        if (url !== '/api/mothership/chat' || init?.method !== 'POST') {
+          return fetchStub(input, init)
+        }
+        streamId = JSON.parse(String(init.body)).userMessageId
+        const call: MothershipStreamV1EventEnvelope = {
+          v: 1,
+          seq: 1,
+          ts: new Date().toISOString(),
+          type: 'tool',
+          stream: { streamId: streamId ?? '' },
+          payload: {
+            phase: 'call',
+            executor: 'client',
+            mode: 'async',
+            toolName: 'browser_list_tabs',
+            toolCallId: 'browser-call',
+            arguments: {},
+          },
+        }
+        return new Response(
+          new ReadableStream<Uint8Array>({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(call)}\n\n`))
+            },
+          }),
+          { headers: { 'Content-Type': 'text/event-stream', 'x-mothership-chat-id': chatId } }
+        )
+      })
+      const chat = renderUseChatInChat(chatId, history)
+      await act(async () => {
+        void chat.getResult().sendMessage('List my tabs')
+      })
+      await waitFor(() => mockExecuteBrowserToolOnClient.mock.calls.length === 1)
+      const toolSignal = mockExecuteBrowserToolOnClient.mock.calls[0]?.[5]
+      if (!(toolSignal instanceof AbortSignal))
+        throw new Error('The browser action has no lifetime')
+      return { ...chat, toolSignal, replays }
+    }
+
+    beforeEach(() => {
+      libDesktopMockFns.mockIsDesktopApp.mockReturnValue(true)
+    })
+
+    afterEach(() => {
+      libDesktopMockFns.mockIsDesktopApp.mockReset()
+    })
+
+    it('keeps running when the window returns to view and the stream is recovered', async () => {
+      const { toolSignal, replays } = await startBrowserAction()
+
+      Object.defineProperty(document, 'visibilityState', {
+        configurable: true,
+        get: () => 'visible',
+      })
+      await act(async () => {
+        document.dispatchEvent(new Event('visibilitychange'))
+      })
+      await waitFor(() => replays.length > 0)
+
+      expect(toolSignal.aborted).toBe(false)
+    })
+
+    it('keeps running when the chat view unmounts, so it finishes and reports its result', async () => {
+      const { toolSignal, unmount } = await startBrowserAction()
+
+      unmount()
+
+      expect(toolSignal.aborted).toBe(false)
+    })
+
+    it('is cancelled when the user stops the chat', async () => {
+      const { toolSignal, getResult } = await startBrowserAction()
+
+      await act(async () => {
+        await getResult().stopGeneration()
+      })
+
+      expect(toolSignal.aborted).toBe(true)
+    })
+  })
 })
@@ -452,6 +452,25 @@ export async function waitForDetachedChatResolution(
   }
 }
 
+/** The abort reason of the user's Stop. */
+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.
+ */
+function browserToolLifetime(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.
@@ -2151,7 +2170,7 @@ export function useChat(
         shouldContinue?: () => boolean
       }
     ) => {
-      const streamAbortSignal = abortControllerRef.current?.signal
+      const browserToolSignal = browserToolLifetime(abortControllerRef.current?.signal)
       const activityTracker = getResourceActivityTracker(
         expectedGen ?? streamGenRef.current,
         options?.targetChatId
@@ -2172,7 +2191,7 @@ export function useChat(
         eventTs?: string
       ) => {
         const scopeId = activityScopeId()
-        startClientBrowserTool(toolCallId, toolName, toolArgs, scopeId, eventTs, streamAbortSignal)
+        startClientBrowserTool(toolCallId, toolName, toolArgs, scopeId, eventTs, browserToolSignal)
       }
       const startClientTerminalToolForStream = (
         toolCallId: string,
@@ -4424,7 +4443,7 @@ export function useChat(
       streamReaderRef.current = null
       const stoppedController = abortControllerRef.current
       if (stoppedController !== pendingAdmission?.controller) {
-        stoppedController?.abort('user_stop:client_stopGeneration')
+        stoppedController?.abort(USER_STOP_ABORT_REASON)
       }
       abortControllerRef.current = null
       setTransportIdle()
@@ -4520,7 +4539,7 @@ export function useChat(
             if (pendingAdmission && pendingAdmission.userMessageId === sid) {
               const admittedChatId = await pendingAdmission.settled
               resolvedChatId ??= admittedChatId
-              pendingAdmission.controller.abort('user_stop:client_stopGeneration')
+              pendingAdmission.controller.abort(USER_STOP_ABORT_REASON)
             }
             if (!resolvedChatId && sid) {
               resolvedChatId = await resolveChatIdForStream(sid, { preferExistingChatId: false })
 
@@ -156,6 +156,7 @@ export interface DesktopChatCapabilities {
   desktopCapabilities?: {
     localFiles?: true
     localFilesystem?: true
+    localReadClaims?: true
     browser?: true
     terminal?: true
     browserSessions?: BrowserKnownSession[]
@@ -217,6 +218,7 @@ export async function getDesktopChatCapabilities(
       ? {
           desktopCapabilities: {
             ...(localFiles ? { localFiles: true as const } : {}),
+            ...(bridge?.localReadClaims === true ? { localReadClaims: true as const } : {}),
             ...(localFilesystem ? { localFilesystem: true as const } : {}),
             ...(browser ? { browser: true as const } : {}),
             ...(terminal ? { terminal: true as const } : {}),
 
@@ -312,6 +312,7 @@ const ChatMessageSchema = z
       .object({
         localFilesystem: z.boolean().optional(),
         localFiles: z.boolean().optional(),
+        localReadClaims: z.boolean().optional(),
         browser: z.boolean().optional(),
         terminal: z.boolean().optional(),
         terminals: z
@@ -1517,6 +1518,7 @@ export async function handleUnifiedChatPost(req: NextRequest) {
           // Executor routing is decided HERE, once per turn, from the caller's declared
           // capabilities — dispatch never discovers client absence by burning a grace timer.
           clientToolPickupExpected,
+          desktopClaimsLocalReads: body.desktopCapabilities?.localReadClaims === true,
           executionContext,
           billingAttribution: executionContext.billingAttribution,
           onComplete: buildOnComplete({