@@ -348,11 +348,15 @@ export function getReplayCompletedWorkflowToolCallIds(events: StreamBatchEvent[]
     const payload = event.payload
     if (!('phase' in payload)) continue
     if (payload.phase !== MothershipStreamV1ToolPhase.result) continue
-    // Client-executed tools (workflow runs, browser actions) must never
-    // re-fire when their completed call replays after reconnect/reload.
+    /**
+     * Client-executed tools (workflow runs, browser and computer actions) must never
+     * re-fire when their completed call replays after reconnect/reload.
+     */
     if (
       typeof payload.toolCallId === 'string' &&
-      (isWorkflowToolName(payload.toolName) || isBrowserToolName(payload.toolName))
+      (isWorkflowToolName(payload.toolName) ||
+        isBrowserToolName(payload.toolName) ||
+        payload.toolName === 'computer')
     ) {
       completedToolCallIds.add(payload.toolCallId)
     }
 
@@ -12,6 +12,8 @@ vi.mock(
 )
 
 import type { PersistedStreamEventEnvelope } from '@/lib/mothership/request/session/contract'
+import { toStreamBatchEvent } from '@/lib/mothership/request/session/types'
+import { getReplayCompletedWorkflowToolCallIds } from '@/app/workspace/[workspaceId]/home/hooks/message-reconcile'
 import { dispatchStreamEvent } from './dispatch-stream-event'
 import { createStreamLoopContext, type StreamLoopContext } from './stream-context'
 import { makeStreamLoopDeps, ref } from './stream-test-helpers'
@@ -99,6 +101,38 @@ describe('tool events (dispatch → model + side effects)', () => {
     expect(deps.startClientComputerTool).not.toHaveBeenCalled()
   })
 
+  it.each([true, false])(
+    'does not redispatch a completed computer call from a fresh replay batch (success=%s)',
+    (success) => {
+      const call = (id: string) =>
+        toolEnv({
+          phase: 'call',
+          executor: 'client',
+          mode: 'async',
+          toolCallId: id,
+          toolName: 'computer',
+          arguments: { action: 'list_apps' },
+        })
+      const events = [
+        call('computer-complete'),
+        toolResult('computer-complete', success, 'computer'),
+        call('computer-unfinished'),
+      ].map(toStreamBatchEvent)
+      const deps = makeStreamLoopDeps()
+      deps.options.suppressedWorkflowToolStartIds = getReplayCompletedWorkflowToolCallIds(events)
+      const ctx = createStreamLoopContext(deps)
+
+      for (const entry of events) dispatchStreamEvent(ctx, entry.event)
+
+      expect(deps.startClientComputerTool).toHaveBeenCalledExactlyOnceWith(
+        'computer-unfinished',
+        { action: 'list_apps' },
+        ''
+      )
+      expect(toolNode(ctx, 'computer-complete').result).toBeDefined()
+    }
+  )
+
   it('redelivers an unsettled computer call through the replay-safe native executor after reconnect', () => {
     const deps = makeStreamLoopDeps()
     const ctx = createStreamLoopContext(deps)
 
@@ -186,4 +186,15 @@ describe('getReplayCompletedWorkflowToolCallIds', () => {
 
     expect(result).toEqual(new Set(['workflow-complete']))
   })
+
+  it('suppresses completed computer and browser calls while keeping unfinished calls eligible', () => {
+    const result = getReplayCompletedWorkflowToolCallIds([
+      toolBatchEvent(1, 'computer-complete', 'computer', MothershipStreamV1ToolPhase.call),
+      toolBatchEvent(2, 'computer-complete', 'computer', MothershipStreamV1ToolPhase.result),
+      toolBatchEvent(3, 'computer-active', 'computer', MothershipStreamV1ToolPhase.call),
+      toolBatchEvent(4, 'browser-complete', 'browser_click', MothershipStreamV1ToolPhase.result),
+    ])
+
+    expect(result).toEqual(new Set(['computer-complete', 'browser-complete']))
+  })
 })
@@ -326,44 +326,65 @@ describe('sse-handlers tool lifecycle', () => {
     )
   })
 
