@@ -6,58 +6,58 @@ import { localCommandPolicy } from '@agent-device/contracts/command-policy';
 import type { CommandSessionStore } from '@agent-device/contracts/runtime-contract';
 import { makeSnapshotState } from '@agent-device/selectors/snapshot-geometry-fixtures';
 
-test('an Android snapshot names the app it captured, not a session app that is not in front', async () => {
-  const captureWith = async (overlay: { type: string; label: string; bundleId: string }) => {
-    let stored: Parameters<CommandSessionStore['set']>[0] | undefined;
-    const device = createAgentDevice({
-      backend: {
-        platform: 'android',
-        captureSnapshot: async () => ({
-          snapshot: makeSnapshotState(
-            [
-              {
-                index: 0,
-                depth: 0,
-                type: 'TextView',
-                label: '12:00',
-                bundleId: 'com.android.systemui',
-                systemBar: 'status',
-              },
-              { index: 1, depth: 0, ...overlay },
-            ],
-            { backend: 'android' },
-          ),
-          appName: 'Settings',
-          appBundleId: 'com.android.settings',
+async function snapshotWithAppWindows(applicationWindowPackages: string[] | undefined) {
+  let stored: Parameters<CommandSessionStore['set']>[0] | undefined;
+  const device = createAgentDevice({
+    backend: {
+      platform: 'android',
+      captureSnapshot: async () => ({
+        snapshot: makeSnapshotState([{ index: 0, depth: 0, type: 'TextView', label: 'Gmail' }], {
+          backend: 'android',
         }),
-      },
-      artifacts: createLocalArtifactAdapter(),
-      sessions: {
-        get: () => undefined,
-        set: (record) => {
-          stored = record;
+        androidSnapshot: {
+          backend: 'android-helper',
+          ...(applicationWindowPackages ? { applicationWindowPackages } : {}),
         },
+        appName: 'Settings',
+        appBundleId: 'com.android.settings',
+      }),
+    },
+    artifacts: createLocalArtifactAdapter(),
+    sessions: {
+      get: () => undefined,
+      set: (record) => {
+        stored = record;
       },
-      policy: localCommandPolicy(),
-    });
-    const result = await device.capture.snapshot({ session: 'default', interactiveOnly: true });
-    return { result, stored };
-  };
-
-  const launcher = await captureWith({
-    type: 'ScrollView',
-    label: 'Workspace',
-    bundleId: 'com.google.android.apps.nexuslauncher',
+    },
+    policy: localCommandPolicy(),
   });
-  assert.equal(launcher.result.appName, 'com.google.android.apps.nexuslauncher');
-  assert.equal(launcher.result.appBundleId, 'com.google.android.apps.nexuslauncher');
-  assert.equal(launcher.stored?.appBundleId, 'com.android.settings');
+  const result = await device.capture.snapshot({ session: 'default', interactiveOnly: true });
+  return { result, stored };
+}
 
-  const settings = await captureWith({
-    type: 'TextView',
-    label: 'Network & internet',
-    bundleId: 'com.android.settings',
-  });
-  assert.equal(settings.result.appName, 'Settings');
-  assert.equal(settings.result.appBundleId, 'com.android.settings');
+test('an Android snapshot names the captured app when the session app has no window in it', async () => {
+  const { result, stored } = await snapshotWithAppWindows([
+    'com.google.android.apps.nexuslauncher',
+  ]);
+
+  assert.equal(result.appName, 'com.google.android.apps.nexuslauncher');
+  assert.equal(result.appBundleId, 'com.google.android.apps.nexuslauncher');
+  assert.equal(stored?.appBundleId, 'com.android.settings');
+});
+
+test('an Android snapshot keeps the session app while one of its windows is captured', async () => {
+  const { result } = await snapshotWithAppWindows([
+    'com.google.android.permissioncontroller',
+    'com.android.settings',
+  ]);
+
+  assert.equal(result.appName, 'Settings');
+  assert.equal(result.appBundleId, 'com.android.settings');
+});
+
+test('a snapshot without application window facts names the session app', async () => {
+  const { result } = await snapshotWithAppWindows(undefined);
+
+  assert.equal(result.appBundleId, 'com.android.settings');
 });
@@ -19,10 +19,7 @@ import type {
   SnapshotVisibility,
 } from '@agent-device/kernel/snapshot';
 import type { SnapshotState } from '@agent-device/contracts/snapshot-model';
-import type {
-  AgentDeviceBackendPlatform,
-  BackendSnapshotResult,
-} from '@agent-device/contracts/backend';
+import type { BackendSnapshotResult } from '@agent-device/contracts/backend';
 import type {
   AgentDeviceRuntime,
   CommandSessionRecord,
@@ -125,7 +122,7 @@ export const snapshotCommand: RuntimeCommand<
     ...(capture.snapshot.presentedSurface
       ? { presentedSurface: capture.snapshot.presentedSurface }
       : {}),
-    ...snapshotAppFields(capture, runtime.backend.platform),
+    ...snapshotAppFields(capture),
   });
 };
 
@@ -238,22 +235,18 @@ function nextSnapshotSession(
 }
 
 /**
- * The app the response header names. Every Android node carries its window's package, so a capture
- * whose app content belongs only to another package, such as the launcher after a failed open,
- * names that package instead of the session app. The session keeps its app.
+ * The app the response header names. An Android helper capture lists its application windows, so
+ * one that shows none of the session app, such as the launcher after a failed open, names the
+ * topmost captured app instead. The session keeps its app.
  */
-function snapshotAppFields(
-  capture: SnapshotCapture,
-  platform: AgentDeviceBackendPlatform,
-): {
+function snapshotAppFields(capture: SnapshotCapture): {
   appName?: string;
   appBundleId?: string;
 } {
   const sessionApp = capture.result.appBundleId ?? capture.session?.appBundleId;
+  const appWindows = capture.annotations.androidSnapshot?.applicationWindowPackages;
   const shownApp =
-    platform === 'android' && sessionApp
-      ? capturedAndroidApp(capture.snapshot.nodes, sessionApp)
-      : sessionApp;
+    sessionApp && appWindows?.[0] && !appWindows.includes(sessionApp) ? appWindows[0] : sessionApp;
   const appName =
     shownApp === sessionApp ? (capture.result.appName ?? capture.session?.appName) : shownApp;
   return {
@@ -262,17 +255,6 @@ function snapshotAppFields(
   };
 }
 
-/** The session app when any app node belongs to it, else the first other app package. */
-function capturedAndroidApp(nodes: readonly SnapshotNode[], sessionApp: string): string {
-  let otherApp: string | undefined;
-  for (const node of nodes) {
-    if (!node.bundleId || node.systemBar || node.keyboardOwned) continue;
-    if (node.bundleId === sessionApp) return sessionApp;
-    otherApp ??= node.bundleId;
-  }
-  return otherApp ?? sessionApp;
-}
-
 /**
  * A capture that reported nothing about truncation is only "not truncated" when its producer
  * actually observes truncation. Producers that do not (Appium page source, the Limrun element
 
@@ -79,6 +79,11 @@ export type AndroidSnapshotBackendMetadata = {
   cacheInvalidated?: boolean;
   captureMode?: string;
   systemSurfaceOnly?: boolean;
+  /**
+   * Packages of the captured application windows that are not system-owned, topmost first. Input
+   * method and system windows are excluded. Absent when the capture read no such window.
+   */
+  applicationWindowPackages?: string[];
   windowCount?: number;
   /**
    * `AccessibilityWindowInfo` types of the listed windows the helper could not serialize because
 
@@ -270,6 +270,38 @@ test('rejects system chrome inherited under an empty application window', () =>
   expect(decision?.diagnostics.helperNonSystemMeaningfulNodeCount).toBe(0);
 });
 
+test('lists only non-system application windows, topmost first', () => {
+  const window = (windowType: number, packageName: string, text: string) =>
+    node({
+      windowType,
+      packageName,
+      className: 'android.widget.FrameLayout',
+      children: [node({ text, packageName, className: 'android.widget.TextView' })],
+    });
+  const result = classifyAndroidHelperContent(
+    helperXml([
+      window(3, 'com.android.systemui', '12:00'),
+      window(1, 'android', 'Allow?'),
+      window(2, 'com.google.android.inputmethod.latin', 'Space'),
+      window(1, 'com.google.android.apps.nexuslauncher', 'Gmail'),
+      window(1, 'com.google.android.apps.nexuslauncher', 'Photos'),
+      window(1, 'com.example.app', 'Home'),
+    ]),
+    {
+      backend: 'android-helper',
+      nodeCount: 12,
+      rootPresent: true,
+      windowCount: 6,
+      captureMode: 'interactive-windows',
+    },
+  );
+
+  expect(result.outcome === 'unusable' ? [] : result.applicationWindowPackages).toEqual([
+    'com.google.android.apps.nexuslauncher',
+    'com.example.app',
+  ]);
+});
+
 test('returns a meaningful active system surface (notification shade) faithfully', () => {
   const result = classifyAndroidHelperContent(
     helperXml([
 
@@ -35,19 +35,41 @@ export type AndroidHelperContentRecoveryDecision = {
   };
 };
 
-export type AndroidHelperContentClassification =
+type AndroidHelperContentOutcome =
   | { outcome: 'ok' }
   | { outcome: 'system-surface-only' }
   | { outcome: 'unusable'; decision: AndroidHelperContentRecoveryDecision };
 
+export type AndroidHelperContentClassification =
+  | ({ outcome: 'ok' | 'system-surface-only' } & AndroidApplicationWindows)
+  | { outcome: 'unusable'; decision: AndroidHelperContentRecoveryDecision };
+
+type AndroidApplicationWindows = {
+  /**
+   * Packages of the captured application windows that are not system-owned, topmost first: the
+   * app a snapshot header names. Input method and system windows are never application windows.
+   */
+  applicationWindowPackages: string[];
+};
+
 export function classifyAndroidHelperContent(
   xml: string,
   metadata: AndroidSnapshotBackendMetadata,
   options: { foregroundAppPackage?: string } = {},
 ): AndroidHelperContentClassification {
-  if (metadata.backend !== 'android-helper') return { outcome: 'ok' };
-
+  if (metadata.backend !== 'android-helper')
+    return { outcome: 'ok', applicationWindowPackages: [] };
   const summary = summarizeAndroidHelperXml(xml, options.foregroundAppPackage);
+  const content = classifyAndroidHelperSummary(summary, metadata);
+  return content.outcome === 'unusable'
+    ? content
+    : { ...content, applicationWindowPackages: summary.applicationWindowPackages };
+}
+
+function classifyAndroidHelperSummary(
+  summary: AndroidHelperXmlSummary,
+  metadata: AndroidSnapshotBackendMetadata,
+): AndroidHelperContentOutcome {
   if (isEmptyHelperOutput(summary, metadata)) {
     return unusable(
       summary,
@@ -97,7 +119,7 @@ function unusable(
   metadata: AndroidSnapshotBackendMetadata,
   reason: AndroidHelperContentRecoveryDecision['reason'],
   failureReason: string,
-): AndroidHelperContentClassification {
+): AndroidHelperContentOutcome {
   return {
     outcome: 'unusable',
     decision: buildRecoveryDecision(summary, metadata, reason, failureReason),
@@ -201,7 +223,7 @@ type AndroidHelperXmlSummary = {
   foregroundAppPackage?: string;
   foregroundAppMeaningfulNodeCount?: number;
   windowTypes: number[];
-};
+} & AndroidApplicationWindows;
 
 type AndroidHelperXmlSummaryState = Omit<AndroidHelperXmlSummary, 'windowTypes'> & {
   currentWindowType?: number;
@@ -243,6 +265,7 @@ function createAndroidHelperXmlSummaryState(
       ? { foregroundAppPackage, foregroundAppMeaningfulNodeCount: 0 }
       : {}),
     windowTypes: new Set<number>(),
+    applicationWindowPackages: [],
   };
 }
 
@@ -280,6 +303,12 @@ function recordAndroidHelperWindowNode(
   if (node.windowType === ANDROID_WINDOW_TYPE_APPLICATION) {
     summary.applicationWindowRootCount += 1;
     if (summary.currentWindowSystemOwned) summary.systemApplicationWindowRootCount += 1;
+    else if (
+      node.packageName !== null &&
+      !summary.applicationWindowPackages.includes(node.packageName)
+    ) {
+      summary.applicationWindowPackages.push(node.packageName);
+    }
   }
 }
 
@@ -370,6 +399,7 @@ function finalizeAndroidHelperXmlSummary(
         }
       : {}),
     windowTypes: [...summary.windowTypes].sort((a, b) => a - b).slice(0, MAX_REPORTED_WINDOW_TYPES),
+    applicationWindowPackages: summary.applicationWindowPackages,
   };
 }
 
 
@@ -41,6 +41,11 @@ export type AndroidSnapshotBackendMetadata = {
   cacheInvalidated?: boolean;
   captureMode?: AndroidSnapshotCaptureMode;
   systemSurfaceOnly?: boolean;
+  /**
+   * Packages of the captured application windows that are not system-owned, topmost first. Input
+   * method and system windows are excluded. Absent when the capture read no such window.
+   */
+  applicationWindowPackages?: string[];
   windowCount?: number;
   /**
    * `AccessibilityWindowInfo` types of the listed windows the helper could not serialize because
 
@@ -639,9 +639,13 @@ async function captureAndroidHelperContentAttempt(params: {
     capture: {
       xml: helperCapture.xml,
       helperMetadata: helperCapture.helperMetadata,
-      metadata: systemSurfaceOnly
-        ? { ...helperCapture.metadata, systemSurfaceOnly: true }
-        : helperCapture.metadata,
+      metadata: {
+        ...helperCapture.metadata,
+        ...(systemSurfaceOnly ? { systemSurfaceOnly: true } : {}),
+        ...(content.applicationWindowPackages.length > 0
+          ? { applicationWindowPackages: content.applicationWindowPackages }
+          : {}),
+      },
     },
   };
 }
 
@@ -80,7 +80,7 @@ and disclosure behavior ([#2682](https://github.com/callstack/agent-device/issue
   now, and hints that point to hidden list content.
 - Use `snapshot -i` by default in agent loops.
 - On Android, `snapshot -i` also keeps the title and message of a standard alert dialog, so you can see what its buttons confirm.
-- On Android, the `Page:` and `App:` lines (`appName` and `appBundleId` in `--json`) name the app the snapshot shows. If the session app is not in front, for example after a failed `open`, they name the app that is, such as the launcher. The session keeps its app.
+- On Android, the `Page:` and `App:` lines (`appName` and `appBundleId` in `--json`) name the session app while the snapshot holds one of its windows. When it holds none, for example after a failed `open`, they name the topmost captured application window, such as the launcher; system UI and keyboard windows never count. `androidSnapshot.applicationWindowPackages` in `--json` lists those windows. The session keeps its app.
 - On Android, repeating an unfiltered snapshot when nothing on screen changed (content or bounds) returns a short acknowledgement instead of the tree. `-i`, `-d`, `-s`, `--json`, and `--raw` always print full output. Add `--force-full` to get the full tree anyway.
 - The default text output is a compact view for planning and targeting actions. It lists visible elements first and may collapse helper and accessibility noise. Use `--raw` or `--json` when you need the full provider tree. Keep `--raw` for troubleshooting, such as when you need the full off-screen tree that summaries abbreviate.
 - Off-screen interactive content is collapsed into summaries that show only a few labels, such as `[off-screen below] 3 interactive items: "Privacy", "Battery", "About"`.