@@ -346,9 +346,9 @@ async function releaseChatLocks(fences: ChatLockFence[]): Promise<void> {
   )
 }
 
-async function readSweepCursor(): Promise<string | undefined> {
+async function readSweepCursor(key = SWEEP_CURSOR_KEY): Promise<string | undefined> {
   try {
-    return (await getRedisClient()?.get(SWEEP_CURSOR_KEY)) ?? undefined
+    return (await getRedisClient()?.get(key)) ?? undefined
   } catch (error) {
     logger.warn('Orphaned-run sweep cursor is unreadable; starting from the first run', {
       error: getErrorMessage(error),
@@ -357,12 +357,12 @@ async function readSweepCursor(): Promise<string | undefined> {
   }
 }
 
-async function writeSweepCursor(cursor: string | undefined): Promise<void> {
+async function writeSweepCursor(cursor: string | undefined, key = SWEEP_CURSOR_KEY): Promise<void> {
   try {
     const redis = getRedisClient()
     if (!redis) return
-    if (cursor) await redis.set(SWEEP_CURSOR_KEY, cursor, 'EX', SWEEP_CURSOR_TTL_SECONDS)
-    else await redis.del(SWEEP_CURSOR_KEY)
+    if (cursor) await redis.set(key, cursor, 'EX', SWEEP_CURSOR_TTL_SECONDS)
+    else await redis.del(key)
   } catch (error) {
     logger.warn('Orphaned-run sweep cursor could not be saved', { error: getErrorMessage(error) })
   }
@@ -489,19 +489,30 @@ export async function settleRunWithoutAccess(run: UnownedRun): Promise<boolean>
  * worth checking yet.
  */
 const ABANDONED_RUN_IDLE_MS = 60_000
+/** Where the last takeover scan stopped, so live runs it skipped never hide the runs after them. */
+export const ABANDONED_RUN_CURSOR_KEY = 'copilot:abandoned-runs:scan-cursor'
 
 /**
  * Runs an interactive controller abandoned that a takeover can still resume: unfinished and
- * not stopped, saved with their recovery intent, idle for a minute but within the recovery window, and
- * with no controller holding their chat lock. Empty while the locks cannot be read, since then
- * no run is provably abandoned.
+ * not stopped, saved with their recovery intent, idle for a minute but within the recovery
+ * window, and with no controller holding their chat lock. Each scan examines at most
+ * `maxExamined` candidates, resuming after the last one the previous scan examined and wrapping
+ * to the first, so runs whose controller is alive cost one examination per pass and never
+ * crowd out an abandoned run. Empty while the locks cannot be read, since then no run is
+ * provably abandoned.
  */
-export async function findAbandonedRecoverableRuns(limit: number): Promise<UnownedRun[]> {
+export async function findAbandonedRecoverableRuns(
+  limit: number,
+  { pageSize = SWEEP_BATCH_SIZE, maxExamined = SWEEP_BATCH_SIZE } = {}
+): Promise<UnownedRun[]> {
   const abandoned: UnownedRun[] = []
-  let after: string | undefined
-  /** Pages past runs whose controller is alive, so they never crowd out an abandoned one. */
-  while (abandoned.length < limit) {
-    const candidates: UnownedRun[] = await db
+  const start = await readSweepCursor(ABANDONED_RUN_CURSOR_KEY)
+  let cursor = start
+  let wrapped = start === undefined
+  let examined = 0
+  while (abandoned.length < limit && examined < maxExamined) {
+    const size = Math.min(pageSize, maxExamined - examined)
+    const page: UnownedRun[] = await db
       .select(unownedRunColumns)
       .from(copilotRuns)
       .where(
@@ -512,23 +523,35 @@ export async function findAbandonedRecoverableRuns(limit: number): Promise<Unown
           idleFor(ABANDONED_RUN_IDLE_MS),
           not(idleFor(ORPHANED_RUN_GRACE_MS)),
           not(stopRequested),
-          after ? gt(copilotRuns.id, after) : undefined
+          cursor ? gt(copilotRuns.id, cursor) : undefined,
+          wrapped && start ? lte(copilotRuns.id, start) : undefined
         )
       )
       .orderBy(asc(copilotRuns.id))
-      .limit(SWEEP_BATCH_SIZE)
-    if (candidates.length === 0) break
-    after = candidates[candidates.length - 1].id
+      .limit(size)
+    let locked: Set<string>
     try {
-      const locked = await findStreamsHoldingChatLock(candidates)
-      abandoned.push(...candidates.filter((run) => !locked.has(run.streamId)))
+      locked = page.length > 0 ? await findStreamsHoldingChatLock(page) : new Set()
     } catch (error) {
       logger.warn('Chat stream ownership is unreadable; no run is taken over this round', {
         error: getErrorMessage(error),
       })
       return []
     }
-    if (candidates.length < SWEEP_BATCH_SIZE) break
+    for (const run of page) {
+      examined++
+      cursor = run.id
+      if (locked.has(run.streamId)) continue
+      abandoned.push(run)
+      if (abandoned.length === limit) break
+    }
+    if (abandoned.length < limit && page.length < size) {
+      /** The end of the table: wrap once to cover the runs before the starting point. */
+      cursor = undefined
+      if (wrapped) break
+      wrapped = true
+    }
   }
-  return abandoned.slice(0, limit)
+  await writeSweepCursor(cursor, ABANDONED_RUN_CURSOR_KEY)
+  return abandoned
 }
@@ -1144,7 +1144,9 @@ export async function recordSimSandboxProcess(
           throw new Error('Sandbox command admission is closed or unavailable')
         }
         const { id, sandboxId, sessionKey } = input.process
-        const entry = JSON.stringify({ [id]: { sandboxId, sessionKey, settled: false } })
+        const entry = JSON.stringify({
+          [id]: { sandboxId, sessionKey, settled: false, ownerToken: input.ownerToken },
+        })
         const [row] = await tx
           .update(copilotAsyncToolCalls)
           .set({
@@ -1297,7 +1299,7 @@ export async function prepareWorkbenchAccess(
       throw new Error('Workbench does not belong to this tool execution')
     }
     const [claim] = await tx
-      .select({ id: copilotAsyncToolCalls.id })
+      .select({ processes: copilotAsyncToolCalls.sandboxProcesses })
       .from(copilotAsyncToolCalls)
       .where(
         and(
@@ -1386,7 +1388,19 @@ export async function prepareWorkbenchAccess(
           )
         )
       )
-    const processes = previous.flatMap((row) =>
+    /**
+     * A re-run's earlier attempts may have left commands running on the remote workbench, which
+     * outlive the Sim process that started them; they are stopped like any earlier call's.
+     */
+    const earlierAttempts = {
+      toolCallId: input.toolCallId,
+      processes: Object.fromEntries(
+        Object.entries(claim.processes).filter(
+          ([, process]) => process.ownerToken !== input.ownerToken
+        )
+      ),
+    }
+    const processes = [...previous, earlierAttempts].flatMap((row) =>
       Object.entries(row.processes).flatMap(([id, process]) =>
         process.settled
           ? []
 
@@ -7,6 +7,7 @@ import { deleteWorkspaceFixture, insertWorkspaceFixture } from '@sim/db/testing/
  * duplicate-send path does, then answers the tool resume that follows.
  */
 import { authMock, authMockFns } from '@sim/testing/mocks/auth.mock'
+import { envFlagsMock, resetEnvFlagsMock, setEnvFlags } from '@sim/testing/mocks/env-flags.mock'
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const { redisUrl, inheritedEnv, worker } = await vi.hoisted(async () => {
@@ -47,12 +48,13 @@ const { redisUrl, inheritedEnv, worker } = await vi.hoisted(async () => {
     REDIS_URL: process.env.REDIS_URL,
     SIM_AGENT_API_URL: process.env.SIM_AGENT_API_URL,
   }
-  process.env.REDIS_URL = url
+  if (url) process.env.REDIS_URL = url
   process.env.SIM_AGENT_API_URL = `http://127.0.0.1:${port}`
   return { redisUrl: url, inheritedEnv, worker: Object.assign(worker, { server }) }
 })
 
 vi.mock('@/lib/auth', () => authMock)
+vi.mock('@/lib/core/config/env-flags', () => envFlagsMock)
 
 import { db } from '@sim/db'
 import {
@@ -74,20 +76,32 @@ import {
   EXHAUSTED_SIM_TOOL_MESSAGE,
   SIM_TOOL_EXECUTION_MAX_ATTEMPTS,
 } from '@/lib/mothership/async-runs/execution-lease'
-import { REVOKED_RUN_ERROR } from '@/lib/mothership/async-runs/orphaned-runs'
+import {
+  ABANDONED_RUN_CURSOR_KEY,
+  findAbandonedRecoverableRuns,
+  REVOKED_RUN_ERROR,
+} from '@/lib/mothership/async-runs/orphaned-runs'
 import {
   claimToolExecution,
   claimWorkflowToolExecution,
+  prepareWorkbenchAccess,
+  recordSimSandboxProcess,
   revokeExhaustedSimToolExecutions,
   upsertAsyncToolCall,
 } from '@/lib/mothership/async-runs/repository'
+import { createTrustedCopilotPrincipal } from '@/lib/mothership/auth/application-delegation'
 import { chatPubSub } from '@/lib/mothership/chat-status'
 import { takeOverAbandonedRuns } from '@/lib/mothership/request/application/abandoned-runs'
+import {
+  RUN_TAKEOVER_AUDIENCE,
+  takeOverStreamRun,
+} from '@/lib/mothership/request/application/recover-stream'
 import {
   createProviderToolCallIdentity,
   scopeProviderToolCallId,
 } from '@/lib/mothership/request/go/tool-call-identity'
 import { chatStreamLockKey } from '@/lib/mothership/request/session/controller-lease'
+import { chatSandboxSessionKey } from '@/lib/mothership/tools/sandbox-session-key'
 import { GET as streamGET } from '@/app/api/copilot/chat/stream/route'
 
 const ownerId = generateId()
@@ -119,12 +133,12 @@ function frameFor(streamId: string, chatId: string) {
  * chat, and the tool's execution lease lapsed with no result recorded.
  */
 async function runAbandonedMidTool(
-  options: { attempts?: number; leaseLive?: boolean; toolName?: string } = {}
+  options: { attempts?: number; leaseLive?: boolean; toolName?: string; runId?: string } = {}
 ) {
   const chatId = generateId()
   chatIds.push(chatId)
   const streamId = generateId()
-  const runId = generateId()
+  const runId = options.runId ?? generateId()
   const request = { message: 'Run the report', userId, messageId: streamId, chatId, workspaceId }
   await db
     .insert(copilotChats)
@@ -304,6 +318,8 @@ describe.runIf(Boolean(redisUrl))('taking over a run whose controller died', ()
 
   beforeEach(async () => {
     worker.requests.length = 0
+    resetEnvFlagsMock()
+    await redis().del(ABANDONED_RUN_CURSOR_KEY)
     await db
       .insert(permissions)
       .values({
@@ -471,4 +487,105 @@ describe.runIf(Boolean(redisUrl))('taking over a run whose controller died', ()
       await db.update(copilotRuns).set({ status: 'cancelled' }).where(eq(copilotRuns.id, runId))
     }
   })
+
+  it('reaches an abandoned run behind live ones, examining a bounded window per scan', async () => {
+    /** The lowest ids, so the scan meets the two live runs before the abandoned one. */
+    const ids = [1, 2, 3].map((n) => `00000000-0000-4000-8000-00000000000${n}`)
+    const live = [
+      await runAbandonedMidTool({ runId: ids[0] }),
+      await runAbandonedMidTool({ runId: ids[1] }),
+    ]
+    const abandoned = await runAbandonedMidTool({ runId: ids[2] })
+    for (const run of live) {
+      await redis().set(chatStreamLockKey(run.chatId), `${run.streamId}\nlive`, 'EX', 60)
+    }
+    try {
+      const bound = { pageSize: 2, maxExamined: 2 }
+      expect(await findAbandonedRecoverableRuns(1, bound)).toEqual([])
+      expect((await findAbandonedRecoverableRuns(1, bound)).map((run) => run.id)).toEqual([
+        abandoned.runId,
+      ])
+    } finally {
+      for (const run of [...live, abandoned]) {
+        await redis().del(chatStreamLockKey(run.chatId))
+        await db
+          .update(copilotRuns)
+          .set({ status: 'cancelled' })
+          .where(eq(copilotRuns.id, run.runId))
+      }
+    }
+  })
+
+  it("hands a re-run the earlier attempt's workbench commands to stop first", async () => {
+    const { chatId, runId, toolCallId } = await runAbandonedMidTool({ leaseLive: true })
+    const sessionKey = chatSandboxSessionKey(chatId)
+    try {
+      await recordSimSandboxProcess({
+        toolCallId,
+        runId,
+        userId,
+        ownerToken: 'dead-controller',
+        process: { id: 'earlier-command', sandboxId: 'sandbox-1', sessionKey },
+      })
+      await db
+        .update(copilotAsyncToolCalls)
+        .set({ executionLeaseExpiresAt: sql`clock_timestamp() - interval '1 second'` })
+        .where(eq(copilotAsyncToolCalls.toolCallId, toolCallId))
+      const successor = { toolCallId, runId, userId, ownerToken: 'successor' }
+      expect(await claimToolExecution(successor)).toEqual({ outcome: 'claimed' })
+      await recordSimSandboxProcess({
+        ...successor,
+        process: { id: 'own-command', sandboxId: 'sandbox-1', sessionKey },
+      })
+
+      const state = await prepareWorkbenchAccess({ ...successor, sessionKey })
+
+      expect(state.processes.map((process) => process.id)).toEqual(['earlier-command'])
+    } finally {
+      await db.update(copilotRuns).set({ status: 'cancelled' }).where(eq(copilotRuns.id, runId))
+    }
+  })
+
+  it('claims no run once its caller is shutting down', async () => {
+    const { chatId, streamId, runId, toolCallId } = await runAbandonedMidTool()
+    const before = await storedRun(runId)
+    const shutdown = new AbortController()
+    shutdown.abort()
+    const principal = createTrustedCopilotPrincipal(
+      { userId, workspaceId, chatId, delegationId: `test:${runId}` },
+      { audience: RUN_TAKEOVER_AUDIENCE, ttlMs: 60_000 }
+    )
+    try {
+      await expect(
+        takeOverStreamRun.execute({
+          principal,
+          input: { streamId },
+          request: { headers: new Headers(), signal: shutdown.signal },
+        })
+      ).rejects.toThrow()
+
+      expect(await storedRun(runId)).toEqual(before)
+      expect(requestsFor(streamId, '/api/mothership')).toHaveLength(0)
+      expect((await storedTool(toolCallId)).attempts).toBe(1)
+      expect(await redis().get(chatStreamLockKey(chatId))).toBeNull()
+    } finally {
+      await db.update(copilotRuns).set({ status: 'cancelled' }).where(eq(copilotRuns.id, runId))
+    }
+  })
+
+  it('leaves a run recoverable when its takeover fails for a reason other than access', async () => {
+    /** Hosted recovery refuses a run saved without its billing admission. */
+    setEnvFlags({ isHosted: true })
+    const { streamId, runId } = await runAbandonedMidTool()
+    const before = await storedRun(runId)
+    try {
+      await takeOverAbandonedRuns()
+
+      expect(await storedRun(runId)).toEqual(before)
+      expect(requestsFor(streamId, '/api/streams/explicit-abort')).toHaveLength(0)
+      expect(requestsFor(streamId, '/api/mothership')).toHaveLength(0)
+    } finally {
+      await db.update(copilotRuns).set({ status: 'cancelled' }).where(eq(copilotRuns.id, runId))
+    }
+  })
 })