@@ -124,11 +124,39 @@ export type OpenApplicationTiming = Readonly<{
   openDispatchDurationMs?: number;
   launchUrlDurationMs?: number;
   postOpenSettleDurationMs?: number;
-  /**
-   * 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';
+  /** Unset when the open had no launched app to observe, such as a URL or deep-link target. */
+  postOpenObservation?: PostOpenObservation;
+  /** Why the observation could not run; present exactly when it is `probe-failed`. */
+  postOpenObservationFailure?: PostOpenObservationFailure;
+}>;
+
+/**
+ * What an app open learned about the launched app before it returned. A local iOS Simulator asks
+ * its host AX bridge; a local Android device captures the app through the snapshot helper. Each
+ * owner bounds the observation, and the open succeeds whatever the value is.
+ *
+ * - `observable`: the launched app's tree was readable.
+ * - `unobservable`: the app stayed unreadable within the owner's bounded window: a launch transition
+ *   or AX-server state that did not clear, a system surface over the app, a content verdict after
+ *   the capture's own re-captures, or the window ran out.
+ * - `probe-failed`: the observation could not run (Android: the helper is not installed at the
+ *   current version, or adb or the accessibility service failed). `postOpenObservationFailure`
+ *   carries the typed failure.
+ * - `app-unidentified`: the open targeted an app, but the owner could not read which package it
+ *   launched, so nothing was observed.
+ * - `not-eligible`: the device has no observation path.
+ */
+export type PostOpenObservation =
+  | 'observable'
+  | 'unobservable'
+  | 'probe-failed'
+  | 'app-unidentified'
+  | 'not-eligible';
+
+/** The typed failure of a `probe-failed` observation: the error code and its typed reason. */
+export type PostOpenObservationFailure = Readonly<{
+  code: string;
+  reason?: string;
 }>;
 
 export type OpenApplicationOutcome = Readonly<{
 
@@ -175,6 +175,11 @@ export type SnapshotOptions = BaseSnapshotOptions & {
   surface?: SessionSurface;
   /** Internal capture purpose; action outcomes always require the full tree. */
   acquisitionIntent?: 'full' | 'surface-observation';
+  /**
+   * A one-off read, such as an open's launch observation. It may use a capture host the session
+   * already keeps warm, but it never installs one or leaves running one that it started.
+   */
+  transient?: boolean;
 };
 
 /**
 
@@ -86,6 +86,31 @@ test('an exec-shaped helper install timeout names the dialog, not a wedged adb s
   );
 });
 
+test('a current-only helper check refuses a missing helper without installing it', async () => {
+  const apkPath = await writeHelperApk('snapshot-helper-current-only-');
+  let installs = 0;
+  const adbProvider = missingPackageProvider(async () => {
+    installs += 1;
+    return { exitCode: 0, stdout: 'Success', stderr: '' };
+  });
+
+  await assert.rejects(
+    () =>
+      ensureAndroidSnapshotHelper({
+        adb: adbProvider.exec,
+        adbProvider,
+        artifact: { apkPath, manifest: { ...manifest, sha256: sha256Text('helper-apk') } },
+        deviceKey: 'android:emulator-5554',
+        installPolicy: 'current-only',
+      }),
+    (error) => {
+      assert.equal((error as AppError).details?.reason, 'android-snapshot-helper-not-current');
+      return true;
+    },
+  );
+  assert.equal(installs, 0);
+});
+
 function adbInstallTimeout(): AppError {
   // An unattended first install on ColorOS: adb blocks on the system install-confirmation dialog
   // and the exec layer kills the command, so stdout/stderr stay empty.
 
@@ -37,6 +37,7 @@ import {
   type FakeAndroidProcess,
 } from './snapshot-helper-session.fixtures.ts';
 import { withAndroidAdbProvider, type AndroidAdbProvider } from '../adb-executor.ts';
+import { isUnreadableCaptureContentError } from '@agent-device/contracts/android-snapshot-quality';
 
 const VALID_PNG = Buffer.from(
   'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+b9xkAAAAASUVORK5CYII=',
@@ -537,6 +538,60 @@ test('snapshotAndroid keeps daemon-session helper alive for reuse until session
   );
 });
 
+test('a borrowed capture releases a helper session it had to start', async () => {
+  const adbCalls: (readonly string[])[] = [];
+  const spawnArgs: (readonly string[])[] = [];
+  const processes: FakeAndroidProcess[] = [];
+  const provider = createPersistentSnapshotHelperProvider({
+    calls: adbCalls,
+    spawnArgs,
+    processes,
+  });
+
+  await snapshotAndroid(device, {
+    helperAdb: provider,
+    helperArtifact,
+    helperSessionScope: 'borrow',
+  });
+
+  assert.equal(spawnArgs.length, 1);
+  assert.equal(processes[0]?.exitCode, 0);
+  assert.equal(
+    adbCalls.some((args) => args[0] === 'forward' && args[1] === '--remove'),
+    true,
+  );
+});
+
+test('a borrowed capture leaves a warm daemon-session helper running', async () => {
+  const adbCalls: (readonly string[])[] = [];
+  const spawnArgs: (readonly string[])[] = [];
+  const processes: FakeAndroidProcess[] = [];
+  const provider = createPersistentSnapshotHelperProvider({
+    calls: adbCalls,
+    spawnArgs,
+    processes,
+  });
+
+  await snapshotAndroid(device, {
+    helperAdb: provider,
+    helperArtifact,
+    helperSessionScope: 'daemon-session',
+  });
+  const borrowed = await snapshotAndroid(device, {
+    helperAdb: provider,
+    helperArtifact,
+    helperSessionScope: 'borrow',
+  });
+
+  assert.equal(borrowed.androidSnapshot.helperSessionReused, true);
+  assert.equal(spawnArgs.length, 1);
+  assert.equal(processes[0]?.exitCode, null);
+  assert.equal(
+    adbCalls.some((args) => args[0] === 'forward' && args[1] === '--remove'),
+    false,
+  );
+});
+
 test('a daemon-session viewport read warms the session the next snapshot reuses', async () => {
   // The gesture viewport and snapshot capture are different helper commands on the same device.
   // They may only share the live session if both derive the same session identity, which is why
@@ -607,6 +662,35 @@ test('snapshotAndroid retires content-invalid daemon helper before the next requ
   );
 });
 
+test('a borrowed capture reports its content verdict without retiring the warm helper', async () => {
+  const adbCalls: (readonly string[])[] = [];
+  const spawnArgs: (readonly string[])[] = [];
+  const processes: FakeAndroidProcess[] = [];
+  const provider = createPersistentSnapshotHelperProvider({
+    calls: adbCalls,
+    spawnArgs,
+    processes,
+    sessionXml: (_sessionIndex, snapshotCount) =>
+      snapshotCount === 1
+        ? '<hierarchy><node text="warm helper" bounds="[0,0][10,10]" /></hierarchy>'
+        : androidSystemWindowOnlyXml(),
+  });
+  await snapshotAndroid(device, {
+    helperAdb: provider,
+    helperArtifact,
+    helperSessionScope: 'daemon-session',
+  });
+
+  await assert.rejects(
+    snapshotAndroid(device, { helperAdb: provider, helperArtifact, helperSessionScope: 'borrow' }),
+    (error: unknown) => isUnreadableCaptureContentError(error),
+  );
+
+  assert.equal(processes[0]?.exitCode, null, 'the session helper is still running');
+  assert.equal(adbCalls.some(isHelperRuntimeReset), false);
+  assert.equal(spawnArgs.length, 1);
+});
+
 test('content-invalid daemon helper retirement force-stops the helper runtime', async () => {
   // Retirement after a content failure is a recovery path, not a release: the helper answered with
   // output we could not trust, so the next capture must meet a runtime that was reset. A clean quit
 
@@ -0,0 +1,160 @@
+import { expect, test, vi } from 'vitest';
+import type { Interactor, SnapshotOptions } from '@agent-device/contracts/interactor-types';
+import type { PlatformRuntimeHost } from '@agent-device/contracts/platform-runtime-operations';
+import { AppError, createRequestCanceledError } from '@agent-device/kernel/errors';
+import {
+  ANDROID_LAUNCH_OBSERVATION_WINDOW_MS,
+  createAndroidLaunchObservationProbe,
+} from './launch-observation.ts';
+import { androidHelperContentUnavailableError } from './snapshot.ts';
+
+type ProbeFixture = Readonly<{
+  snapshotOptions: SnapshotOptions[];
+  sleeps: number[];
+  /** Ends every pending clock sleep, as elapsed time would. */
+  elapse: () => void;
+  observe: (
+    signal?: AbortSignal,
+  ) => ReturnType<ReturnType<typeof createAndroidLaunchObservationProbe>['awaitObservable']>;
+}>;
+
+function createProbe(snapshot: (options: SnapshotOptions) => Promise<unknown>): ProbeFixture {
+  const snapshotOptions: SnapshotOptions[] = [];
+  const sleeps: number[] = [];
+  const pendingSleeps: Array<() => void> = [];
+  const clock = {
+    now: () => Date.now(),
+    sleep: async (ms: number, signal?: AbortSignal) => {
+      sleeps.push(ms);
+      await new Promise<void>((resolve, reject) => {
+        pendingSleeps.push(resolve);
+        signal?.addEventListener('abort', () => reject(signal.reason), { once: true });
+      });
+    },
+  } as unknown as PlatformRuntimeHost['clock'];
+  const interactor = {
+    snapshot: async (options: SnapshotOptions) => {
+      snapshotOptions.push(options);
+      return await snapshot(options);
+    },
+  } as unknown as Pick<Interactor, 'snapshot'>;
+  const probe = createAndroidLaunchObservationProbe({ clock });
+  return {
+    snapshotOptions,
+    sleeps,
+    elapse: () => {
+      for (const resolve of pendingSleeps.splice(0)) resolve();
+    },
+    observe: async (signal = new AbortController().signal) =>
+      await probe.awaitObservable(interactor, 'com.example.app', signal),
+  };
+}
+
+/** What the capture throws once its re-captures still see an unmounted app. */
+function contentVerdict(): AppError {
+  return androidHelperContentUnavailableError(
+    {
+      reason: 'content-poor-app-window',
+      failureReason: 'Android snapshot helper returned insufficient foreground app content',
+      diagnostics: {
+        helperNodeCount: 3,
+        helperSystemUiNodeCount: 0,
+        helperWindowRootCount: 1,
+        helperApplicationWindowRootCount: 1,
+        helperMeaningfulNodeCount: 0,
+        helperApplicationMeaningfulNodeCount: 0,
+        helperNonSystemMeaningfulNodeCount: 0,
+        helperInputMethodMeaningfulNodeCount: 0,
+        helperWindowTypes: [1],
+      },
+    },
+    3,
+  );
+}
+
+/** A capture that ends only when its signal aborts, as a stuck helper call does. */
+async function captureUntilAborted(options: SnapshotOptions): Promise<never> {
+  return await new Promise<never>((_resolve, reject) => {
+    if (options.signal?.aborted) reject(options.signal.reason);
+    options.signal?.addEventListener('abort', () => reject(options.signal?.reason), {
+      once: true,
+    });
+  });
+}
+
+test('a readable launched app is observable through one transient capture', async () => {
+  const probe = createProbe(async () => ({ nodes: [] }));
+
+  await expect(probe.observe()).resolves.toEqual({ observation: 'observable' });
+  expect(probe.snapshotOptions).toHaveLength(1);
+  expect(probe.snapshotOptions[0]).toMatchObject({
+    appBundleId: 'com.example.app',
+    transient: true,
+  });
+});
+
+test('a content verdict after the capture re-captures is unobservable', async () => {
+  const probe = createProbe(async () => {
+    throw contentVerdict();
+  });
+
+  await expect(probe.observe()).resolves.toEqual({ observation: 'unobservable' });
+});
+
+test('a system surface covering the launched app is unobservable', async () => {
+  const probe = createProbe(async () => ({
+    nodes: [],
+    androidSnapshot: { backend: 'android-helper', systemSurfaceOnly: true },
+  }));
+
+  await expect(probe.observe()).resolves.toEqual({ observation: 'unobservable' });
+});
+
+test('a capture mechanism failure is a failed probe with its typed reason', async () => {
+  const probe = createProbe(async () => {
+    throw new AppError('COMMAND_FAILED', 'Android snapshot helper failed: accessibility timeout', {
+      androidSnapshotHelperFailureReason: 'Android snapshot helper failed: accessibility timeout',
+      androidCaptureFailureReason: 'accessibility-timeout',
+    });
+  });
+
+  await expect(probe.observe()).resolves.toEqual({
+    observation: 'probe-failed',
+    failure: { code: 'COMMAND_FAILED', reason: 'accessibility-timeout' },
+  });
+});
+
+test('a helper that is not installed at the current version is a failed probe', async () => {
+  const probe = createProbe(async () => {
+    throw new AppError('COMMAND_FAILED', 'Android snapshot helper is not installed', {
+      reason: 'android-snapshot-helper-not-current',
+    });
+  });
+
+  await expect(probe.observe()).resolves.toEqual({
+    observation: 'probe-failed',
+    failure: { code: 'COMMAND_FAILED', reason: 'android-snapshot-helper-not-current' },
+  });
+});
+
+test('a capture that outlasts the fixed window is abandoned as unobservable', async () => {
+  const probe = createProbe(captureUntilAborted);
+
+  const observing = probe.observe();
+  await vi.waitFor(() => expect(probe.sleeps).toEqual([ANDROID_LAUNCH_OBSERVATION_WINDOW_MS]));
+  probe.elapse();
+
+  await expect(observing).resolves.toEqual({ observation: 'unobservable' });
+  expect(probe.snapshotOptions[0]?.signal?.aborted).toBe(true);
+});
+
+test('a cancelled open rejects with its cancellation, not an observation', async () => {
+  const controller = new AbortController();
+  const canceled = createRequestCanceledError();
+  const probe = createProbe(async (options) => {
+    controller.abort(canceled);
+    return await captureUntilAborted(options);
+  });
+
+  await expect(probe.observe(controller.signal)).rejects.toBe(canceled);
+});