fix(desktop): limit the overdue sweep over desktop calls only, and bound it by deadline

The sweep's tool-name filter admitted read, grep and glob calls on Sim's own
files, which the settlement then skipped, so enough of them could fill every
batch and starve real desktop calls. Queries now use the SQL form of
isDesktopToolCall (a desktop tool by name, or a VFS read of a granted local
folder) before their limit.

The sweep's horizon is now on the deadline that lapsed, not on the run's
start: Sim does not enforce a run's wall clock, so a long-lived run's
recently overdue call is still settled.

Author: waleedlatif1

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

@@ -764,6 +764,61 @@ describe.runIf(Boolean(redisUrl))("a turn bound to a desktop's background execut
     TURN_WAIT_MS
   )
 
+  it(
+    'reaches an abandoned desktop call however many older Sim-file reads the run left pending',
+    async () => {
+      const desktop = await signedInDesktop()
+      const run = await boundRun(desktop)
+      await db.insert(copilotAsyncToolCalls).values(
+        Array.from({ length: 201 }, () => ({
+          runId: run.runId,
+          toolCallId: generateId(),
+          toolName: 'read',
+          args: { path: 'workspace/notes.md' },
+          createdAt: new Date(Date.now() - 900_000),
+        }))
+      )
+      const abandoned = generateId()
+      await db.insert(copilotAsyncToolCalls).values({
+        runId: run.runId,
+        toolCallId: abandoned,
+        toolName: 'browser_click',
+        args: { ref: 'e1' },
+        createdAt: new Date(Date.now() - 600_000),
+      })
+
+      await runCleanupStaleExecutions()
+
+      expect((await storedCall(abandoned)).status).toBe('failed')
+    },
+    TURN_WAIT_MS
+  )
+
+  it(
+    'settles a call whose window lapsed recently on a run that started long ago',
+    async () => {
+      const desktop = await signedInDesktop()
+      const run = await boundRun(desktop)
+      await db
+        .update(copilotRuns)
+        .set({ startedAt: new Date(Date.now() - 2 * 24 * 3_600_000) })
+        .where(eq(copilotRuns.id, run.runId))
+      const toolCallId = generateId()
+      await db.insert(copilotAsyncToolCalls).values({
+        runId: run.runId,
+        toolCallId,
+        toolName: 'browser_click',
+        args: { ref: 'e1' },
+        createdAt: new Date(Date.now() - 600_000),
+      })
+
+      await runCleanupStaleExecutions()
+
+      expect((await storedCall(toolCallId)).status).toBe('failed')
+    },
+    TURN_WAIT_MS
+  )
+
   it(
     'keeps the pickup window of a call that was never gated when a decision is posted for it',
     async () => {

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

@@ -31,7 +31,8 @@ import {
   isTerminalAsyncStatus,
 } from '@/lib/mothership/async-runs/lifecycle'
 import { DESKTOP_TOOL_PICKUP_GRACE_MS } from '@/lib/mothership/constants'
-import { DESKTOP_TOOL_CALL_NAMES } from '@/lib/mothership/tools/desktop-tools'
+import { NAMED_DESKTOP_TOOL_NAMES } from '@/lib/mothership/tools/desktop-tools'
+import { USER_LOCAL_VFS_ROOT } from '@/lib/mothership/tools/local-filesystem'
 
 const LIVE_RUN_STATUSES: CopilotRunStatus[] = ['active', 'paused_waiting_for_tool', 'resuming']
 
@@ -61,6 +62,26 @@ function pickupOverdueAt(at: SQL) {
     sql`${pickupDeadline} <= ${at}`
   )
 }
+
+function isUserLocalVfsPath(path: SQL) {
+  return sql`(${path} = ${USER_LOCAL_VFS_ROOT} OR ${path} LIKE ${`${USER_LOCAL_VFS_ROOT}/%`})`
+}
+
+/**
+ * The SQL form of `isDesktopToolCall`, so a query limits only over calls the desktop runs: a
+ * desktop tool by name, or a VFS read of a granted local folder (not a read of Sim's own files).
+ */
+const isDesktopToolCallRow = or(
+  inArray(copilotAsyncToolCalls.toolName, [...NAMED_DESKTOP_TOOL_NAMES]),
+  and(
+    inArray(copilotAsyncToolCalls.toolName, ['read', 'grep']),
+    isUserLocalVfsPath(sql`${copilotAsyncToolCalls.args}->>'path'`)
+  ),
+  and(
+    eq(copilotAsyncToolCalls.toolName, 'glob'),
+    isUserLocalVfsPath(sql`${copilotAsyncToolCalls.args}->>'pattern'`)
+  )
+)
 const INBOX_ROW_LIMIT = 500
 
 export interface DesktopDeviceRegistration {
@@ -183,7 +204,7 @@ export async function listDesktopInboxRows(identity: Omit<DesktopDeviceIdentity,
           eq(copilotRuns.desktopDeviceId, identity.deviceId),
           eq(copilotRuns.userId, identity.userId),
           sql`${copilotRuns.startedAt} > now() - make_interval(hours => ${DESKTOP_INBOX_HORIZON_HOURS})`,
-          inArray(copilotAsyncToolCalls.toolName, [...DESKTOP_TOOL_CALL_NAMES]),
+          isDesktopToolCallRow,
           state
         )
       )
@@ -366,7 +387,7 @@ export async function getDesktopToolCallDeadlines(toolCallId: string) {
       and(
         eq(copilotAsyncToolCalls.toolCallId, toolCallId),
         isNotNull(copilotRuns.desktopDeviceId),
-        inArray(copilotAsyncToolCalls.toolName, [...DESKTOP_TOOL_CALL_NAMES])
+        isDesktopToolCallRow
       )
     )
     .limit(1)
@@ -380,28 +401,29 @@ 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. Only runs inside the inbox's
- * horizon are scanned, oldest calls first.
+ * these within its 5 s poll, so anything this finds lost its waiter. Only deadlines that lapsed
+ * within the inbox's horizon are scanned, whatever the run's age, oldest calls first.
  */
 export async function listOverdueDesktopToolCalls(input: { slackMs: number; limit: number }) {
   const overdue = sql`clock_timestamp() - ${input.slackMs} * interval '1 millisecond'`
+  const horizon = sql`clock_timestamp() - make_interval(hours => ${DESKTOP_INBOX_HORIZON_HOURS})`
   const rows = await db
     .select({ toolCallId: copilotAsyncToolCalls.toolCallId })
     .from(copilotAsyncToolCalls)
     .innerJoin(copilotRuns, eq(copilotRuns.id, copilotAsyncToolCalls.runId))
     .where(
       and(
         isNotNull(copilotRuns.desktopDeviceId),
-        sql`${copilotRuns.startedAt} > now() - make_interval(hours => ${DESKTOP_INBOX_HORIZON_HOURS})`,
-        inArray(copilotAsyncToolCalls.toolName, [...DESKTOP_TOOL_CALL_NAMES]),
+        isDesktopToolCallRow,
         or(
-          pickupOverdueAt(overdue),
+          and(pickupOverdueAt(overdue), sql`${pickupDeadline} > ${horizon}`),
           and(
             eq(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.running),
             inArray(copilotAsyncToolCalls.claimedBy, Object.values(DESKTOP_TOOL_CLAIM_OWNER)),
             isNotNull(copilotAsyncToolCalls.executionOwnerToken),
             isNull(copilotAsyncToolCalls.executionRevokedAt),
-            sql`${copilotAsyncToolCalls.executionLeaseExpiresAt} < ${overdue}`
+            sql`${copilotAsyncToolCalls.executionLeaseExpiresAt} < ${overdue}`,
+            sql`${copilotAsyncToolCalls.executionLeaseExpiresAt} > ${horizon}`
           )
         )
       )

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

@@ -68,8 +68,8 @@ export function isClaimedOnPickup(
   )
 }
 
-/** Every tool name {@link isDesktopToolCall} can accept, for narrowing a query before it. */
-export const DESKTOP_TOOL_CALL_NAMES = [...DESKTOP_TOOL_NAMES, 'read', 'grep', 'glob']
+/** The tools that run through the desktop app by name alone; local VFS reads also depend on args. */
+export const NAMED_DESKTOP_TOOL_NAMES: readonly string[] = [...DESKTOP_TOOL_NAMES]
 
 /**
  * The claim owner a desktop background executor records. It is the per-surface owner the chat