@@ -1,4 +1,4 @@
-import { test } from 'vitest';
+import { test, vi } from 'vitest';
 import assert from 'node:assert/strict';
 import { closeAndroidApp, openAndroidApp } from '../app-lifecycle.ts';
 import { withAndroidAdbProvider } from '../adb-executor.ts';
@@ -162,6 +162,55 @@ test('closeAndroidApp waits until package process exits after force-stop', async
   ]);
 });
 
+test.each(['foreground', 'process'] as const)(
+  'closeAndroidApp refuses an exhausted %s fence',
+  async (phase) => {
+    vi.useFakeTimers();
+    const calls: (readonly string[])[] = [];
+    try {
+      await withAndroidAdbProvider(
+        {
+          exec: async (args) => {
+            calls.push(args);
+            const stdout =
+              args[1] === 'pidof'
+                ? '12345\n'
+                : args[1] === 'dumpsys'
+                  ? `mCurrentFocus=Window{42 u0 ${phase === 'foreground' ? 'com.example.app/.MainActivity' : 'com.android.launcher/.Launcher'}}\n`
+                  : '';
+            return { stdout, stderr: '', exitCode: 0 };
+          },
+        },
+        { serial: ANDROID_EMULATOR.id },
+        async () => {
+          const rejection = assert.rejects(
+            closeAndroidApp(ANDROID_EMULATOR, 'com.example.app'),
+            (error: unknown) => {
+              assert.ok(error instanceof AppError);
+              assert.equal(error.code, 'COMMAND_FAILED');
+              assert.deepEqual(error.details, {
+                reason: 'android-app-close-timeout',
+                phase,
+                packageName: 'com.example.app',
+                timeoutMs: 2_000,
+              });
+              return true;
+            },
+          );
+          await Promise.all([rejection, vi.runAllTimersAsync()]);
+        },
+      );
+      assert.deepEqual(calls[0], ['shell', 'am', 'force-stop', 'com.example.app']);
+      assert.equal(
+        calls.filter((args) => args[1] === 'pidof').length,
+        phase === 'process' ? 40 : 0,
+      );
+    } finally {
+      vi.useRealTimers();
+    }
+  },
+);
+
 test('openAndroidApp ensures Android reverse before localhost deep link launch', async () => {
   const device: DeviceInfo = {
     platform: 'android',
 
@@ -546,6 +546,16 @@ async function waitForAndroidPackageNotForeground(
     if (foreground?.package !== packageName) return;
     await sleep(ANDROID_CLOSE_FOCUS_POLL_MS);
   }
+  throw new AppError(
+    'COMMAND_FAILED',
+    `Android app ${packageName} remained foreground after close`,
+    {
+      reason: 'android-app-close-timeout',
+      phase: 'foreground',
+      packageName,
+      timeoutMs: ANDROID_CLOSE_FOCUS_TIMEOUT_MS,
+    },
+  );
 }
 
 async function readAndroidForegroundApp(device: DeviceInfo): Promise<AppStateRuntimeResult | null> {
@@ -565,6 +575,16 @@ async function waitForAndroidPackageProcessGone(
     }
     await sleep(ANDROID_CLOSE_PROCESS_POLL_MS);
   }
+  throw new AppError(
+    'COMMAND_FAILED',
+    `Android app ${packageName} process remained running after close`,
+    {
+      reason: 'android-app-close-timeout',
+      phase: 'process',
+      packageName,
+      timeoutMs: ANDROID_CLOSE_PROCESS_TIMEOUT_MS,
+    },
+  );
 }
 
 async function isAndroidPackageProcessRunning(
 
@@ -9,6 +9,9 @@ import type { Interactor, SnapshotOptions } from '@agent-device/contracts/intera
 import type { DeviceInfo } from '@agent-device/kernel/device';
 import { AppError, createRequestCanceledError } from '@agent-device/kernel/errors';
 import { bindAndroidApplicationLifecycle } from './lifecycle.ts';
+import { closeAndroidApp } from './app-lifecycle.ts';
+import { withAndroidAdbProvider } from './adb-executor.ts';
+import { bindAndroidAdbHostStub } from './adb-host.fixtures.ts';
 
 const device: DeviceInfo = {
   platform: 'android',
@@ -20,6 +23,7 @@ const device: DeviceInfo = {
 };
 
 afterEach(() => {
+  vi.useRealTimers();
   vi.restoreAllMocks();
 });
 
@@ -39,6 +43,7 @@ function createLifecycle(
       input: Readonly<{ stateDir: string; shutdownTarget: boolean; signal: AbortSignal }>,
     ) => Promise<void>;
     shutdownTarget?: () => Promise<unknown>;
+    close?: Interactor['close'];
   }> = {},
 ): LifecycleFixture {
   const calls: string[] = [];
@@ -53,6 +58,7 @@ function createLifecycle(
         openDevice: async () => {},
         close: async (app: string) => {
           calls.push(`close:${app}`);
+          await params.close?.(app);
         },
         setSetting: async () => {},
         snapshot: async (options: SnapshotOptions) => {
@@ -164,6 +170,43 @@ test.each([
   expect(outcome.appBundleId).toBe(appBundleId);
 });
 
+test('relaunch refuses to open or observe after the Android process close fence expires', async () => {
+  vi.useFakeTimers();
+  bindAndroidAdbHostStub({});
+  const { calls, lifecycle } = createLifecycle({
+    close: async (app) => await closeAndroidApp(device, app),
+  });
+  await withAndroidAdbProvider(
+    {
+      exec: async (args) => ({
+        stdout:
+          args[1] === 'pidof'
+            ? '12345\n'
+            : args[1] === 'dumpsys'
+              ? 'mCurrentFocus=Window{43 u0 com.android.launcher/.Launcher}\n'
+              : '',
+        stderr: '',
+        exitCode: 0,
+      }),
+    },
+    { serial: device.id },
+    async () => {
+      const rejection = expect(
+        lifecycle.openApplication(openInput({ relaunch: true })),
+      ).rejects.toMatchObject({
+        code: 'COMMAND_FAILED',
+        details: {
+          reason: 'android-app-close-timeout',
+          phase: 'process',
+          packageName: 'com.example.app',
+        },
+      });
+      await Promise.all([rejection, vi.runAllTimersAsync()]);
+    },
+  );
+  expect(calls).toEqual(['close:com.example.app']);
+});
+
 test('preserves a runtime launch URL duration after the admitted Android follow-up open', async () => {
   const { calls, lifecycle } = createLifecycle();
   vi.spyOn(Date, 'now')