-  it('pre-persists browser tools as pending for the desktop authorization claim', async () => {
-    isSimExecuted.mockReturnValue(false)
-    context.runId = 'run-1'
-
-    await prePersistClientExecutableToolCall(
-      {
-        type: MothershipStreamV1EventType.tool,
-        payload: {
-          toolCallId: 'browser-tool-1',
-          toolName: 'browser_list_tabs',
-          arguments: {},
-          executor: MothershipStreamV1ToolExecutor.client,
-          mode: MothershipStreamV1ToolMode.async,
-          phase: MothershipStreamV1ToolPhase.call,
-        },
-      } satisfies StreamEvent,
-      context,
-      {},
-      execContext
-    )
-
-    expect(upsertAsyncToolCall).toHaveBeenCalledWith({
-      runId: 'run-1',
-      toolCallId: 'browser-tool-1',
-      toolName: 'browser_list_tabs',
-      args: {},
-      sealedContext: { __sealedClientToolContextV1: 'sealed-context' },
-      status: MothershipStreamV1AsyncToolRecordStatus.pending,
-      permissionRequested: false,
-    })
-    expect(sealClientToolContext).toHaveBeenCalledWith({
-      toolCallId: 'browser-tool-1',
-      runId: 'run-1',
-      userId: 'user-1',
-      registry: execContext.resolvedSecretTraceRegistry,
-      toolInput: {},
-    })
-  })
+  describe.each(['browser_list_tabs', 'terminal', 'import_local_files', 'computer'])(
+    'native %s pre-persistence',
+    (toolName) => {
+      it.each([false, true])(
+        'keeps the call pending for the desktop claim when approval gating is %s',
+        async (gated) => {
+          isSimExecuted.mockReturnValue(false)
+          toolRequiresApproval.mockReturnValue(gated)
+          context.runId = 'run-1'
+          context.toolPermissions.enabled = gated
+          const args =
+            toolName === 'computer'
+              ? { action: 'status' }
+              : toolName === 'terminal'
+                ? { operation: 'run', command: 'pwd' }
+                : {}
+          const event = {
+            type: MothershipStreamV1EventType.tool,
+            payload: {
+              toolCallId: 'native-tool-1',
+              toolName,
+              arguments: args,
+              executor: MothershipStreamV1ToolExecutor.client,
+              mode: MothershipStreamV1ToolMode.async,
+              phase: MothershipStreamV1ToolPhase.call,
+            },
+          } satisfies StreamEvent
+
+          await prePersistClientExecutableToolCall(event, context, {}, execContext)
+
+          expect(upsertAsyncToolCall).toHaveBeenCalledExactlyOnceWith({
+            runId: 'run-1',
+            toolCallId: 'native-tool-1',
+            toolName,
+            args,
+            sealedContext: { __sealedClientToolContextV1: 'sealed-context' },
+            status: MothershipStreamV1AsyncToolRecordStatus.pending,
+            permissionRequested: gated,
+          })
+          expect(sealClientToolContext).toHaveBeenCalledWith({
+            toolCallId: 'native-tool-1',
+            runId: 'run-1',
+            userId: 'user-1',
+            registry: execContext.resolvedSecretTraceRegistry,
+            toolInput: args,
+          })
+          expect(event.payload).toEqual({
+            toolCallId: 'native-tool-1',
+            toolName,
+            arguments: args,
+            executor: MothershipStreamV1ToolExecutor.client,
+            mode: MothershipStreamV1ToolMode.async,
+            phase: MothershipStreamV1ToolPhase.call,
+            ...(gated ? { status: 'awaiting_approval' } : {}),
+          })
+        }
+      )
+    }
+  )
 
   it('persists a gated sim tool and stamps the frame so a reload can still answer it', async () => {
     toolRequiresApproval.mockReturnValue(true)
 
@@ -281,6 +281,14 @@ describe('pendingToolWaitBudgetMs', () => {
     )
   })
 
+  it('reserves the whole computer action budget before the lifecycle adds delivery grace', () => {
+    expect(pendingToolWaitBudgetMs({ name: 'computer', status: 'executing' })).toBe(90_000)
+    expect(pendingToolWaitBudgetMs({ name: 'computer', status: 'executing' }, 'device-1')).toBe(CLIENT_TOOL_RESULT_TIMEOUT_MS)
+    expect(pendingToolWaitBudgetMs({ name: 'computer', status: 'awaiting_approval' })).toBe(
+      TOOL_WATCHDOG_LONG_RUNNING_MS
+    )
+  })
+
   it('falls back to the tool\u2019s own watchdog once it is actually executing', () => {
     expect(pendingToolWaitBudgetMs({ name: 'terminal_run', status: 'executing' })).toBe(
       TOOL_WATCHDOG_DEFAULT_MS
 
@@ -1,4 +1,5 @@
 import { browserToolRendererTimeoutMs, isCurrentBrowserToolName } from '@sim/browser-protocol'
+import { COMPUTER_USE_TOOL_TIMEOUT_MS } from '@sim/desktop-bridge'
 import { createLogger } from '@sim/logger'
 import { isTerminalToolName, resolveRunWaitMs } from '@sim/terminal-protocol'
 import { toError } from '@sim/utils/errors'
@@ -271,6 +272,7 @@ export function pendingToolWaitBudgetMs(
   const executableName = toolCall?.execName ?? toolCall?.name
   if (desktopDeviceId && executableName && isDesktopToolCall(executableName, toolCall?.params))
     return CLIENT_TOOL_RESULT_TIMEOUT_MS
+  if (executableName === 'computer') return COMPUTER_USE_TOOL_TIMEOUT_MS
   if (executableName && isCurrentBrowserToolName(executableName)) {
     return browserToolRendererTimeoutMs(executableName, toolCall?.params)
   }
 
@@ -1,5 +1,5 @@
 /** @vitest-environment jsdom */
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const mocks = vi.hoisted(() => ({
   execute: vi.fn(),
@@ -29,6 +29,31 @@ describe('computer action delivery', () => {
     mocks.complete.mockResolvedValue(undefined)
     mocks.pageExit.mockResolvedValue(undefined)
   })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('allows the full action budget, then cancels and reports an uncertain result', async () => {
+    vi.useFakeTimers()
+    mocks.execute.mockImplementationOnce(() => new Promise(() => {}))
+    const id = nextId()
+    const execution = executeComputerToolOnClient(id, { action: 'list_apps' }, now())
+
+    await vi.advanceTimersByTimeAsync(89_999)
+    expect(mocks.cancel).not.toHaveBeenCalled()
+    expect(mocks.complete).not.toHaveBeenCalled()
+
+    await vi.advanceTimersByTimeAsync(1)
+    await execution
+    expect(mocks.cancel).toHaveBeenCalledExactlyOnceWith(id)
+    expect(mocks.complete).toHaveBeenCalledExactlyOnceWith(
+      id,
+      'cancelled',
+      expect.stringContaining('timed out'),
+      { doNotRetry: true, outcomeUnknown: true }
+    )
+  })
+
   it('strips UI activity and runs each action only once across redelivery', async () => {
     const id = nextId()
     await executeComputerToolOnClient(
 
@@ -1,3 +1,4 @@
+import { COMPUTER_USE_TOOL_TIMEOUT_MS } from '@sim/desktop-bridge'
 import { ComputerUseSchema } from '@sim/desktop-bridge/computer-use'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
@@ -17,7 +18,6 @@ import { computerToolResultForModel } from '@/lib/mothership/tools/client/comput
 const logger = createLogger('ComputerToolExecution')
 const MAX_EVENT_AGE_MS = 120_000
 const MAX_UNDELIVERED_RESULTS = 8
-const MAX_ACTION_MS = 90_000
 const replayLedger = new BrowserToolReplayLedger({
   storageKey: 'sim:computer-tool-ledger:v1',
   legacyStoragePrefix: 'sim:computer-tool-executed:',
@@ -147,7 +147,7 @@ export async function executeComputerToolOnClient(
           timer = setTimeout(() => {
             cancel()
             rejectTimeout(new Error('Computer action timed out; its effect may be incomplete'))
-          }, MAX_ACTION_MS)
+          }, COMPUTER_USE_TOOL_TIMEOUT_MS)
         }),
       ])
       execution.completion = cancelled
 
@@ -36,6 +36,9 @@ import type {
 
 const PENDING_DESKTOP_SCOPE_PREFIX = 'pending:' as const
 
+/** Renderer budget for native authorization, app approval, queueing, and execution. */
+export const COMPUTER_USE_TOOL_TIMEOUT_MS = 90_000
+
 /** Native work is bound to the server-authorized chat and tool call. */
 export interface ComputerUseActivity {
   toolCallId: string