@@ -1,4 +1,5 @@
 import { resetEnvFlagsMock, resetEnvironmentUtilsMock, setEnvFlags } from '@sim/testing'
+import { getMockLogger } from '@sim/testing/mocks/logger.mock'
 import {
   mothershipAgentUrlMock,
   mothershipAgentUrlMockFns,
@@ -3607,7 +3608,12 @@ describe('runCopilotLifecycle', () => {
       if (!streamContext) throw new Error('The turn did not start its stream')
       return streamContext
     }
-    return { bodies, lifecycle, resumedWithLostImport, context }
+    /** The reasons the turn logged for force-failing its calls. */
+    const forceFailures = () =>
+      getMockLogger('CopilotLifecycle')
+        .error.mock.calls.map(([message]) => String(message))
+        .filter((message) => message.endsWith('force-failing'))
+    return { bodies, lifecycle, resumedWithLostImport, context, forceFailures }
   }
 
   it('waits on a chat-view import while its lease is renewed, and fails it once the lease lapses', async () => {
@@ -3625,6 +3631,9 @@ describe('runCopilotLifecycle', () => {
       await vi.advanceTimersByTimeAsync(52_000)
       expect((await turn.lifecycle).success).toBe(true)
       expect(turn.resumedWithLostImport()).toBe(true)
+      expect(turn.forceFailures()).toEqual([
+        'Pending tool execution has no live lease past its budget; force-failing',
+      ])
     } finally {
       mothershipAsyncRunsMockFns.mockGetChatViewDesktopLeaseRemainingMs.mockReset()
       vi.useRealTimers()
@@ -3646,6 +3655,9 @@ describe('runCopilotLifecycle', () => {
       await vi.advanceTimersByTimeAsync(32_000)
       expect((await turn.lifecycle).success).toBe(true)
       expect(turn.resumedWithLostImport()).toBe(true)
+      expect(turn.forceFailures()).toEqual([
+        'Pending tool execution has no live lease past its budget; force-failing',
+      ])
     } finally {
       mothershipAsyncRunsMockFns.mockGetChatViewDesktopLeaseRemainingMs.mockReset()
       vi.useRealTimers()
@@ -3660,9 +3672,18 @@ describe('runCopilotLifecycle', () => {
       const turn = runImportTurn()
       await vi.advanceTimersByTimeAsync(CLIENT_TOOL_RESULT_TIMEOUT_MS - 1_000)
       expect(turn.bodies).toHaveLength(1)
+      const leaseReads =
+        mothershipAsyncRunsMockFns.mockGetChatViewDesktopLeaseRemainingMs.mock.calls.length
       await vi.advanceTimersByTimeAsync(2_000)
+      // At the cap the call is given up without reading its lease.
+      expect(
+        mothershipAsyncRunsMockFns.mockGetChatViewDesktopLeaseRemainingMs.mock.calls.length
+      ).toBe(leaseReads)
       expect((await turn.lifecycle).success).toBe(true)
       expect(turn.resumedWithLostImport()).toBe(true)
+      expect(turn.forceFailures()).toEqual([
+        'Pending tool execution reached the client tool result cap; force-failing',
+      ])
     } finally {
       mothershipAsyncRunsMockFns.mockGetChatViewDesktopLeaseRemainingMs.mockReset()
       vi.useRealTimers()
@@ -3682,6 +3703,9 @@ describe('runCopilotLifecycle', () => {
       await vi.advanceTimersByTimeAsync(10_000)
       expect((await turn.lifecycle).success).toBe(true)
       expect(turn.resumedWithLostImport()).toBe(true)
+      expect(turn.forceFailures()).toEqual([
+        'Pending tool execution lease could not be read for a whole lease; force-failing',
+      ])
     } finally {
       mothershipAsyncRunsMockFns.mockGetChatViewDesktopLeaseRemainingMs.mockReset()
       vi.useRealTimers()
@@ -3702,6 +3726,9 @@ describe('runCopilotLifecycle', () => {
       await vi.advanceTimersByTimeAsync(20_000)
       expect((await turn.lifecycle).success).toBe(true)
       expect(turn.resumedWithLostImport()).toBe(true)
+      expect(turn.forceFailures()).toEqual([
+        'Pending tool execution lease could not be read for a whole lease; force-failing',
+      ])
     } finally {
       mothershipAsyncRunsMockFns.mockGetChatViewDesktopLeaseRemainingMs.mockReset()
       vi.useRealTimers()
 
@@ -103,6 +103,33 @@ const LEASE_LOOKUP_RETRY_MS = 5_000
 /** How long one lease lookup may take before it counts as failed. */
 const LEASE_LOOKUP_TIMEOUT_MS = 5_000
 
+/** The resume wait's watch over one pending tool call. */
+interface PendingToolWatchdog {
+  promise: Promise<AsyncCompletionSignal>
+  settlement: Promise<{ toolCallId: string; promise: Promise<AsyncCompletionSignal> }>
+  deadlineAt: number
+  waitBudgetMs: number
+  /** When this wait began. */
+  startedAt: number
+  /** Past this, the call is given up however its lease stands: any client tool's cap. */
+  ceilingAt: number
+  /** Why the deadline was moved past the plain budget, if it was. */
+  extendedBy?: 'lease' | 'lease_lookup'
+  /** Until when a failing lease lookup is retried before the call is given up. */
+  leaseLookupRetryUntil?: number
+}
+
+/** Why a pending call's wait ran out, in the words its force-fail is logged with. */
+function pendingToolExpiryMessage(watchdog: PendingToolWatchdog, now: number): string {
+  if (!watchdog.extendedBy)
+    return 'Pending tool execution exceeded its resume wait budget; force-failing'
+  if (now >= watchdog.ceilingAt)
+    return 'Pending tool execution reached the client tool result cap; force-failing'
+  if (watchdog.leaseLookupRetryUntil !== undefined)
+    return 'Pending tool execution lease could not be read for a whole lease; force-failing'
+  return 'Pending tool execution has no live lease past its budget; force-failing'
+}
+
 /** A pending call's chat-view lease, or why it could not be read within `timeoutMs`. */
 async function readLeaseWithin(
   toolCallId: string,
@@ -1390,26 +1417,7 @@ async function runCheckpointLoop(
       })
       let maximumWaitBudgetMs = 0
       let timedOutCount = 0
-      const pendingWatchdogs = new Map<
-        string,
-        {
-          promise: Promise<AsyncCompletionSignal>
-          settlement: Promise<{
-            toolCallId: string
-            promise: Promise<AsyncCompletionSignal>
-          }>
-          deadlineAt: number
-          waitBudgetMs: number
-          /** When this wait began. */
-          startedAt: number
-          /** Past this, the call is given up however its lease stands: any client tool's cap. */
-          ceilingAt: number
-          /** Why the deadline was moved past the plain budget, if it was. */
-          extendedBy?: 'lease' | 'lease_lookup'
-          /** Until when a failing lease lookup is retried before the call is given up. */
-          leaseLookupRetryUntil?: number
-        }
-      >()
+      const pendingWatchdogs = new Map<string, PendingToolWatchdog>()
 
       /**
        * A long-running approval must not lend its deadline to an unrelated
@@ -1450,59 +1458,62 @@ async function runCheckpointLoop(
             context.pendingToolPromises.get(toolCallId) === watchdog.promise
         )
         // A desktop import the chat view is running renews its lease while it works: its budget
-        // runs to the end of that lease, and only a lapsed lease fails it.
+        // runs to the end of that lease, and only a lapsed lease fails it. At its ceiling a call is
+        // given up however its lease stands, so its lease is not read.
         // A lookup that fails says nothing about the lease, so it is retried, for at most one lease.
         // Each lookup is bounded, so a stalled read cannot hold the wait past its deadlines or Stop.
+        const leaseChecked = overdueTools.filter(([, watchdog]) => now < watchdog.ceilingAt)
         const leases = await Promise.all(
-          overdueTools.map(([toolCallId]) =>
+          leaseChecked.map(([toolCallId]) =>
             readLeaseWithin(toolCallId, LEASE_LOOKUP_TIMEOUT_MS, options.abortSignal)
           )
         )
         if (isAborted(options, context)) break
-        const expiredTools = overdueTools.filter(([toolCallId, watchdog], index) => {
-          // A call replaced while its lease was read belongs to its new watchdog.
-          if (context.pendingToolPromises.get(toolCallId) !== watchdog.promise) return false
-          const lease = leases[index]
-          const checkedAt = Date.now()
-          if (checkedAt >= watchdog.ceilingAt) return true
-          const extendTo = (deadlineAt: number, reason: 'lease' | 'lease_lookup') => {
-            watchdog.deadlineAt = Math.min(deadlineAt, watchdog.ceilingAt)
-            watchdog.extendedBy = reason
-            maximumWaitBudgetMs = Math.max(
-              maximumWaitBudgetMs,
-              watchdog.deadlineAt - watchdog.startedAt
-            )
-            return false
-          }
-          if ('error' in lease) {
-            watchdog.leaseLookupRetryUntil ??= checkedAt + SIM_TOOL_EXECUTION_LEASE_SECONDS * 1000
-            if (checkedAt >= watchdog.leaseLookupRetryUntil) return true
-            logger.warn('Could not read a pending tool call lease; checking again', {
-              toolCallId,
-              error: getErrorMessage(lease.error),
-            })
-            return extendTo(checkedAt + LEASE_LOOKUP_RETRY_MS, 'lease_lookup')
-          }
-          watchdog.leaseLookupRetryUntil = undefined
-          if (typeof lease.remainingMs !== 'number' || lease.remainingMs <= 0) return true
-          return extendTo(checkedAt + lease.remainingMs + LEASE_RECHECK_SLACK_MS, 'lease')
-        })
+        const expiredTools = [
+          ...overdueTools.filter(
+            ([toolCallId, watchdog]) =>
+              now >= watchdog.ceilingAt &&
+              context.pendingToolPromises.get(toolCallId) === watchdog.promise
+          ),
+          ...leaseChecked.filter(([toolCallId, watchdog], index) => {
+            // A call replaced while its lease was read belongs to its new watchdog.
+            if (context.pendingToolPromises.get(toolCallId) !== watchdog.promise) return false
+            const lease = leases[index]
+            const checkedAt = Date.now()
+            const extendTo = (deadlineAt: number, reason: 'lease' | 'lease_lookup') => {
+              watchdog.deadlineAt = Math.min(deadlineAt, watchdog.ceilingAt)
+              watchdog.extendedBy = reason
+              maximumWaitBudgetMs = Math.max(
+                maximumWaitBudgetMs,
+                watchdog.deadlineAt - watchdog.startedAt
+              )
+              return false
+            }
+            if ('error' in lease) {
+              watchdog.leaseLookupRetryUntil ??= checkedAt + SIM_TOOL_EXECUTION_LEASE_SECONDS * 1000
+              if (checkedAt >= watchdog.leaseLookupRetryUntil) return true
+              logger.warn('Could not read a pending tool call lease; checking again', {
+                toolCallId,
+                error: getErrorMessage(lease.error),
+              })
+              return extendTo(checkedAt + LEASE_LOOKUP_RETRY_MS, 'lease_lookup')
+            }
+            watchdog.leaseLookupRetryUntil = undefined
+            if (typeof lease.remainingMs !== 'number' || lease.remainingMs <= 0) return true
+            return extendTo(checkedAt + lease.remainingMs + LEASE_RECHECK_SLACK_MS, 'lease')
+          }),
+        ]
         if (expiredTools.length > 0) {
           await Promise.all(
             expiredTools.map(async ([toolCallId, watchdog]) => {
               const waitedMs = Date.now() - watchdog.startedAt
-              logger.error(
-                watchdog.extendedBy
-                  ? 'Pending tool execution outlived its renewed lease or its cap; force-failing'
-                  : 'Pending tool execution exceeded its resume wait budget; force-failing',
-                {
-                  checkpointId: continuation.checkpointId,
-                  toolCallId,
-                  waitBudgetMs: watchdog.waitBudgetMs,
-                  waitedMs,
-                  ...(watchdog.extendedBy ? { extendedBy: watchdog.extendedBy } : {}),
-                }
-              )
+              logger.error(pendingToolExpiryMessage(watchdog, now), {
+                checkpointId: continuation.checkpointId,
+                toolCallId,
+                waitBudgetMs: watchdog.waitBudgetMs,
+                waitedMs,
+                ...(watchdog.extendedBy ? { extendedBy: watchdog.extendedBy } : {}),
+              })
               await failPendingToolCall(toolCallId, context, execContext)
               if (context.pendingToolPromises.get(toolCallId) === watchdog.promise) {
                 context.pendingToolPromises.delete(toolCallId)
 
@@ -158,18 +158,18 @@ describe('an import keeps its lease while it runs', () => {
   const LEASE_MS = 60_000
   /**
    * The server's side of the lease, by the rules the lease route applies: the claim (which the
-   * desktop makes as it starts building the manifest) takes a lease, and a renewal extends it only
-   * while it is live; a refused renewal answers 410.
+   * desktop makes before it scans, within its 8 s authorization timeout) takes a lease, and a
+   * renewal extends it only while it is live; a refused renewal answers 410.
    */
   let server: {
     leaseUntil: number
     claimed: boolean
     stopped: boolean
     renewalsReceived: number
-    transient: number[]
-    /** How long the server takes to answer the next renewal it receives. */
-    nextAnswerDelayMs: number
+    /** How the server answers the renewals it receives next: a failure that may pass, or as usual. */
+    answers: (number | 'usual')[]
   }
+  let claimMs: number
   let scanMs: number
   let finishUpload: () => void
   const leaseLive = () => Date.now() < server.leaseUntil
@@ -183,13 +183,14 @@ describe('an import keeps its lease while it runs', () => {
       claimed: false,
       stopped: false,
       renewalsReceived: 0,
-      transient: [],
-      nextAnswerDelayMs: 0,
+      answers: [],
     }
+    claimMs = 0
     scanMs = 0
     mocks.invoke.mockImplementation(async (request: { operation: string }) => {
       if (request.operation !== 'manifest')
         return { ok: true, data: { kind: 'chunk', bytes: new Uint8Array([65, 66, 67]), eof: true } }
+      await sleep(claimMs)
       server.claimed = true
       server.leaseUntil = Date.now() + LEASE_MS
       await sleep(scanMs)
@@ -204,14 +205,10 @@ describe('an import keeps its lease while it runs', () => {
     mocks.json.mockImplementation(async (contract: unknown) => {
       if (contract !== renewDesktopToolLeaseContract) return { folder: { id: 'created-folder' } }
       server.renewalsReceived += 1
-      const delayMs = server.nextAnswerDelayMs
-      server.nextAnswerDelayMs = 0
-      const transient = server.transient.shift()
-      const refused = server.stopped || !server.claimed || !leaseLive()
-      if (!transient && !refused) server.leaseUntil = Date.now() + LEASE_MS
-      await sleep(delayMs)
-      if (transient) return answer(transient)
-      if (refused) return answer(410)
+      const transient = server.answers.shift()
+      if (typeof transient === 'number') return answer(transient)
+      if (server.stopped || !server.claimed || !leaseLive()) return answer(410)
+      server.leaseUntil = Date.now() + LEASE_MS
       return { renewed: true }
     })
   })
@@ -233,11 +230,8 @@ describe('an import keeps its lease while it runs', () => {
     expect(leaseLive()).toBe(false)
   })
 
-  it('a refusal of a renewal sent before the claim does not stop it, however late it arrives', async () => {
-    // The first renewal goes out before the desktop claims the call; its 410 arrives only after
-    // the manifest confirmed the claim.
-    server.nextAnswerDelayMs = 5_000
-    scanMs = 1_000
+  it('keeps renewing when the desktop takes most of its authorization timeout to claim', async () => {
+    claimMs = 7_000
     const run = executeNativeFileTool('tool', 'import_local_files')
     await vi.advanceTimersByTimeAsync(90_000)
     expect(leaseLive()).toBe(true)
@@ -259,9 +253,12 @@ describe('an import keeps its lease while it runs', () => {
   })
 
   it('keeps renewing through failures that may pass', async () => {
-    server.transient = [401, 429, 503]
+    // Beats at 20 s, 60 s and 100 s fail; the beats between them renew. Stopping at any of the
+    // failures would let the lease lapse by 140 s.
+    server.answers = [401, 'usual', 429, 'usual', 503]
     const run = executeNativeFileTool('tool', 'import_local_files')
-    await vi.advanceTimersByTimeAsync(90_000)
+    await vi.advanceTimersByTimeAsync(150_000)
+    expect(server.renewalsReceived).toBe(7)
     expect(leaseLive()).toBe(true)
     finishUpload()
     await run
 
@@ -112,24 +112,19 @@ export async function importNativeFiles(
 }
 
 /**
- * Renews an import's lease from the moment its manifest is requested, every heartbeat, the way a
+ * Renews an import's lease every heartbeat from the moment its manifest is requested, the way a
  * desktop renews a bound call, so a slow directory scan cannot outlast the lease the claim took.
- * The claim lands while the manifest is being built, so a refusal (410) counts only once the
- * manifest confirmed the claim: then the call was stopped, settled, or its lease lapsed, and
+ * The desktop claims the call before it scans, within its authorization timeout, which is well
+ * inside one heartbeat: every renewal follows the claim, and the claim's own lease covers the
+ * first beat. A refusal (410) means the call was stopped, settled, or its lease lapsed, and
  * renewing stops. Any other failure may pass, and the next beat tries again.
  */
-function keepImportLeased(toolCallId: string): { claimed(): void; stop(): void } {
-  let claimed = false
-  let stopped = false
-  const renew = () => {
-    if (stopped) return
-    // Whether the claim was confirmed when this renewal was sent: a refusal of one sent before it
-    // may arrive after, and says nothing about the running import.
-    const sentAfterClaim = claimed
+function keepImportLeased(toolCallId: string): { stop(): void } {
+  const timer = setInterval(() => {
     requestJson(renewDesktopToolLeaseContract, { body: { toolCallId, chatView: true } }).catch(
       (error) => {
-        if (sentAfterClaim && error instanceof ApiClientError && error.status === 410) {
-          stop()
+        if (error instanceof ApiClientError && error.status === 410) {
+          clearInterval(timer)
           return
         }
         logger.warn('Could not renew the import lease; trying again next beat', {
@@ -138,20 +133,8 @@ function keepImportLeased(toolCallId: string): { claimed(): void; stop(): void }
         })
       }
     )
-  }
-  const timer = setInterval(renew, SIM_TOOL_EXECUTION_HEARTBEAT_MS)
-  const stop = () => {
-    stopped = true
-    clearInterval(timer)
-  }
-  renew()
-  return {
-    claimed() {
-      claimed = true
-      renew()
-    },
-    stop,
-  }
+  }, SIM_TOOL_EXECUTION_HEARTBEAT_MS)
+  return { stop: () => clearInterval(timer) }
 }
 
 /** The server claims imports before reading their manifest, preventing replayed uploads. */
@@ -192,7 +175,6 @@ export async function executeNativeFileTool(
     if (response.data.kind === 'chunk') throw new Error('Unexpected chunk outside an import.')
     let completion
     if (response.data.kind === 'manifest') {
-      lease?.claimed()
       completion = localFileImportCompletion(
         await importNativeFiles(toolCallId, response.data, signal)
       )