@@ -124,7 +124,10 @@ export type OpenApplicationTiming = Readonly<{
   openDispatchDurationMs?: number;
   launchUrlDurationMs?: number;
   postOpenSettleDurationMs?: number;
-  /** What a Simulator open learned about the launched app before returning (see the Apple owner). */
+  /**
+   * What the open learned about the launched app's readability before returning, set by a local
+   * iOS Simulator and by Android (see each platform owner).
+   */
   postOpenObservation?: 'observable' | 'unobservable' | 'not-eligible';
 }>;
 
 
@@ -1,8 +1,12 @@
 import { afterEach, expect, test, vi } from 'vitest';
-import type { LocalApplicationInteractorHost } from '@agent-device/contracts/application-lifecycle-runtime';
+import type {
+  LocalApplicationInteractorHost,
+  OpenApplicationInput,
+} from '@agent-device/contracts/application-lifecycle-runtime';
 import type { PlatformRuntimeHost } from '@agent-device/contracts/platform-runtime-operations';
-import type { Interactor } from '@agent-device/contracts/interactor-types';
+import type { Interactor, SnapshotOptions } from '@agent-device/contracts/interactor-types';
 import type { DeviceInfo } from '@agent-device/kernel/device';
+import { AppError } from '@agent-device/kernel/errors';
 import { bindAndroidApplicationLifecycle } from './lifecycle.ts';
 
 const device: DeviceInfo = {
@@ -18,17 +22,32 @@ afterEach(() => {
   vi.restoreAllMocks();
 });
 
-test('preserves a runtime launch URL duration after the admitted Android follow-up open', async () => {
-  const opens: string[] = [];
+type LifecycleFixture = Readonly<{
+  calls: string[];
+  lifecycle: ReturnType<typeof bindAndroidApplicationLifecycle>;
+}>;
+
+function createLifecycle(
+  params: Readonly<{
+    snapshot?: (options: SnapshotOptions | undefined) => Promise<unknown>;
+    openedAppBundleId?: string;
+    signal?: AbortSignal;
+  }> = {},
+): LifecycleFixture {
+  const calls: string[] = [];
   const localInteractors: LocalApplicationInteractorHost = {
     resolve: async () =>
       ({
         open: async (app: string) => {
-          opens.push(app);
+          calls.push(`open:${app}`);
         },
         openDevice: async () => {},
         close: async () => {},
         setSetting: async () => {},
+        snapshot: async (options?: SnapshotOptions) => {
+          calls.push(`snapshot:${options?.appBundleId}`);
+          return await (params.snapshot?.(options) ?? Promise.resolve({ nodes: [] }));
+        },
       }) as unknown as Interactor,
   };
   const host = {
@@ -41,7 +60,8 @@ test('preserves a runtime launch URL duration after the admitted Android follow-
     },
     androidApplications: {
       resolveOpenTarget: async () => ({}),
-      inferOpenedAppBundleId: async () => 'com.example.app',
+      inferOpenedAppBundleId: async () =>
+        'openedAppBundleId' in params ? params.openedAppBundleId : 'com.example.app',
       resetFramePerfStats: async () => {},
       applyRuntimeHints: async () => {},
       clearRuntimeHints: async () => {},
@@ -60,21 +80,18 @@ test('preserves a runtime launch URL duration after the admitted Android follow-
     | 'localInteractors'
     | 'toolchains'
   >;
-  vi.spyOn(Date, 'now')
-    .mockReturnValueOnce(10)
-    .mockReturnValueOnce(20)
-    .mockReturnValueOnce(30)
-    .mockReturnValueOnce(50);
   const lifecycle = bindAndroidApplicationLifecycle({
     host,
     device,
-    signal: new AbortController().signal,
+    signal: params.signal ?? new AbortController().signal,
   });
+  return { calls, lifecycle };
+}
 
-  const outcome = await lifecycle.openApplication({
+function openInput(overrides: Partial<OpenApplicationInput> = {}): OpenApplicationInput {
+  return {
     target: 'com.example.app',
     positionals: ['com.example.app'],
-    runtimeLaunchUrl: 'example://after-open',
     appBundleId: 'com.example.app',
     surface: 'app',
     hasExistingSession: false,
@@ -84,8 +101,106 @@ test('preserves a runtime launch URL duration after the admitted Android follow-
     stateDir: '/state',
     runtimeHints: {},
     execution: {},
-  });
+    ...overrides,
+  };
+}
+
+/** What the Android capture throws once its bounded re-capture still sees an unmounted app. */
+function unreadableLaunchContentError(): AppError {
+  return new AppError(
+    'COMMAND_FAILED',
+    'Android snapshot helper returned insufficient foreground app content',
+    {
+      androidSnapshotHelperFailureReason: 'content-poor-app-window',
+      attempts: 3,
+      retriable: true,
+    },
+  );
+}
 
-  expect(opens).toEqual(['com.example.app', 'example://after-open']);
+test('preserves a runtime launch URL duration after the admitted Android follow-up open', async () => {
+  const { calls, lifecycle } = createLifecycle();
+  vi.spyOn(Date, 'now')
+    .mockReturnValueOnce(10)
+    .mockReturnValueOnce(20)
+    .mockReturnValueOnce(30)
+    .mockReturnValueOnce(50);
+
+  const outcome = await lifecycle.openApplication(
+    openInput({ runtimeLaunchUrl: 'example://after-open' }),
+  );
+
+  expect(calls.filter((call) => call.startsWith('open:'))).toEqual([
+    'open:com.example.app',
+    'open:example://after-open',
+  ]);
   expect(outcome.timing.launchUrlDurationMs).toBe(20);
 });
+
+test('an Android app open returns only after a capture of the launched app is readable', async () => {
+  let releaseCapture: () => void = () => {};
+  const captureReleased = new Promise<void>((resolve) => {
+    releaseCapture = resolve;
+  });
+  const { calls, lifecycle } = createLifecycle({
+    openedAppBundleId: 'com.example.opened',
+    snapshot: async () => {
+      await captureReleased;
+      return { nodes: [] };
+    },
+  });
+
+  let settled = false;
+  const opening = lifecycle.openApplication(openInput()).then((outcome) => {
+    settled = true;
+    return outcome;
+  });
+  await vi.waitFor(() => expect(calls).toContain('snapshot:com.example.opened'));
+  await Promise.resolve();
+  expect(settled).toBe(false);
+  releaseCapture();
+  const outcome = await opening;
+
+  expect(calls).toEqual(['open:com.example.app', 'snapshot:com.example.opened']);
+  expect(outcome.appBundleId).toBe('com.example.opened');
+  expect(outcome.timing.postOpenObservation).toBe('observable');
+  expect(outcome.timing.postOpenSettleDurationMs).toEqual(expect.any(Number));
+});
+
+test('an app still unreadable after the capture re-captures opens as unobservable', async () => {
+  const { calls, lifecycle } = createLifecycle({
+    snapshot: async () => {
+      throw unreadableLaunchContentError();
+    },
+  });
+
+  const outcome = await lifecycle.openApplication(openInput({ relaunch: true }));
+
+  expect(calls).toEqual(['open:com.example.app', 'snapshot:com.example.app']);
+  expect(outcome.appBundleId).toBe('com.example.app');
+  expect(outcome.timing.postOpenObservation).toBe('unobservable');
+});
+
+test('a cancelled open does not report the launch observation as unobservable', async () => {
+  const controller = new AbortController();
+  const { lifecycle } = createLifecycle({
+    signal: controller.signal,
+    snapshot: async () => {
+      controller.abort(new Error('request cancelled'));
+      throw unreadableLaunchContentError();
+    },
+  });
+
+  await expect(lifecycle.openApplication(openInput())).rejects.toThrow('request cancelled');
+});
+
+test('an open whose launched app package is unknown does not observe the launch', async () => {
+  const { calls, lifecycle } = createLifecycle({ openedAppBundleId: undefined });
+
+  const outcome = await lifecycle.openApplication(
+    openInput({ target: 'https://example.com', positionals: ['https://example.com'] }),
+  );
+
+  expect(calls).toEqual(['open:https://example.com']);
+  expect(outcome.timing.postOpenObservation).toBe('not-eligible');
+});
@@ -164,10 +164,35 @@ async function openAndroidApplication(
   if (appBundleId) {
     await host.androidApplications.resetFramePerfStats(binding.device, appBundleId);
   }
-  timing.postOpenSettleDurationMs = 0;
+  const settleStartedAtMs = Date.now();
+  timing.postOpenObservation = await observeAndroidLaunch(binding, input, appBundleId);
+  timing.postOpenSettleDurationMs = elapsed(settleStartedAtMs);
   return { appBundleId, timing };
 }
 
+/**
+ * `am start -W` returns once the activity draws its first frame, which can be a splash or an empty
+ * root while the app still mounts its views, so the open itself captures the launched app. The
+ * capture's content verdict and its bounded re-capture decide readiness. The open still succeeds
+ * when the app stays unreadable or the capture fails: the capture reports why in its own
+ * diagnostics, and the next observation meets the same state.
+ */
+async function observeAndroidLaunch(
+  binding: ReturnType<typeof bindLocalApplicationLifecycleInteractor>,
+  input: OpenApplicationInput,
+  appBundleId: string | undefined,
+): Promise<NonNullable<OpenApplicationOutcome['timing']['postOpenObservation']>> {
+  if (!appBundleId) return 'not-eligible';
+  const interactor = await binding.resolveInteractor(input.execution, appBundleId);
+  try {
+    await interactor.snapshot({ appBundleId, signal: binding.signal });
+    return 'observable';
+  } catch {
+    binding.signal.throwIfAborted();
+    return 'unobservable';
+  }
+}
+
 function elapsed(startedAtMs: number): number {
   return Math.max(0, Date.now() - startedAtMs);
 }
 
@@ -191,7 +191,8 @@ test(
             .length,
           2,
         );
-        assertSnapshotCountInRange(snapshots, 2, 3);
+        // Each launchApp open captures the launched app once before it returns.
+        assertSnapshotCountInRange(snapshots, 4, 5);
       },
     );
   },