fix(ios): keep bridge-only behavior to iOS Simulators

The launch observation, the runner-free find admission, and the relaunch
policy apply only where the host AX bridge exists: iOS Simulators. A tvOS
Simulator keeps its awaited prewarm and asks for no observation, which the
tvOS provider scenario now pins.

Author: thymikee

packages/platform-apple/src/lifecycle.test.ts

@@ -483,3 +483,29 @@ test('a Simulator whose bridge cannot answer keeps the fixed settle', async () =
   expect(outcome.timing.postOpenObservation).toBe('unobservable');
   expect(events).toEqual(['open', 'sleep']);
 });
+
+test('a tvOS Simulator relaunch keeps the awaited prewarm and asks for no observation', async () => {
+  const events: string[] = [];
+  const { host, prewarmRunnerSession, notifyRunnerAppRelaunched } = simulatorHost({ events });
+  const awaitObservable = vi.fn(async () => 'observable' as const);
+  const tvos = { ...simulator, appleOs: 'tvos', target: 'tv' } as const satisfies DeviceInfo;
+  const lifecycle = bindAppleApplicationLifecycle({
+    host,
+    device: tvos,
+    signal: new AbortController().signal,
+    observation: { awaitObservable },
+  });
+
+  const outcome = await lifecycle.openApplication({
+    ...openInput(),
+    relaunch: true,
+    execution: { plannedOperations: ['captureSnapshot'] },
+  });
+
+  expect(outcome.timing.runnerDemand).toBeUndefined();
+  expect(outcome.timing.runnerPrewarmWaited).toBe(true);
+  expect(outcome.timing.postOpenObservation).toBeUndefined();
+  expect(awaitObservable).not.toHaveBeenCalled();
+  expect(prewarmRunnerSession).toHaveBeenCalledOnce();
+  expect(notifyRunnerAppRelaunched).not.toHaveBeenCalled();
+});

packages/platform-apple/src/open-policy.ts

