fix(desktop): scope the overdue sweep to desktop calls and keep ungated pickup windows

- The overdue listing and the per-call deadline read only consider desktop
  tool calls, and the settlement checks the call is one the desktop runs, so
  a bound run's workflow call or Sim-files VFS read is never failed with the
  desktop's not-started result.
- The cron scans only runs inside the inbox's horizon, oldest calls first,
  within its batch limit.
- Recording a decision clears the pickup deadline only for a call that was
  gated; a call that was never gated keeps the window it was offered with.

Author: waleedlatif1

apps/sim/lib/desktop/executor/bound-turn.integration.ts

@@ -731,6 +731,62 @@ describe.runIf(Boolean(redisUrl))("a turn bound to a desktop's background execut
     TURN_WAIT_MS
   )
 
+  it(
+    'leaves a bound run’s calls the desktop never runs to their own path',
+    async () => {
+      const desktop = await signedInDesktop()
+      const run = await boundRun(desktop)
+      const longAgo = new Date(Date.now() - 600_000)
+      const workflowCall = generateId()
+      const simFileRead = generateId()
+      await db.insert(copilotAsyncToolCalls).values([
+        {
+          runId: run.runId,
+          toolCallId: workflowCall,
+          toolName: 'run_workflow',
+          args: {},
+          createdAt: longAgo,
+        },
+        {
+          runId: run.runId,
+          toolCallId: simFileRead,
+          toolName: 'read',
+          args: { path: 'workspace/notes.md' },
+          createdAt: longAgo,
+        },
+      ])
+
+      await runCleanupStaleExecutions()
+
+      expect((await storedCall(workflowCall)).status).toBe('pending')
+      expect((await storedCall(simFileRead)).status).toBe('pending')
+    },
+    TURN_WAIT_MS
+  )
+
+  it(
+    'keeps the pickup window of a call that was never gated when a decision is posted for it',
+    async () => {
+      const desktop = await signedInDesktop()
+      const run = await boundRun(desktop)
+      await desktop.pull()
+
+      const { toolCallId, answer, context } = await agentCalls(run, 'browser_click', { ref: 'e1' })
+      const offeredRow = await offered(toolCallId)
+      const decided = await post(toolPermissionPOST, '/api/copilot/tool-permission', {
+        decisions: [{ toolCallId, decision: 'allow' }],
+      })
+      expect(decided.status).toBe(200)
+
+      expect((await storedCall(toolCallId)).pickupDeadlineAt).toEqual(offeredRow.pickupDeadlineAt)
+      const { executionToken } = await desktop.claim(toolCallId)
+      await desktop.complete(toolCallId, executionToken, { clicked: true })
+      await answer
+      expect(resultOf(context, toolCallId)).toMatchObject({ success: true })
+    },
+    TURN_WAIT_MS
+  )
+
   it(
     'settles a call Sim never offered once its pickup window would have closed',
     async () => {

apps/sim/lib/desktop/executor/repository.ts

@@ -336,12 +336,14 @@ export async function offerDesktopToolCall(input: {
 /**
  * A bound desktop call with the deadlines only Sim enforces, read on the database clock every CAS
  * uses: whether its pickup window closed while it is unclaimed, and whether its lease lapsed while
- * it runs. Null for a call on a run no device is bound to.
+ * it runs. Null for a call on a run no device is bound to, and for a tool the desktop never runs.
  */
 export async function getDesktopToolCallDeadlines(toolCallId: string) {
   const [row] = await db
     .select({
       toolCallId: copilotAsyncToolCalls.toolCallId,
+      toolName: copilotAsyncToolCalls.toolName,
+      args: copilotAsyncToolCalls.args,
       runId: copilotRuns.id,
       userId: copilotRuns.userId,
       deviceId: copilotRuns.desktopDeviceId,
@@ -361,7 +363,11 @@ export async function getDesktopToolCallDeadlines(toolCallId: string) {
     .innerJoin(copilotRuns, eq(copilotRuns.id, copilotAsyncToolCalls.runId))
     .leftJoin(desktopDevices, eq(desktopDevices.id, copilotRuns.desktopDeviceId))
     .where(
-      and(eq(copilotAsyncToolCalls.toolCallId, toolCallId), isNotNull(copilotRuns.desktopDeviceId))
+      and(
+        eq(copilotAsyncToolCalls.toolCallId, toolCallId),
+        isNotNull(copilotRuns.desktopDeviceId),
+        inArray(copilotAsyncToolCalls.toolName, [...DESKTOP_TOOL_CALL_NAMES])
+      )
     )
     .limit(1)
   return row?.deviceId ? { ...row, deviceId: row.deviceId } : null
@@ -374,7 +380,8 @@ export type DesktopToolCallDeadlines = NonNullable<
 /**
  * Bound desktop calls a deadline passed for at least `slackMs` ago: unclaimed past their pickup
  * deadline (offered or not), or claimed by the executor with a lapsed lease. A live waiter settles
- * these within its 5 s poll, so anything this finds lost its waiter.
+ * these within its 5 s poll, so anything this finds lost its waiter. Only runs inside the inbox's
+ * horizon are scanned, oldest calls first.
  */
 export async function listOverdueDesktopToolCalls(input: { slackMs: number; limit: number }) {
   const overdue = sql`clock_timestamp() - ${input.slackMs} * interval '1 millisecond'`
@@ -385,6 +392,8 @@ export async function listOverdueDesktopToolCalls(input: { slackMs: number; limi
     .where(
       and(
         isNotNull(copilotRuns.desktopDeviceId),
+        sql`${copilotRuns.startedAt} > now() - make_interval(hours => ${DESKTOP_INBOX_HORIZON_HOURS})`,
+        inArray(copilotAsyncToolCalls.toolName, [...DESKTOP_TOOL_CALL_NAMES]),
         or(
           pickupOverdueAt(overdue),
           and(
@@ -397,6 +406,7 @@ export async function listOverdueDesktopToolCalls(input: { slackMs: number; limi
         )
       )
     )
+    .orderBy(asc(copilotAsyncToolCalls.createdAt), asc(copilotAsyncToolCalls.toolCallId))
     .limit(input.limit)
   return rows.map((row) => row.toolCallId)
 }

apps/sim/lib/mothership/async-runs/repository.ts

@@ -1738,8 +1738,9 @@ export async function recordToolPermissionDecision(
         .set({
           permissionDecision: decision,
           permissionDecidedAt: now,
-          // No pickup window runs while the user decides: an allowed call is offered afresh.
-          pickupDeadlineAt: null,
+          // No pickup window runs while the user decides: a gated call is offered afresh once
+          // allowed. A call that was never gated keeps the window it was offered with.
+          pickupDeadlineAt: sql`CASE WHEN ${copilotAsyncToolCalls.permissionRequestedAt} IS NULL THEN ${copilotAsyncToolCalls.pickupDeadlineAt} END`,
           updatedAt: now,
         })
         .where(

apps/sim/lib/mothership/request/tools/desktop-wait.test.ts

@@ -98,6 +98,8 @@ describe('settleAbandonedDesktopToolCalls', () => {
       .mockRejectedValueOnce(new Error('connection reset'))
       .mockResolvedValueOnce({
         toolCallId: 'overdue',
+        toolName: 'browser_click',
+        args: { ref: 'e1' },
         runId: 'run-1',
         userId: 'user-1',
         deviceId: 'device-1',

apps/sim/lib/mothership/request/tools/desktop-wait.ts

@@ -1,6 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
 import { interruptibleSleep } from '@sim/utils/helpers'
+import { toRecordOrNull } from '@sim/utils/object'
 import { ringDesktopInbox } from '@/lib/desktop/executor/doorbell'
 import { isDesktopPresent } from '@/lib/desktop/executor/presence'
 import {
@@ -23,6 +24,7 @@ import {
   type ClientToolSettlementGuard,
   settleClientToolCall,
 } from '@/lib/mothership/request/tools/client-settlement.server'
+import { isDesktopToolCall } from '@/lib/mothership/tools/desktop-tools'
 import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 
 const logger = createLogger('CopilotDesktopToolWait')
@@ -230,7 +232,9 @@ async function readDesktopPresence(deviceId: string): Promise<boolean | null> {
  */
 async function settleOverdueDesktopToolCall(toolCallId: string): Promise<boolean> {
   const call = await getDesktopToolCallDeadlines(toolCallId)
-  if (!call) return false
+  // A VFS read of Sim's own files shares its tool name with a local read, but no desktop runs it.
+  if (!call || !isDesktopToolCall(call.toolName, toRecordOrNull(call.args) ?? undefined))
+    return false
   if (call.status === ASYNC_TOOL_STATUS.pending) {
     const present = await readDesktopPresence(call.deviceId)
     // Before its pickup window closes, a call fails early only when its device is known to be away: