@@ -1,3 +1,4 @@
+import { classifyAndroidAppTarget } from './open-target.ts';
 import { AppError } from '@agent-device/kernel/errors';
 import type { AppStateRuntimeResult } from '@agent-device/contracts/app-state-runtime';
 import { Deadline, sleep } from '@agent-device/host-kit/retry';
@@ -252,7 +253,7 @@ async function tryAndroidHelperLaunch(
     options.activity !== undefined ||
     androidLaunchArgs(options).length > 0 ||
     options.terminateRunningApp ||
-    !/^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)+$/.test(app)
+    classifyAndroidAppTarget(app) !== 'package'
   )
     return undefined;
   const { runAndroidAutomationHelper } = await import('./automation-helper.ts');
 
@@ -0,0 +1,81 @@
+import { afterEach, expect, test } from 'vitest';
+import { once } from 'node:events';
+import { openAndroidApp } from './app-lifecycle.ts';
+import { withAndroidAdbProvider } from './adb-executor.ts';
+import { readAndroidFillTargetBeforeMutation } from './fill-verification.ts';
+import { resetAndroidSnapshotHelperSessions } from './snapshot-helper-session-lifecycle.ts';
+import {
+  createPersistentSnapshotHelperProvider,
+  type FakeAndroidProcess,
+} from './__tests__/snapshot-helper-session.fixtures.ts';
+import { ANDROID_SNAPSHOT_HELPER_FIXTURE_ARTIFACT as artifact } from './__tests__/test-utils/android-snapshot-helper.ts';
+import { ANDROID_EMULATOR as device } from './__tests__/test-utils/device-fixtures.ts';
+afterEach(resetAndroidSnapshotHelperSessions);
+
+test.each(['advertised', 'unsupported', 'ended'] as const)(
+  'app open through an %s session uses exactly one launch transport',
+  async (mode) => {
+    const calls: (readonly string[])[] = [],
+      requests: string[] = [],
+      processes: FakeAndroidProcess[] = [];
+    const pkg = 'com.example.app';
+    const provider = createPersistentSnapshotHelperProvider({
+      calls,
+      processes,
+      spawnArgs: [],
+      sessionRequests: requests,
+      sessionCommands:
+        mode === 'unsupported' ? ['snapshot-immediate'] : ['snapshot-immediate', 'app'],
+      sessionCommand: (command) =>
+        command.startsWith('app ')
+          ? {
+              launchOutputBase64: Buffer.from(
+                `Status: ok\nActivity: ${pkg}/.MainActivity\n`,
+              ).toString('base64'),
+            }
+          : undefined,
+    });
+    const exec = provider.exec;
+    await withAndroidAdbProvider(
+      {
+        ...provider,
+        snapshotHelperArtifact: artifact,
+        exec: async (args, options) => {
+          if (args[0] === 'shell' && args[1] === 'am' && args[2] === 'start') {
+            calls.push(args);
+            return {
+              stdout: `Status: ok\nActivity: ${pkg}/.MainActivity\n`,
+              stderr: '',
+              exitCode: 0,
+            };
+          }
+          return await exec(args, options);
+        },
+      },
+      { serial: device.id },
+      async () => {
+        await readAndroidFillTargetBeforeMutation(device, 10, 10, {
+          helperSessionScope: 'daemon-session',
+        });
+        if (mode === 'ended') {
+          const exited = once(processes[0]!, 'close');
+          processes[0]!.kill();
+          await exited;
+        }
+        await expect(openAndroidApp(device, pkg)).resolves.toBe(pkg);
+      },
+    );
+    const appRequests = requests.filter((request) => request.startsWith('app '));
+    expect(appRequests).toHaveLength(mode === 'advertised' ? 1 : 0);
+    expect(
+      calls.filter((args) => args[0] === 'shell' && args[1] === 'am' && args[2] === 'start'),
+    ).toHaveLength(mode === 'advertised' ? 0 : 1);
+    if (mode === 'advertised')
+      expect(JSON.parse(Buffer.from(appRequests[0]!.split(' ')[2]!, 'base64').toString())).toEqual({
+        kind: 'open',
+        packageName: pkg,
+      });
+    if (mode === 'ended')
+      expect(calls.some((args) => args[0] === 'forward' && args[1] === '--remove')).toBe(true);
+  },
+);
@@ -71,7 +71,9 @@ test('a validated no-injection refusal completes fill through adb without a help
   const f = fixture({ ...refused, injected: 'false' });
   await withAndroidAdbProvider(f.provider, { serial: device.id }, async () => {
     await fillAndroid(device, 10, 10, 'chips', 0, helper);
-    expect((await readAndroidFillTargetBeforeMutation(device, 10, 10, helper))?.text).toBe('chips');
+    expect(
+      (await readAndroidFillTargetBeforeMutation(device, 10, 10, helper))?.targetInput?.text,
+    ).toBe('chips');
   });
   expect(f.calls.filter((args) => args[0] === 'shell' && args[2] === 'text')).toHaveLength(1);
   expect(f.requests.filter((request) => request.startsWith('input '))).toHaveLength(1);
 
@@ -28,7 +28,7 @@ import type { ResolveInteractionTargetParams } from './interaction-resolution-re
  * photograph of a surface that may still be rearranging itself, and the ADB-backed Android helper is
  * measured reporting frames in flight — so an interaction issued right after an action that moved
  * the UI can resolve a point the target has already left and report success on the vacancy. The exposure is the runtime path's own capture-to-dispatch
- * distance, so the gate is backend-neutral.
+ * distance. Android requires a bounded quiet interval; other platforms retain the full observation window.
  *
  * Two judgements decide when it is real: {@link movingTargetGateDecision} asks whether this position
  * is still owed a second observation, and kernel's `areCapturedRectsAtSamePosition` asks whether the
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ import type { ResolveInteractionTargetParams } from './interaction-resolution-re`
`28`	`28`	`* photograph of a surface that may still be rearranging itself, and the ADB-backed Android helper is`
`29`	`29`	`* measured reporting frames in flight — so an interaction issued right after an action that moved`
`30`	`30`	`* the UI can resolve a point the target has already left and report success on the vacancy. The exposure is the runtime path's own capture-to-dispatch`
`31`		`- * distance, so the gate is backend-neutral.`
	`31`	`+ * distance. Android requires a bounded quiet interval; other platforms retain the full observation window.`
`32`	`32`	`*`
`33`	`33`	`* Two judgements decide when it is real: {@link movingTargetGateDecision} asks whether this position`
`34`	`34`	* is still owed a second observation, and kernel's `areCapturedRectsAtSamePosition` asks whether the