@@ -6,7 +6,7 @@ import type {
 import type { PlatformRuntimeHost } from '@agent-device/contracts/platform-runtime-operations';
 import { isIosFamily, type DeviceInfo } from '@agent-device/kernel/device';
 import { resolveAppleSimulatorRunnerDemand } from './runner-demand.ts';
-import type { LaunchObservationPort } from './snapshot-observability.ts';
+import { hasSimulatorBridge, type LaunchObservationPort } from './snapshot-observability.ts';
 
 const POST_OPEN_SETTLE_MS = 300;
 
@@ -31,7 +31,10 @@ export function resolveRunnerPrewarmPolicy(
   input: OpenApplicationInput,
   localIosSimulator: boolean,
 ): RunnerPrewarmPolicy {
-  const runnerDemand = localIosSimulator
+  // Only a Simulator with the host AX bridge has a runner-free observation path, so only it
+  // consults the plan and skips the relaunch wait; every other Apple target keeps its lifecycle.
+  const bridge = localIosSimulator && hasSimulatorBridge(device);
+  const runnerDemand = bridge
     ? resolveAppleSimulatorRunnerDemand(input.execution.plannedOperations)
     : undefined;
   const shouldPrewarmRunner =
@@ -43,7 +46,7 @@ export function resolveRunnerPrewarmPolicy(
   return {
     ...(runnerDemand ? { runnerDemand } : {}),
     shouldPrewarmRunner,
-    awaitPrewarmAfterOpen: input.relaunch && !localIosSimulator,
+    awaitPrewarmAfterOpen: input.relaunch && !bridge,
   };
 }
 
@@ -62,7 +65,7 @@ export async function settleAppleOpen(
   timing: MutableOpenTiming,
 ): Promise<void> {
   const startedAtMs = Date.now();
-  if (localIosSimulator && observation && input.appBundleId) {
+  if (localIosSimulator && hasSimulatorBridge(binding.device) && observation && input.appBundleId) {
     timing.postOpenObservation = await observation.awaitObservable(
       binding.device,
       input.appBundleId,

packages/platform-apple/src/runtime-snapshot.ts

@@ -13,7 +13,8 @@ import type {
   PlatformRuntimeHost,
   PlatformRuntimeOperations,
 } from '@agent-device/contracts/platform-runtime-operations';
-import { isIosFamily, isMacOs, type DeviceInfo } from '@agent-device/kernel/device';
+import { isMacOs, type DeviceInfo } from '@agent-device/kernel/device';
+import { hasSimulatorBridge } from './snapshot-observability.ts';
 import type { AppleSnapshotRoute } from './snapshot-route.ts';
 
 /** Apple-owned selection between app snapshots and explicit macOS surface snapshots. */
@@ -142,15 +143,15 @@ async function admitAppleNativeFind(
 }
 
 /**
- * Whether the runner can answer a native find without a startup wait. Off a local Simulator the
- * runner is the only reader, so it always answers; on one, only a ready session does (see the
- * find-runtime doc above).
+ * Whether the runner can answer a native find without a startup wait. Without the Simulator
+ * bridge the runner is the only reader, so it always answers; with it, only a ready session does
+ * (see the find-runtime doc above).
  */
 async function runnerCanAnswerNow(
   host: Pick<PlatformRuntimeHost, 'appleApplications'>,
   device: DeviceInfo,
   execution: Readonly<{ requestId?: string }> | undefined,
 ): Promise<boolean> {
-  if (!isIosFamily(device) || device.kind !== 'simulator') return true;
+  if (!hasSimulatorBridge(device)) return true;
   return await host.appleApplications.hasLiveRunnerSession(device, execution ?? {});
 }

packages/platform-apple/src/snapshot-observability.test.ts

@@ -138,11 +138,14 @@ test('a failure outside the launch transition ends the wait at once', async () =
   expect(sleep).not.toHaveBeenCalled();
 });
 
-test('a device without a bridge is not eligible', async () => {
+test.each([
+  ['a physical iOS device', { ...simulator, kind: 'device' as const }],
+  ['a tvOS Simulator', { ...simulator, appleOs: 'tvos' as const, target: 'tv' as const }],
+])('%s has no bridge and is not eligible', async (_name, device) => {
   const { observe, acquire } = probe([acquired()], { now: () => 0, sleep: async () => {} });
-  await expect(
-    observe.awaitObservable({ ...simulator, kind: 'device' }, 'com.example.app', signal()),
-  ).resolves.toBe('not-eligible');
+  await expect(observe.awaitObservable(device, 'com.example.app', signal())).resolves.toBe(
+    'not-eligible',
+  );
   expect(acquire).not.toHaveBeenCalled();
 });
 

packages/platform-apple/src/snapshot-observability.ts

@@ -3,7 +3,7 @@ import {
   deriveIosCaptureHint,
 } from '@agent-device/capture-kit/ios-snapshot-planning';
 import type { PlatformRuntimeHost } from '@agent-device/contracts/platform-runtime-operations';
-import { isIosFamily, type DeviceInfo } from '@agent-device/kernel/device';
+import type { DeviceInfo } from '@agent-device/kernel/device';
 import type { SimulatorSnapshotSource } from './snapshot-source-facade.ts';
 import type { SimulatorSnapshotTargetResolver } from './snapshot-target.ts';
 
@@ -41,6 +41,11 @@ const LAUNCH_TRANSITION_WINDOW_MS: ReadonlyMap<string, number> = new Map([
   ['foreground-owner-changed', 1_000],
 ]);
 
+/** Only iOS Simulators carry the host AX bridge; other Apple simulators observe through XCTest. */
+export function hasSimulatorBridge(device: DeviceInfo): boolean {
+  return device.platform === 'apple' && device.appleOs === 'ios' && device.kind === 'simulator';
+}
+
 export function createLaunchObservationProbe(
   deps: Readonly<{
     source: SimulatorSnapshotSource;
@@ -51,7 +56,7 @@ export function createLaunchObservationProbe(
   const hint = deriveIosCaptureHint(createIosSnapshotRequest({ depth: 1, interactiveOnly: true }));
   return Object.freeze({
     awaitObservable: async (device, appBundleId, signal) => {
-      if (!isIosFamily(device) || device.kind !== 'simulator') return 'not-eligible';
+      if (!hasSimulatorBridge(device)) return 'not-eligible';
       let deadline: number | undefined;
       for (;;) {
         const target = await deps.resolveTarget(device, appBundleId, signal).catch(() => undefined);