@@ -198,6 +198,18 @@ What changed:
   `main` either) but emits `android_blocking_dialog_unobserved`, and nothing about that dump can be
   carried forward as evidence.
 
+- **CI — rebased again onto `main`'s #1981.** The PR's Coverage lane tests the branch merged into
+  `main`, and #1981 landed there after the first rebase: Android publication now derives covered
+  state from acquisition evidence that travels in an opaque capture envelope, and
+  `readAndroidSnapshotNodes` goes through `androidSnapshotPublicationInput`. This branch's new
+  `android-dialog-readiness.test.ts` mocked `snapshotAndroid` with a bare `{ nodes }`, so
+  publication threw, the ANR recovery's own catch reported "Automatic recovery failed", and two
+  cases failed on a fixture defect that looked like broken recovery. The fixture now builds its
+  capture with the production constructor (`makeAndroidSnapshotCapture`), the recovered case pins
+  the tap that dismissed the dialog rather than the status alone, and a new case pins #1832 on the
+  readiness path: a "Close app" covered by a foreground surface is never tapped and recovery
+  reports failure.
+
 Left open, not in this pass: **F5** (the ANR poll is attempt-bounded, so cheaper probes shortened
 its wall-clock window), **F6** (the promoted `type` path has no delivery or helper-version check),
 **F7** (`#1832` citations corrected to `#592` where this pass rewrote them; other `#1832`
 
@@ -1,10 +1,19 @@
-import { expect, test, vi } from 'vitest';
+import { beforeEach, expect, test, vi } from 'vitest';
+import type { RawSnapshotNode } from '@agent-device/kernel/snapshot';
 
+/**
+ * Recovery reads the daemon presentation, and Android publication derives covered state from the
+ * acquisition evidence the capture envelope carries (#1981). The fake capture is therefore built by
+ * the production constructor: a bare `{ nodes }` throws inside publication, and recovery would then
+ * report "recovery failed" for a fixture reason rather than a device one.
+ */
 vi.mock('../../platforms/android/snapshot.ts', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../../platforms/android/snapshot.ts')>();
+  const { makeAndroidSnapshotCapture } =
+    await import('../../__tests__/test-utils/android-snapshot-capture.ts');
   return {
     ...actual,
-    snapshotAndroid: vi.fn(async () => ({ nodes: anrDialogNodes() })),
+    snapshotAndroid: vi.fn(async () => makeAndroidSnapshotCapture(screenNodes)),
   };
 });
 
@@ -26,8 +35,17 @@ const NORMAL_FOCUS_DUMP = `  mCurrentFocus=Window{a1b2c3 u0 ${APP}/${APP}.MainAc
 const ANR_FOCUS_DUMP = `  mCurrentFocus=Window{ffeedd u0 Application Not Responding: ${APP}}`;
 const SYSTEM_DIALOG_DUMP =
   '  mCurrentFocus=Window{ffeedd u0 Application Not Responding: com.android.systemui}';
+const CLOSE_APP_RECT = { x: 100, y: 600, width: 220, height: 80 };
+const CLOSE_APP_TAP = ['shell', 'input', 'tap', '210', '640'];
+
+/** What the mocked capture publishes: the screen the case under test is recovering from. */
+let screenNodes: RawSnapshotNode[];
+
+beforeEach(() => {
+  screenNodes = anrDialogNodes();
+});
 
-function anrDialogNodes() {
+function anrDialogNodes(): RawSnapshotNode[] {
   return [
     {
       index: 0,
@@ -39,11 +57,32 @@ function anrDialogNodes() {
       index: 1,
       type: 'android.widget.Button',
       label: 'Close app',
-      rect: { x: 100, y: 600, width: 220, height: 80 },
+      rect: CLOSE_APP_RECT,
     },
   ];
 }
 
+/**
+ * The same dialog with a foreground sheet drawn over it: the "Close app" is in the tree but nothing
+ * a user could touch. #1832 — recovery acts on what is reachable, never on raw text.
+ */
+function coveredCloseAppNodes(): RawSnapshotNode[] {
+  return [
+    ...anrDialogNodes(),
+    {
+      index: 2,
+      type: 'com.google.android.material.bottomsheet.BottomSheetDialog',
+      identifier: 'com.example:id/bottom_sheet',
+      hittable: true,
+      rect: { x: 0, y: 0, width: 1080, height: 2400 },
+    },
+  ];
+}
+
+function tapCalls(calls: string[][]): string[][] {
+  return calls.filter((call) => call[1] === 'input' && call[2] === 'tap');
+}
+
 /**
  * A device whose focused window is `dialog` until recovery taps "Close app", and the app after
  * that — the tap is what dismisses the dialog on a real device too.
@@ -69,28 +108,59 @@ test('an ANR that surfaces between two commands is recovered by the next pre-dis
   const session = makeAndroidSession('readiness-anr-between', { appBundleId: APP });
   let anr = false;
 
-  const readiness = await withFakeAdb(
+  const { readiness, calls } = await withFakeAdb(
     deviceShowing(() => (anr ? ANR_FOCUS_DUMP : null)),
-    async ({ device }) => {
+    async ({ device, calls }) => {
       session.device = device;
       await ensureAndroidBlockingSystemDialogReady({
         session,
         command: 'tap',
         phase: 'after-command',
       });
       anr = true;
-      return await ensureAndroidBlockingSystemDialogReady({
+      const readiness = await ensureAndroidBlockingSystemDialogReady({
         session,
         command: 'tap',
         phase: 'before-command',
       });
+      return { readiness, calls };
     },
   );
 
   expect(readiness).toEqual({
     status: 'recovered',
     warning: `Recovered Android app ANR before tap: closed and relaunched ${APP}.`,
   });
+  // Recovering means the dialog was actually dismissed on the device, so the reported status is
+  // pinned to the tap that did it rather than to the status value alone.
+  expect(tapCalls(calls)).toEqual([CLOSE_APP_TAP]);
+});
+
+test('an ANR whose Close app is covered is not tapped, and recovery reports failure', async () => {
+  // #1832: recovery reads the presentation's occlusion result, so a "Close app" that a foreground
+  // surface covers is unreachable. Tapping it anyway would land the tap on whatever is on top.
+  const session = makeAndroidSession('readiness-anr-covered', { appBundleId: APP });
+  screenNodes = coveredCloseAppNodes();
+
+  const { calls } = await withFakeAdb(
+    deviceShowing(() => ANR_FOCUS_DUMP),
+    async ({ device, calls }) => {
+      session.device = device;
+      await expect(
+        ensureAndroidBlockingSystemDialogReady({
+          session,
+          command: 'tap',
+          phase: 'before-command',
+        }),
+      ).rejects.toMatchObject({
+        code: 'COMMAND_FAILED',
+        message: expect.stringContaining('Android app ANR blocked tap'),
+      });
+      return { calls };
+    },
+  );
+
+  expect(tapCalls(calls)).toEqual([]);
 });
 
 test('a system dialog that surfaces between two commands blocks the next command', async () => {