fix(maestro): corroborate same-app foreground read and pin no-session close input

- app-lifecycle: settle and re-read a same-app foreground sample before refusing killApp, so a stale mCurrentFocus right after Home does not spuriously refuse a legal kill; unreadable confirm keeps the refusal
- session-close test: record the full closeApplication input and assert positionals, surface, outPath, and ensureReady alongside mode kill
- kill tests: expect two reads on refusal; cover stale same-app settling to background and unreadable confirm failing closed

Author: Rohit3523

packages/platform-android/src/__tests__/app-lifecycle-kill.test.ts

@@ -136,7 +136,96 @@ test('killAndroidApp refuses a foreground target before killing', async () => {
     },
   );
 
-  assert.deepEqual(calls, [['shell', 'dumpsys', 'window', 'windows']]);
+  assert.deepEqual(calls, [
+    ['shell', 'dumpsys', 'window', 'windows'],
+    ['shell', 'dumpsys', 'window', 'windows'],
+  ]);
+});
+
+test('killAndroidApp proceeds when a stale same-app read settles to background', async () => {
+  const device: DeviceInfo = {
+    platform: 'android',
+    id: 'emulator-5554',
+    name: 'Pixel',
+    kind: 'emulator',
+    booted: true,
+  };
+  let foregroundReads = 0;
+  const calls: (readonly string[])[] = [];
+
+  await withAndroidAdbProvider(
+    {
+      exec: async (args) => {
+        calls.push(args);
+        if (args.join(' ') === 'shell dumpsys window windows') {
+          foregroundReads += 1;
+          // First read still names the target (stale `mCurrentFocus` right after
+          // `pressKey: Home`); later reads see the launcher so the kill completes.
+          const stdout =
+            foregroundReads === 1
+              ? 'mCurrentFocus=Window{42 u0 com.example.app/.MainActivity}\n'
+              : 'mCurrentFocus=Window{43 u0 com.android.launcher/.Launcher}\n';
+          return { stdout, stderr: '', exitCode: 0 };
+        }
+        return { stdout: '', stderr: '', exitCode: 0 };
+      },
+      reverse: {
+        ensure: async () => {},
+        remove: async () => {},
+        removeAllOwned: async () => {},
+      },
+    },
+    { serial: 'emulator-5554' },
+    async () => await killAndroidApp(device, 'com.example.app'),
+  );
+
+  assert.equal(foregroundReads >= 2, true);
+  assert.ok(calls.some((args) => args.join(' ') === 'shell am kill com.example.app'));
+});
+
+test('killAndroidApp fails closed when the confirmatory read cannot answer', async () => {
+  const device: DeviceInfo = {
+    platform: 'android',
+    id: 'emulator-5554',
+    name: 'Pixel',
+    kind: 'emulator',
+    booted: true,
+  };
+  let foregroundReads = 0;
+
+  await withAndroidAdbProvider(
+    {
+      exec: async (args) => {
+        if (args.join(' ') === 'shell dumpsys window windows') {
+          foregroundReads += 1;
+          if (foregroundReads === 1) {
+            return {
+              stdout: 'mCurrentFocus=Window{42 u0 com.example.app/.MainActivity}\n',
+              stderr: '',
+              exitCode: 0,
+            };
+          }
+          return { stdout: '', stderr: '', exitCode: 0 };
+        }
+        return { stdout: '', stderr: '', exitCode: 0 };
+      },
+      reverse: {
+        ensure: async () => {},
+        remove: async () => {},
+        removeAllOwned: async () => {},
+      },
+    },
+    { serial: 'emulator-5554' },
+    async () => {
+      await assertRejectsAppError(() => killAndroidApp(device, 'com.example.app'), {
+        code: 'COMMAND_FAILED',
+        hint: /Background the app before killApp/,
+        details: { reason: 'android-kill-requires-background-app' },
+      });
+    },
+  );
+
+  assert.equal(foregroundReads, 2);
 });
 
 test('killAndroidApp fails when the process survives the kill', async () => {

packages/platform-android/src/app-lifecycle.ts

@@ -563,23 +563,24 @@ async function readAndroidForegroundApp(device: DeviceInfo): Promise<AppStateRun
 }
 
 /**
- * `killAndroidPackage`'s precondition needs the opposite corroboration from
- * `waitForAndroidPackageProcessGone`'s "gone twice in a row counts": here a read naming a
- * different app is not enough on its own to trust "safe to kill". Live evidence (2026-09-25,
- * Android 16 emulator): immediately after `launchApp`, `dumpsys window`'s `mCurrentFocus` still
- * named the previous foreground app for one read while `dumpsys activity activities` already
- * showed the launched app resumed — `getAndroidAppState` takes whichever dump answers first, so
- * that stale window-focus read alone would have skipped the `android-kill-requires-background-app`
- * refusal against a target still genuinely in the foreground. A same-app read is trusted
- * immediately (refusing early is always safe); a different-app or unreadable read is corroborated
- * once after a short settle before this lets `killAndroidPackage` proceed.
+ * `killAndroidPackage`'s precondition corroborates either foreground read once:
+ * `mCurrentFocus` can lag one sample behind the resumed activity both after
+ * `launchApp` (stale different-app read would skip a required refusal) and
+ * after `pressKey: Home` (stale same-app read would spuriously refuse a legal
+ * kill). A confirmatory read after a short settle decides; an unreadable
+ * confirm keeps the first same-app refusal.
  */
 async function readAndroidForegroundAppSettled(
   device: DeviceInfo,
   packageName: string,
 ): Promise<AppStateRuntimeResult | null> {
   const first = await readAndroidForegroundApp(device);
-  if (first?.package === packageName) return first;
+  if (first?.package === packageName) {
+    await sleep(ANDROID_KILL_FOREGROUND_STABLE_MS);
+    const confirmed = await readAndroidForegroundApp(device);
+    if (confirmed && confirmed.package !== packageName) return confirmed;
+    return first;
+  }
   await sleep(ANDROID_KILL_FOREGROUND_STABLE_MS);
   return await readAndroidForegroundApp(device);
 }

src/daemon/session-lifecycle/internal/__tests__/session-close-without-session-mode.test.ts

@@ -48,7 +48,13 @@ function makeSessionStore(): SessionStore {
 test('an app-only kill close with no stored session still carries mode kill to the platform close', async () => {
   const sessionStore = makeSessionStore();
   mockResolveTargetDevice.mockResolvedValue(ANDROID_DEVICE);
-  const seenModes: Array<unknown> = [];
+  const seenInputs: Array<{
+    mode?: unknown;
+    positionals?: unknown;
+    surface?: unknown;
+    outPath?: unknown;
+    ensureReady?: unknown;
+  }> = [];
   const baseBind = mockBindDeviceRuntime.getMockImplementation();
   mockBindDeviceRuntime.mockImplementationOnce(async (device, use) => {
     const binding = await baseBind!(device, use);
@@ -59,7 +65,7 @@ test('an app-only kill close with no stored session still carries mode kill to t
       operations: {
         ...binding.operations,
         closeApplication: async (input: Parameters<typeof innerClose>[0]) => {
-          seenModes.push(input.mode);
+          seenInputs.push(input);
         },
       },
     };
@@ -81,5 +87,10 @@ test('an app-only kill close with no stored session still carries mode kill to t
   });
 
   expect(response?.ok).toBe(true);
-  expect(seenModes).toEqual(['kill']);
+  expect(seenInputs).toHaveLength(1);
+  expect(seenInputs[0]?.mode).toBe('kill');
+  expect(seenInputs[0]?.positionals).toEqual(['com.example.app']);
+  expect(seenInputs[0]?.surface).toBe('app');
+  expect(seenInputs[0]?.outPath).toBeUndefined();
+  expect(seenInputs[0]?.ensureReady).toBe(true);
 });