@@ -262,6 +262,56 @@ describe.runIf(Boolean(redisUrl))('Chat runs no controller owns', () => {
     return { ...run, marker: chat?.conversationId ?? null }
   }
 
+  describe('a Sim claim past its start window', () => {
+    async function lateTool(
+      runId: string,
+      fields: Partial<{ status: 'running'; claimedBy: string }> = {}
+    ) {
+      const tool = await dispatchedTool(runId)
+      await db
+        .update(copilotAsyncToolCalls)
+        .set({ executionDeadlineAt: sql`clock_timestamp() + interval '30 seconds'`, ...fields })
+        .where(eq(copilotAsyncToolCalls.toolCallId, tool.toolCallId))
+      return tool
+    }
+
+    async function storedTool(toolCallId: string) {
+      const [row] = await db
+        .select()
+        .from(copilotAsyncToolCalls)
+        .where(eq(copilotAsyncToolCalls.toolCallId, toolCallId))
+      return row
+    }
+
+    it('leaves an admitted pending call unclaimed for its caller to settle as never run', async () => {
+      const run = await admittedRun()
+      const tool = await lateTool(run.runId)
+
+      expect(await claimToolExecution(tool)).toEqual({ outcome: 'too_late' })
+      expect(await storedTool(tool.toolCallId)).toMatchObject({
+        status: 'pending',
+        executionStartedAt: null,
+        executionOwnerToken: null,
+      })
+    })
+
+    it('reports a stopped run as closed before the start window', async () => {
+      const run = await admittedRun({ stopped: true })
+      const tool = await lateTool(run.runId)
+
+      expect(await claimToolExecution(tool)).toEqual({ outcome: 'closed' })
+    })
+
+    it('still claims a call a client already claimed, and one without a deadline', async () => {
+      const run = await admittedRun()
+      const clientClaimed = await lateTool(run.runId, { status: 'running', claimedBy: 'client' })
+      const undated = await dispatchedTool(run.runId)
+
+      expect(await claimToolExecution(clientClaimed)).toEqual({ outcome: 'claimed' })
+      expect(await claimToolExecution(undated)).toEqual({ outcome: 'claimed' })
+    })
+  })
+
   it('settles a run whose controller died once its recovery window has passed', async () => {
     const orphan = await admittedRun({ idleMinutes: 90, status: 'paused_waiting_for_tool' })
 
 
@@ -868,6 +868,12 @@ export type ToolExecutionClaim =
   /** Already claimed or settled. */
   | { outcome: 'existing' }
 
+/** A Sim handler's claim, which also reports an unclaimed call too late to start. */
+export type SimToolExecutionClaim =
+  | ToolExecutionClaim
+  /** Admitted but unclaimed, with too little of its deadline left to start: nothing ran it. */
+  | { outcome: 'too_late' }
+
 /**
  * Every condition at once, typed as a condition: drizzle's `and` may return undefined, which a
  * negation would render as `NOT (NULL)` and match nothing.
@@ -904,6 +910,13 @@ const tooLateToStart = sql`(${copilotAsyncToolCalls.executionDeadlineAt} IS NOT
  */
 const pastResumeGiveUp = sql`(${copilotAsyncToolCalls.executionDeadlineAt} IS NOT NULL AND ${copilotAsyncToolCalls.executionDeadlineAt} + ${TOOL_WATCHDOG_RESUME_GRACE_MS} * interval '1 millisecond' <= clock_timestamp())`
 
+/** A call nothing claimed or started whose deadline leaves too little to start it. */
+const pendingTooLateToStart = allOf(
+  eq(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.pending),
+  isNull(copilotAsyncToolCalls.executionStartedAt),
+  tooLateToStart
+)
+
 /**
  * A Sim execution whose owner died before recording a result: its lease lapsed, which a live
  * owner's heartbeat never lets happen. A takeover runs it again until it has started
@@ -932,11 +945,12 @@ const rerunnableSimExecution = allOf(
  * Sim claims a call it is about to execute under an execution lease; a terminal result never
  * releases it. The claim takes a call's first execution, or re-runs one whose owner died
  * mid-execution: the new owner token fences the dead owner out, since its renewals and its
- * result both require the token and an unexpired lease.
+ * result both require the token and an unexpired lease. A pending call too late to start is left
+ * unclaimed, under the same admission check, for its caller to settle as never run.
  */
 export async function claimToolExecution(
   owner: SimToolExecutionOwner
-): Promise<ToolExecutionClaim> {
+): Promise<SimToolExecutionClaim> {
   return await claimUnderRunAdmission(owner, 'sim-stream', true, async (tx, thisCall) => {
     const startedAt = new Date()
     const [claimed] = await traceMothershipQuery('UPDATE', 'copilot_async_tool_calls', () =>
@@ -961,7 +975,8 @@ export async function claimToolExecution(
                 inArray(copilotAsyncToolCalls.status, [
                   ASYNC_TOOL_STATUS.pending,
                   ASYNC_TOOL_STATUS.running,
-                ])
+                ]),
+                not(pendingTooLateToStart)
               ),
               interruptedSimExecution
             )
@@ -971,10 +986,13 @@ export async function claimToolExecution(
     )
     if (claimed) return { outcome: 'claimed' } as const
     const [record] = await traceMothershipQuery('SELECT', 'copilot_async_tool_calls', () =>
-      tx.select({ id: copilotAsyncToolCalls.id }).from(copilotAsyncToolCalls).where(thisCall)
+      tx
+        .select({ tooLate: sql<boolean>`${pendingTooLateToStart}` })
+        .from(copilotAsyncToolCalls)
+        .where(thisCall)
     )
     if (!record) throw new Error('Tool execution record is unavailable')
-    return { outcome: 'existing' } as const
+    return record.tooLate ? ({ outcome: 'too_late' } as const) : ({ outcome: 'existing' } as const)
   })
 }
 
 
@@ -15,9 +15,9 @@ import {
   prepareWorkbenchAccess,
   recordSimSandboxProcess,
   renewSimToolExecutionLease,
+  type SimToolExecutionClaim,
   settleSimSandboxProcess,
   settleSimToolExecution,
-  type ToolExecutionClaim,
 } from '@/lib/mothership/async-runs/repository'
 import { TraceAttr } from '@/lib/mothership/generated/trace-attributes-v1'
 import { TraceSpan } from '@/lib/mothership/generated/trace-spans-v1'
@@ -30,7 +30,7 @@ export interface ToolExecutionLifetime {
   readonly signal: AbortSignal
   readonly owner?: SimToolExecutionOwner
   complete(input: CompleteAsyncToolCallInput): Promise<void>
-  claim(runId: string, userId: string): Promise<ToolExecutionClaim>
+  claim(runId: string, userId: string): Promise<SimToolExecutionClaim>
   hold<T>(work: Promise<T>): Promise<T>
 }
 
 
@@ -369,8 +369,10 @@ describe('executeToolAndReport provenance isolation', () => {
   beforeEach(() => {
     executeTool.mockReset()
     completeAsyncToolCall.mockResolvedValue(null)
+    completePendingAsyncToolCall.mockReset()
     markAsyncToolRunning.mockResolvedValue(null)
     upsertAsyncToolCall.mockResolvedValue(null)
+    claimToolExecution.mockReset()
     claimToolExecution.mockResolvedValue({ outcome: 'claimed' })
     settleSimToolExecution.mockResolvedValue(undefined)
     waitForToolConfirmation.mockReset()
@@ -698,7 +700,8 @@ describe('executeToolAndReport provenance isolation', () => {
     expect(tool.error).toBe(TOOL_DEADLINE_BEFORE_START_MESSAGE)
   })
 
-  it('settles an unclaimed call past its start window as never run, without claiming it', async () => {
+  it('settles a call its claim found too late to start as never run, without claiming it', async () => {
+    claimToolExecution.mockResolvedValueOnce({ outcome: 'too_late' })
     completePendingAsyncToolCall.mockImplementationOnce(async (input) => ({ ...input }))
     const tool: ToolCallState = {
       ...buildPendingToolCall(),
@@ -711,7 +714,6 @@ describe('executeToolAndReport provenance isolation', () => {
       resolvedSecretTraceRegistry: new ResolvedSecretTraceRegistry(),
     })
 
-    expect(claimToolExecution).not.toHaveBeenCalled()
     expect(executeTool).not.toHaveBeenCalled()
     expect(completePendingAsyncToolCall).toHaveBeenCalledExactlyOnceWith(
       expect.objectContaining({
@@ -727,22 +729,25 @@ describe('executeToolAndReport provenance isolation', () => {
     })
   })
 
-  it('leaves a call past its start window that is already claimed to its claim', async () => {
-    completePendingAsyncToolCall.mockResolvedValueOnce(null)
+  it('settles the call of a stopped run as stopped even past its start window', async () => {
+    claimToolExecution.mockResolvedValueOnce({ outcome: 'closed' })
+    completePendingAsyncToolCall.mockImplementation(async (input) => ({ ...input }))
     const tool: ToolCallState = {
       ...buildPendingToolCall(),
       name: 'generate_audio',
       deadlineAt: Date.now() + 30_000,
     }
-    await executeToolAndReport(tool.id, buildStreamingContext(tool), {
+    const completion = await executeToolAndReport(tool.id, buildStreamingContext(tool), {
       userId: 'user-1',
       workflowId: 'workflow-1',
       resolvedSecretTraceRegistry: new ResolvedSecretTraceRegistry(),
     })
 
-    expect(claimToolExecution).toHaveBeenCalledOnce()
-    expect(executeTool).not.toHaveBeenCalled()
-    expect(tool.error).toBe(TOOL_DEADLINE_BEFORE_START_MESSAGE)
+    expect(completePendingAsyncToolCall).not.toHaveBeenCalled()
+    expect(completion).toMatchObject({
+      status: 'cancelled',
+      message: 'Run stopped before tool admission',
+    })
   })
 
   it('claims a call without a deadline without trying to settle it first', async () => {
 
@@ -754,22 +754,22 @@ async function executeToolAndReportInner(
   })
   /** A re-run after a takeover gets what remains of the call's first deadline, never a fresh one. */
   if (record?.executionDeadlineAt) toolCall.deadlineAt = record.executionDeadlineAt.getTime()
-  // Too late to start: an unclaimed call is settled as never run rather than claimed first, so a
-  // crash before its handler refuses to start cannot leave it recovered as an unknown outcome.
-  if (
-    toolStartWindowClosed(toolCall.deadlineAt, Date.now()) &&
-    (await failUnstartedToolCall(
-      toolCall.id,
-      context,
-      execContext,
-      TOOL_DEADLINE_BEFORE_START_MESSAGE
-    ))
-  )
-    return terminalCompletionFromToolCall(toolCall)
   if (context.runId) {
     const claim = await lifetime.claim(context.runId, execContext.userId)
     if (claim.outcome === 'closed') return settleCancelled('Run stopped before tool admission')
-    if (claim.outcome === 'existing') {
+    // Settled as never run instead of claimed, so a crash before the handler refuses to start
+    // cannot leave it recovered as an unknown outcome. Losing that settlement leaves another writer's.
+    if (
+      claim.outcome === 'too_late' &&
+      (await failUnstartedToolCall(
+        toolCall.id,
+        context,
+        execContext,
+        TOOL_DEADLINE_BEFORE_START_MESSAGE
+      ))
+    )
+      return terminalCompletionFromToolCall(toolCall)
+    if (claim.outcome !== 'claimed') {
       /** The winning controller owns execution; this promise observes its durable result. */
       const completion = await waitForToolConfirmation(
         toolCall.id,