@@ -52,3 +52,62 @@ test('a stalled capture retries without scrolling or consuming an attempt', asyn
   assert.deepEqual(probeAttempts, [1, 1]);
   assert.deepEqual(scrollAttempts, []);
 });
+
+/**
+ * The CI failure shape (`smoke:automation-input`, id="automation-longpress"): the element is on
+ * screen only after the first scroll, and the first read after every scroll lands on a surface that
+ * is still moving, so the daemon answers not-found with `unsettledGesture`. Scrolling on that miss
+ * carries the element off the top before any settled read sees it.
+ */
+function listWithUnsettledFirstReads(visibleAtPosition: number | undefined) {
+  let position = 0;
+  let readSinceScroll = true;
+  const probes: number[] = [];
+  const scrolls: number[] = [];
+  return {
+    probes,
+    scrolls,
+    probe: async (attempt: number): Promise<CliJsonResult> => {
+      probes.push(attempt);
+      if (!readSinceScroll) {
+        readSinceScroll = true;
+        return result(1, {
+          reason: 'selector_not_found',
+          unsettledGesture: { action: 'scroll', positionals: ['down', '0.75'] },
+        });
+      }
+      return position === visibleAtPosition
+        ? result(0)
+        : result(1, { reason: 'selector_not_found' });
+    },
+    scroll: async (attempt: number) => {
+      scrolls.push(attempt);
+      position += 1;
+      readSinceScroll = false;
+    },
+  };
+}
+
+test('an unsettled miss right after the scroll that reached the element is re-read, not scrolled past', async () => {
+  const list = listWithUnsettledFirstReads(1);
+
+  await searchForVisibleElement('id="automation-longpress"', list.probe, list.scroll);
+
+  assert.deepEqual(list.probes, [1, 2, 2]);
+  assert.deepEqual(list.scrolls, [1]);
+});
+
+test('each scroll window re-reads an unsettled miss once, and a real absence still fails with every step', async () => {
+  const list = listWithUnsettledFirstReads(undefined);
+
+  await assert.rejects(
+    searchForVisibleElement('id="automation-longpress"', list.probe, list.scroll),
+    (error: Error) => {
+      assert.match(error.message, /probe 4: .*selector_not_found/);
+      assert.match(error.message, /scroll after attempt 3: null/);
+      return true;
+    },
+  );
+  assert.deepEqual(list.probes, [1, 2, 2, 3, 3, 4, 4]);
+  assert.deepEqual(list.scrolls, [1, 2, 3]);
+});
@@ -63,7 +63,7 @@ export async function assertElementTextAfterScrolling(
         'scroll',
         'down',
         '0.75',
-      ]).then(() => undefined),
+      ]).then((result) => result.json?.data),
   );
   await assertElementText(context, selector, expected);
 }
@@ -77,31 +77,38 @@ export async function assertElementTextAfterScrolling(
 export async function searchForVisibleElement(
   selector: string,
   probeVisibility: (attempt: number) => Promise<CliJsonResult>,
-  scrollAfterAttempt: (attempt: number) => Promise<void>,
+  scrollAfterAttempt: (attempt: number) => Promise<unknown>,
 ): Promise<void> {
   let stallRetriesLeft = SCROLL_SEARCH_STALL_RETRIES;
-  let lastFailure: CliJsonResult | undefined;
+  let unsettledReprobeLeft = true;
+  const history: string[] = [];
 
   for (let attempt = 1; attempt <= SCROLL_SEARCH_ATTEMPTS;) {
     const probe = await probeVisibility(attempt);
+    history.push(`probe ${attempt}: ${JSON.stringify(probe.json ?? { status: probe.status })}`);
     if (probe.status === 0) return;
-    lastFailure = probe;
 
+    const details = probe.json?.error?.details;
     // The snapshot never came back, so the surface was never read. Scrolling here would move the
     // surface for a reason unrelated to visibility and spend an attempt on no evidence.
-    if (probe.json?.error?.details?.captureStalled === true && stallRetriesLeft > 0) {
+    if (details?.captureStalled === true && stallRetriesLeft > 0) {
       stallRetriesLeft -= 1;
       continue;
     }
+    // The read ran on a surface still moving from the last scroll, so its miss is not an absence.
+    if (details?.unsettledGesture !== undefined && unsettledReprobeLeft) {
+      unsettledReprobeLeft = false;
+      continue;
+    }
 
     attempt += 1;
     if (attempt <= SCROLL_SEARCH_ATTEMPTS) {
-      await scrollAfterAttempt(attempt - 1);
+      const scrolled = await scrollAfterAttempt(attempt - 1);
+      history.push(`scroll after attempt ${attempt - 1}: ${JSON.stringify(scrolled ?? null)}`);
+      unsettledReprobeLeft = true;
     }
   }
-  assert.fail(
-    `${selector} did not become visible after scrolling\nlast visibility probe: ${JSON.stringify(lastFailure?.json ?? null)}`,
-  );
+  assert.fail(`${selector} did not become visible after scrolling\n${history.join('\n')}`);
 }
 
 function requireNode(