@@ -58,6 +58,48 @@ test('a command that arrives while cleanup holds its serial is refused', async (
   expect(tunnels.start).toHaveBeenCalledOnce();
 });
 
+/**
+ * The serial a cleanup is ending is reached only by the cleanup's own dispatches. A reverse command that
+ * arrives while that cleanup is mid-request goes back through the session's closed public route, so nothing
+ * gets mapped at a device that is being disconnected, behind the cleanup's one listing.
+ */
+test('a reverse command that arrives during cleanup is refused, not dispatched at the ending serial', async () => {
+  const runs: string[][] = [];
+  let reportList!: () => void;
+  reverse.listGate = new Promise<void>((resolve) => {
+    reportList = resolve;
+  });
+  const deps = androidDependencies(runs);
+  // The route the reverse manager dispatches through, which is what production hands it.
+  let reverseRoute!: (args: readonly string[]) => Promise<unknown>;
+  deps.android.createPortReverse = async (adb) => {
+    reverseRoute = adb;
+    return reverse;
+  };
+  const session = await createLimrunAndroidSession(ANDROID_SESSION_OPTIONS, deps);
+  // The first command raises the tunnel this session owns, giving cleanup a serial to end.
+  await session.adbProvider.exec(['shell', 'echo', 'ready']);
+  const dispatched = runs.length;
+  try {
+    // Cleanup holds its listing open: its teardown executor is published at the serial it is ending.
+    const cleanup = cleanupLimrunAndroidAdbTunnel(session);
+    await vi.waitFor(() => expect(reverse.list).toHaveBeenCalledOnce());
+
+    await expect(reverseRoute(['reverse', 'tcp:9001', 'tcp:8001'])).rejects.toMatchObject({
+      code: 'SESSION_NOT_FOUND',
+      details: { reason: 'limrun_adb_tunnel_cleaned_up' },
+    });
+
+    reportList();
+    await cleanup;
+  } finally {
+    reverse.listGate = undefined;
+  }
+  // Nothing mapped an endpoint behind the cleanup's back: no reverse command was dispatched at all, because
+  // the listing and the removals are stubbed and the caller's command never reached the device.
+  expect(runs.slice(dispatched).filter((argv) => argv.includes('reverse'))).toEqual([]);
+});
+
 const tunnels = vi.hoisted(() => ({
   /**
    * Held by a case that has to keep a tunnel in flight, which is the window a session's cleanup has to
 
@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import type Limrun from '@limrun/api';
 import {
   createInstanceClient as createAndroidInstanceClient,
@@ -184,7 +185,12 @@ export async function cleanupLimrunAndroidAdbTunnel(session: LimrunAndroidSessio
       // ask for.
       session.adbReverseExecutor = async (args, options) =>
         await runLimrunAndroidAdbAtSerial(session, serial, args, options);
-      await cleanupAndroidPortReverse(session);
+      // The teardown's marker covers this route and every dispatch this cleanup starts from it, including a
+      // reverse manager that answers a later request of its own inside the same await chain. A caller command
+      // that reaches this route through any other path carries no marker.
+      await limrunAdbTeardownScope.run(true, async () => {
+        await cleanupAndroidPortReverse(session);
+      });
       await session.dependencies.host
         .runAdb(session.dependencies.android.hostAdbInvocation(['disconnect', serial]), {
           allowFailure: true,
@@ -239,14 +245,25 @@ async function runLimrunAndroidAdb(
 /**
  * The reverse manager's own route to the device. It is the session's route while the session is live, and
  * cleanup's route of its own once the session is retired: clearing reverse mappings means reaching the device
- * that is about to be disconnected, and that has to stay possible after every caller of this session was refused.
+ * that is about to be disconnected, and that has to stay possible after every caller of this session was
+ * refused. Only the cleanup's own dispatches carry its teardown scope, so no caller command is ever
+ * dispatched at the serial the teardown is ending.
  */
+/**
+ * Whether one dispatch belongs to a session's teardown: true only for the dispatches that teardown itself
+ * started. The reverse manager is given this predicate as its route, and a provider that hands a caller
+ * command to it — a reverse command queued inside an operation of its own — carries no marker, so the
+ * manager cannot have a caller's mapping bound at a serial that is on its way out. A marker set by one
+ * session never authorises another session's route.
+ */
+const limrunAdbTeardownScope = new AsyncLocalStorage<boolean>();
+
 async function runLimrunAndroidReverseAdb(
   session: LimrunAndroidAdbSession,
   args: readonly string[],
   options?: LimrunAdbCommandOptions,
 ): Promise<LimrunAdbCommandResult> {
-  const atSerial = session.adbReverseExecutor;
+  const atSerial = limrunAdbTeardownScope.getStore() ? session.adbReverseExecutor : undefined;
   if (atSerial !== undefined) return await atSerial(args, options);
   return await runLimrunAndroidAdb(session, args, options);
 }
 
@@ -0,0 +1,68 @@
+import { test, vi } from 'vitest';
+import assert from 'node:assert/strict';
+import type { DeviceLease } from '@agent-device/contracts/device';
+import { LimrunCaptureLifecycle, type LimrunCaptureHost } from './capture-lifecycle.ts';
+import type { LimrunLeaseOwner } from './lease-ownership.ts';
+import type { NetworkCapture } from './network-har.ts';
+
+/** Longer than the lifecycle's budget for a destination tunnel that is still being opened. */
+const CAPTURE_OPEN_WAIT_MS = 25_000;
+
+/**
+ * A repeat allocation joins the start its owner is already running, within the budget a read or a teardown
+ * gives that same handshake.
+ */
+test('a repeat allocation stops waiting on a destination tunnel that never answers', async () => {
+  vi.useFakeTimers();
+  const lifecycle = new LimrunCaptureLifecycle(captureHost());
+  const owner = ownerWithCapture();
+  let joined = false;
+  const joining = lifecycle.start(owner, undefined).then(() => {
+    joined = true;
+  });
+  try {
+    await vi.advanceTimersByTimeAsync(CAPTURE_OPEN_WAIT_MS);
+    await joining;
+  } finally {
+    vi.useRealTimers();
+  }
+
+  assert.ok(joined, 'expected the joining allocation to stop waiting on the stalled tunnel');
+  // What the stalled start goes on to open stays the owner's to publish, and its teardown's to end: the
+  // joiner leaves the capture where the allocation that started it put it.
+  assert.equal(owner.capture?.phase, 'starting');
+});
+
+function captureHost(held: readonly LimrunLeaseOwner[] = []): LimrunCaptureHost {
+  return {
+    harDir: undefined,
+    liveSessionOf: () => undefined,
+    heldOwners: () => held,
+  };
+}
+
+/** An owner whose lease has a destination tunnel that has not answered, and never will. */
+function ownerWithCapture(): LimrunLeaseOwner {
+  const lease = {
+    leaseId: 'lease-capture-join',
+    tenantId: 'team-a',
+    runId: 'run-a',
+    backend: 'android-instance',
+    leaseProvider: 'limrun',
+    createdAt: 1,
+    heartbeatAt: 1,
+    expiresAt: 60_001,
+  } satisfies DeviceLease;
+  const opening = new Promise<NetworkCapture>(() => {});
+  return {
+    lease,
+    platform: 'android',
+    creation: Promise.resolve({ status: 'ready', session: undefined, appAlias: undefined }),
+    state: { phase: 'live' },
+    rentedInstanceId: undefined,
+    session: undefined,
+    capture: { phase: 'starting', opening },
+    appAlias: undefined,
+    deletedInstanceId: undefined,
+  } as unknown as LimrunLeaseOwner;
+}
@@ -50,7 +50,11 @@ export class LimrunCaptureLifecycle {
   async start(owner: LimrunLeaseOwner, hostList: unknown): Promise<void> {
     const held = owner.capture;
     if (held?.phase === 'starting') {
-      await held.opening;
+      // Joining another allocation's destination tunnel is waited for within the budget a read or a teardown
+      // gives that same handshake, and its outcome changes nothing here: the start keeps its own owner to
+      // publish to, and this lease's teardown is the route that ends whatever tunnel it opens. So a handshake
+      // that stops answering costs this caller its wait, and nothing else.
+      await awaitLimrunWithinBudget(held.opening, CAPTURE_OPEN_BUDGET_MS);
       return;
     }
     const harDir = this.host.harDir;
@@ -107,9 +111,14 @@ export class LimrunCaptureLifecycle {
     // written and ended by the continuation below all the same, so it is never left without an owner.
     const opened = await awaitLimrunWithinBudget(state.opening, CAPTURE_OPEN_BUDGET_MS);
     if (opened.ok) return await endCapture(leaseId, opened.value, this.record);
-    void state.opening.then(async (late) => {
-      await endCapture(leaseId, late, this.record);
-    });
+    void state.opening.then(
+      async (late) => {
+        await endCapture(leaseId, late, this.record);
+      },
+      // Observed: this continuation outlives its budget, so a late failure of it must not reach the process
+      // as an unhandled rejection. The tunnel it could not end stays the host's, reported by nothing else.
+      () => undefined,
+    );
     return this.settled.get(leaseId);
   }
 
 
@@ -12,6 +12,10 @@ export function limrunUserAgent(clientVersion: string): string {
  * Asks the SDK for one attempt at a request whose failure this runtime cannot tell apart from Limrun having
  * done the work: the SDK retries a lost answer by POSTing again, and a repeated instance create rents a
  * second instance. The SDK defaults to two retries, so a request that must not repeat carries this.
+ *
+ * The option is the SDK's request-scoped `maxRetries` (`RequestOptions`, @limrun/api 0.64.1), which every
+ * resource method takes as its second argument. `session-allocation.test.ts` pins that this is what the
+ * create honours: it drives the real SDK against a local server that drops the answer and asserts one POST.
  */
 export const LIMRUN_SINGLE_ATTEMPT = Object.freeze({ maxRetries: 0 });
 
 
@@ -57,6 +57,14 @@ export type LimrunLeaseOwner = {
   appAlias: LimrunAppAlias | undefined;
   /** The instance Limrun has already confirmed deleted, so a retried disposal never bills a second delete. */
   deletedInstanceId: string | undefined;
+  /**
+   * The delete this owner has in flight: the instance it names, and the request Limrun has not answered. A
+   * route that owes the end of that instance waits on this request rather than sending Limrun a second one —
+   * a delete whose answer this disposal stopped waiting for is still the delete that instance is getting.
+   */
+  pendingDelete:
+    | Readonly<{ instanceId: string; requested: Promise<string | undefined> }>
+    | undefined;
 };
 
 /** What one lease has live in this runtime, whatever its platform. */
 
@@ -0,0 +1,89 @@
+import { test, vi, expect } from 'vitest';
+import type { DeviceLease } from '@agent-device/contracts/device';
+import { disposeLimrunLeaseOwner, type LimrunDisposalHost } from './lease-release.ts';
+import type { LimrunCreateOutcome, LimrunLeaseOwner } from './lease-ownership.ts';
+
+/*
+ * Each wait is longer than the budgets it steps past: a disposal's create wait, and everything a disposal
+ * left without a create answer may still wait for — one delete, the local teardown, one capture record.
+ */
+const CREATE_ANSWER_WAIT_MS = 130_000;
+const DISPOSAL_SETTLE_WAIT_MS = 110_000;
+
+/**
+ * A create that answers after its disposal stopped waiting owes its end to the disposal already over. If that
+ * disposal's delete is still with Limrun, the late end joins it: one instance is deleted by one request.
+ */
+test('a create that answers late joins the delete its disposal already started', async () => {
+  // Loaded before the clock is replaced, so the disposal's own budget timers are fake timers.
+  await import('./lifecycle-budget.ts');
+  let reportDelete!: () => void;
+  const deleteHost = vi.fn<LimrunDisposalHost['deleteInstance']>(async () => {
+    await new Promise<void>((resolve) => {
+      reportDelete = resolve;
+    });
+    return undefined;
+  });
+  const host: LimrunDisposalHost = {
+    deleteInstance: deleteHost,
+    endCapture: async () => undefined,
+  };
+  let reportCreate!: () => void;
+  const creation = new Promise<LimrunCreateOutcome>((resolve) => {
+    // A create that rented the instance and then failed, after its disposal had given up on it.
+    reportCreate = () => resolve({ status: 'failed', error: new Error('instance boot failed') });
+  });
+  const owner = ownerWithRentedInstance(creation);
+
+  vi.useFakeTimers();
+  try {
+    const disposal = disposeLimrunLeaseOwner(host, owner);
+    // The disposal stops waiting on the create and asks Limrun once to end the instance it did rent.
+    await vi.advanceTimersByTimeAsync(CREATE_ANSWER_WAIT_MS);
+    expect(deleteHost).toHaveBeenCalledOnce();
+    // Its own delete then runs out its deadline, and the disposal refuses its caller.
+    await vi.advanceTimersByTimeAsync(DISPOSAL_SETTLE_WAIT_MS);
+    await expect(disposal).resolves.toMatchObject({ cleanup: 'uncertain' });
+
+    // The create answers now. The end it owes is this disposal's, and it joins the request Limrun already
+    // has for this instance rather than sending a second one.
+    reportCreate();
+    await vi.advanceTimersByTimeAsync(DISPOSAL_SETTLE_WAIT_MS);
+    expect(deleteHost).toHaveBeenCalledOnce();
+
+    // The one request confirming is enough: the joined end records the instance as deleted.
+    reportDelete();
+    await vi.advanceTimersByTimeAsync(DISPOSAL_SETTLE_WAIT_MS);
+  } finally {
+    vi.useRealTimers();
+  }
+  expect(owner.deletedInstanceId).toBe('android-instance-1');
+});
+
+/** An owner whose create has rented an instance but has not answered, taken by a disposal. */
+function ownerWithRentedInstance(creation: Promise<LimrunCreateOutcome>): LimrunLeaseOwner {
+  const lease = {
+    leaseId: 'lease-release-join',
+    tenantId: 'team-a',
+    runId: 'run-a',
+    backend: 'android-instance',
+    leaseProvider: 'limrun',
+    createdAt: 1,
+    heartbeatAt: 1,
+    expiresAt: 60_001,
+  } satisfies DeviceLease;
+  return {
+    lease,
+    platform: 'android',
+    creation,
+    state: { phase: 'releasing', by: 'release' },
+    rentedInstanceId: 'android-instance-1',
+    session: undefined,
+    localRelease: undefined,
+    keepAlive: undefined,
+    capture: undefined,
+    appAlias: undefined,
+    deletedInstanceId: undefined,
+    pendingDelete: undefined,
+  } as unknown as LimrunLeaseOwner;
+}