@@ -7,24 +7,29 @@ import type { EnvMap } from '@agent-device/kernel/source-value';
 import type { DaemonRequest } from './daemon-request.ts';
 import type { BindDeviceRuntime } from './request-runtime-binding.ts';
 
-type DeviceReadinessFlags = Pick<
-  NonNullable<DaemonRequest['flags']>,
-  'serial' | 'androidDeviceAllowlist'
->;
+type RequestFlags = NonNullable<DaemonRequest['flags']>;
+
+/** The request's Android serial allowlist, from `--android-device-allowlist` or the environment. */
+function androidSerialAllowlistInput(
+  flags: Pick<RequestFlags, 'androidDeviceAllowlist'>,
+  env: EnvMap,
+): readonly string[] | undefined {
+  const allowlist = resolveAndroidSerialAllowlist(flags.androidDeviceAllowlist, env);
+  return allowlist ? [...allowlist].sort() : undefined;
+}
 
 /**
- * The readiness input of a request that boots a device. It carries the request's `--serial` and
- * Android serial allowlist, so a boot only accepts a device the request may use.
+ * The readiness input of `boot`. It carries the request's `--serial` and Android serial
+ * allowlist, so a boot only accepts a device the request may use.
  */
 export function resolveDeviceReadinessInput(params: {
-  flags: DeviceReadinessFlags;
+  flags: Pick<RequestFlags, 'serial' | 'androidDeviceAllowlist'>;
   env: EnvMap;
   deadlineAtMs: number | undefined;
 }): EnsureReadyInput {
-  const allowlist = resolveAndroidSerialAllowlist(params.flags.androidDeviceAllowlist, params.env);
   return {
     serial: params.flags.serial,
-    androidSerialAllowlist: allowlist ? [...allowlist].sort() : undefined,
+    androidSerialAllowlist: androidSerialAllowlistInput(params.flags, params.env),
     deadlineAtMs: params.deadlineAtMs,
   };
 }
@@ -34,12 +39,15 @@ export function resolveDeviceReadinessInput(params: {
  * its AVD name, and returns the booted device with its adb serial. A command that addresses such
  * a device continues with the returned identity, so every later binding, claim and lock keys on
  * the serial. Returns undefined when the device needs no boot here.
+ *
+ * The resolved device is the boot target, so the request's `--serial` does not reach readiness.
+ * Only the Android serial allowlist does: it bounds which serial the boot may come up on.
  */
 export async function bootStoppedLocalAndroidDevice(params: {
   device: DeviceInfo;
   owner: RuntimeOwnerRef;
   bindDevice: BindDeviceRuntime;
-  flags: DeviceReadinessFlags;
+  flags: Pick<RequestFlags, 'androidDeviceAllowlist'>;
   env: EnvMap;
   deadlineAtMs: number | undefined;
 }): Promise<DeviceInfo | undefined> {
@@ -48,5 +56,8 @@ export async function bootStoppedLocalAndroidDevice(params: {
     return undefined;
   }
   const readiness = await params.bindDevice(device, ensureReadyUse);
-  return await readiness.operations.ensureReady(resolveDeviceReadinessInput(params));
+  return await readiness.operations.ensureReady({
+    androidSerialAllowlist: androidSerialAllowlistInput(params.flags, params.env),
+    deadlineAtMs: params.deadlineAtMs,
+  });
 }
@@ -261,6 +261,46 @@ test('open of a stopped AVD under an allowlist that excludes its booted serial c
   assert.equal(store.get('claim-allowlist'), undefined);
 });
 
+test('open of a stopped AVD boots the resolved AVD whatever --serial names', async () => {
+  const { store, stateDir } = setup();
+  const stoppedAvd = { ...android, id: 'pixel-avd', booted: false };
+  mockResolveTargetDevice.mockResolvedValue(stoppedAvd);
+  // Android readiness waits for the serial it is given, so a forwarded --serial for another
+  // device would wait for that device instead of the AVD that was resolved.
+  const readinessInputs: EnsureReadyInput[] = [];
+  const ensureReady = async (input: EnsureReadyInput): Promise<DeviceInfo> => {
+    readinessInputs.push(input);
+    if (input.serial && input.serial !== android.id) {
+      throw new AppError('COMMAND_FAILED', 'Android emulator did not appear in time', {
+        reason: BOOT_TIMEOUT_REASON,
+      });
+    }
+    return android;
+  };
+
+  const response = await handleOpenCommand({
+    host: createTestHostEnvironment(),
+    createCommandSurface: fakeCreateCommandSurface,
+    platformServices: daemonPlatformServicesFixture(),
+    req: {
+      command: 'open',
+      token: 'test',
+      session: 'claim-serial',
+      positionals: ['Demo'],
+      flags: { platform: 'android', device: stoppedAvd.name, serial: 'emulator-5560' },
+    },
+    sessionName: 'claim-serial',
+    logPath: path.join(stateDir, 'daemon.log'),
+    sessionStore: store,
+    bindDevice: bindBootingLifecycleRuntime(ensureReady),
+  });
+
+  assert.equal(response.ok, true);
+  assert.equal(readinessInputs.length, 1);
+  assert.equal(readinessInputs[0]?.serial, undefined);
+  assert.equal(store.get('claim-serial')?.device.id, android.id);
+});
+
 test('failed local open after dispatch retains its device claim for recovery', async () => {
   const { store, stateDir } = setup();
   mockResolveTargetDevice.mockResolvedValue(android);