@@ -0,0 +1,17 @@
+import { test } from 'vitest';
+import assert from 'node:assert/strict';
+import { capture, recycledCellSnapshot } from './scroll-edge-state-fixtures.ts';
+
+test('surface signature changes when a recycled cell keeps its slot but changes text', async () => {
+  const before = await capture(recycledCellSnapshot('First story'));
+  const after = await capture(recycledCellSnapshot('Second story'));
+  assert.ok(before.fingerprint && after.fingerprint);
+  assert.notEqual(before.fingerprint, after.fingerprint);
+});
+
+test('surface signature is stable when nothing on the container moves', async () => {
+  const first = await capture(recycledCellSnapshot('First story'));
+  const second = await capture(recycledCellSnapshot('First story'));
+  assert.ok(first.fingerprint);
+  assert.equal(first.fingerprint, second.fingerprint);
+});
@@ -66,6 +66,32 @@ export function scrollSnapshot(hiddenContentBelow: boolean): SnapshotNode[] {
   ];
 }
 
+/**
+ * A scrolled container whose one visible cell keeps a stable identifier and slot while only its text
+ * varies — the recycled-cell shape where identity alone would hide real progress.
+ */
+export function recycledCellSnapshot(label: string): SnapshotNode[] {
+  return [
+    {
+      index: 1,
+      ref: 'e1',
+      type: 'ScrollView',
+      label: 'Feed',
+      hiddenContentBelow: true,
+      rect: { x: 0, y: 100, width: 400, height: 600 },
+    },
+    {
+      index: 2,
+      ref: 'e2',
+      parentIndex: 1,
+      type: 'StaticText',
+      identifier: 'cell-0',
+      label,
+      rect: { x: 0, y: 640, width: 400, height: 56 },
+    },
+  ];
+}
+
 export async function captureThrows(scope: string | undefined): Promise<AppError> {
   try {
     await captureScrollEdgeState({
 
@@ -358,6 +358,34 @@ test('runScrollEdgePasses: a moving fingerprint never trips no-progress and scro
   assert.equal(result.passes, 5);
 });
 
+test('runScrollEdgePasses: a fresh surface signature continues after identical passes', async () => {
+  let scrollCalls = 0;
+  // The surface sits at `a` for three captures, then a pass finally reveals `b`. `b` is a signature
+  // the window has not seen, so the loop keeps going rather than stopping as no-progress on the pass
+  // that actually advanced.
+  const captures = [
+    { canScroll: true, fingerprint: 'a' },
+    { canScroll: true, fingerprint: 'a' },
+    { canScroll: true, fingerprint: 'a' },
+    { canScroll: true, fingerprint: 'b' },
+    { canScroll: false, fingerprint: 'b' },
+  ];
+  let index = 0;
+  const result = await runScrollEdgePasses({
+    edge: 'bottom',
+    captureState: async () => ({
+      emptySnapshot: false,
+      ...(captures[index++] ?? { canScroll: false }),
+    }),
+    scroll: async () => {
+      scrollCalls += 1;
+      return undefined;
+    },
+  });
+  assert.equal(result.passes, 4);
+  assert.equal(scrollCalls, 4);
+});
+
 test('unique container scope is retained across edge pass captures', async () => {
   const scopes: Array<string | undefined> = [];
   const snapshots = [scrollSnapshot(true), scrollSnapshot(true), scrollSnapshot(false)];
 
@@ -0,0 +1,20 @@
+import { test } from 'vitest';
+import assert from 'node:assert/strict';
+import { scrollSurfaceIsStuck } from '../scroll-edge-state.ts';
+
+const cases: ReadonlyArray<readonly [string, readonly string[], boolean]> = [
+  ['identical captures', ['a', 'a', 'a', 'a'], true],
+  ['rubber-band alternation', ['bottom', 'top', 'bottom', 'top'], true],
+  ['two stable signatures', ['a', 'b', 'a', 'b'], true],
+  ['parked after one detour', ['a', 'b', 'a', 'a'], true],
+  // A newest signature the window has not seen is a pass that just made progress: keep scrolling.
+  ['fresh progress after identical passes', ['a', 'a', 'a', 'b'], false],
+  ['three distinct signatures', ['a', 'b', 'c', 'a'], false],
+  ['below the minimum length', ['a', 'a', 'a'], false],
+];
+
+for (const [label, signatures, expected] of cases) {
+  test(`scrollSurfaceIsStuck: ${label}`, () => {
+    assert.equal(scrollSurfaceIsStuck(signatures), expected);
+  });
+}
@@ -81,15 +81,19 @@ export async function scrollSurfaceFingerprint(
 
 /**
  * Has a scroll stopped making progress? True once `recentSignatures` holds at least
- * `SCROLL_EDGE_STUCK_MIN_LENGTH` captures within the last `SCROLL_EDGE_STUCK_WINDOW` and no more
- * than two of them are distinct — the signature of a container that ignores the gesture or is only
- * rubber-banding. Callers cap `recentSignatures` to the window. Exported so `scroll --until` reuses
- * the one definition of "stuck" rather than a second copy.
+ * `SCROLL_EDGE_STUCK_MIN_LENGTH` captures within the last `SCROLL_EDGE_STUCK_WINDOW`, no more than
+ * two are distinct, AND the newest capture is one the window already showed — the signature of a
+ * container that ignores the gesture or only rubber-bands. A newest signature the window has not seen
+ * is a pass that just made real progress, so `A,A,A,B` continues while `A,B,A,B` is stuck. Callers
+ * cap `recentSignatures` to the window. Exported so `scroll --until` reuses the one definition of
+ * "stuck" rather than a second copy.
  */
 export function scrollSurfaceIsStuck(recentSignatures: readonly string[]): boolean {
   if (recentSignatures.length < SCROLL_EDGE_STUCK_MIN_LENGTH) return false;
   const window = recentSignatures.slice(-SCROLL_EDGE_STUCK_WINDOW);
-  return new Set(window).size <= SCROLL_EDGE_STUCK_MAX_DISTINCT;
+  if (new Set(window).size > SCROLL_EDGE_STUCK_MAX_DISTINCT) return false;
+  const newest = window.at(-1);
+  return newest !== undefined && window.slice(0, -1).includes(newest);
 }
 
 /**
 
@@ -210,13 +210,14 @@ function isUsableRect(rect: SnapshotNode['rect']): rect is NonNullable<SnapshotN
 
 /**
  * A stable signature of the content the container currently shows, built from the container's own
- * descendants (via the parent chain), each keyed by identity and rounded position. Scrolling shifts
- * descendant rects, so a real pass always changes it; a gesture the container ignores leaves it
- * byte-identical. Descendant scoping — not geometric overlap — is the point: it excludes the
- * keyboard, its typing predictions, and scroll-indicator overlays, which are not under the scroller
- * and would otherwise flicker and mask a stuck container. Rounded to whole pixels so layout jitter
- * never fakes movement; a false "unchanged" only defers to a later pass or the pass limit. An empty
- * string (a container with no positioned descendants) leaves both loops to their edge/pass signals.
+ * descendants (via the parent chain), each keyed by its identity fields and rounded position.
+ * Scrolling shifts descendant rects, and a recycled cell that keeps its slot while its text changes
+ * re-keys, so a real pass always changes it; a gesture the container ignores leaves it byte-identical.
+ * Descendant scoping — not geometric overlap — is the point: it excludes the keyboard, its typing
+ * predictions, and scroll-indicator overlays, which are not under the scroller and would otherwise
+ * flicker and mask a stuck container. Rounded to whole pixels so layout jitter never fakes movement;
+ * a false "unchanged" only defers to a later pass or the pass limit. An empty string (a container with
+ * no positioned descendants) leaves both loops to their edge/pass signals.
  */
 function buildSurfaceFingerprint(container: SnapshotNode, nodes: SnapshotNode[]): string {
   const byIndex = new Map<number, SnapshotNode>();
@@ -236,7 +237,12 @@ function buildSurfaceFingerprint(container: SnapshotNode, nodes: SnapshotNode[])
 }
 
 function surfaceIdentity(node: SnapshotNode): string {
-  return (node.identifier ?? node.label ?? node.value ?? '').trim();
+  // All three content fields, not first-present: a recycled cell keeps its identifier and slot while
+  // its label/value change, and that text change is exactly the progress the signature must register.
+  const identifier = (node.identifier ?? '').trim();
+  const label = (node.label ?? '').trim();
+  const value = (node.value ?? '').trim();
+  return `${identifier}${label}${value}`;
 }
 
 function isDescendantOf(