fix: require full-surface evidence before the no-effect claim (#1601 review P1)

accept-stale alone is subset-tolerant by design: a successful scroll that
replaced every list cell under fixed chrome still classifies 'unchanged' on
the shared chrome alone, and #1573 has live evidence of that shape. The
agent-facing claim now additionally requires every discriminating entry of
the quiet capture to match the baseline exactly, in both directions
(haveIdenticalDiscriminatingSurfaces): any appeared or vanished real
element — including scope drift — vetoes the warning. Silence is the safe
failure mode for a message that steers the agent's next move.

Red evidence: the new fixed-chrome + replaced-list regression test fails on
the previous PR commit (gestureNoEffect wrongly present), passes with the
gate.

Author: thymikee

src/daemon/__tests__/post-gesture-stabilization-fixtures.ts

@@ -62,6 +62,45 @@ export function pickupSnapshotWithExtraText(y = 500) {
   };
 }
 
+/**
+ * Fixed tab-bar chrome + a list whose visible cells sit at stable row rects.
+ * Two captures with DIFFERENT cell ids model a successful scroll that
+ * replaced every list row while the chrome (a discriminating, shared,
+ * unmoved entry) stayed put: `classifyBaselineSurfaceEvidence` reads
+ * 'unchanged' from the shared chrome alone (#1601 review P1) — the exact
+ * accept-stale false negative that must never surface as an agent-facing
+ * no-effect claim.
+ */
+export function chromeWithListSnapshot(cellIds: [string, string]) {
+  return makeSnapshotState([
+    { index: 0, type: 'Application', label: 'App', rect: { x: 0, y: 0, width: 390, height: 844 } },
+    {
+      index: 1,
+      parentIndex: 0,
+      type: 'Button',
+      identifier: 'tab-home',
+      label: 'Home',
+      rect: { x: 0, y: 800, width: 195, height: 44 },
+    },
+    {
+      index: 2,
+      parentIndex: 0,
+      type: 'Cell',
+      identifier: cellIds[0],
+      label: cellIds[0],
+      rect: { x: 0, y: 100, width: 390, height: 60 },
+    },
+    {
+      index: 3,
+      parentIndex: 0,
+      type: 'Cell',
+      identifier: cellIds[1],
+      label: cellIds[1],
+      rect: { x: 0, y: 160, width: 390, height: 60 },
+    },
+  ]);
+}
+
 export function applicationRootNode() {
   return {
     ref: 'e-root',

src/daemon/__tests__/post-gesture-stabilization.test.ts

@@ -9,6 +9,7 @@ import {
   markPostGestureStabilization,
 } from '../post-gesture-stabilization.ts';
 import {
+  chromeWithListSnapshot,
   deliverySnapshot,
   keyboardWindowNodes,
   makeSession,
@@ -157,6 +158,38 @@ test('capturePostGestureStabilizedResult keeps polling past the normal deadline
   assert.ok(captureCount > 8, `expected sustained polling, saw ${captureCount} captures`);
 });
 
+test('a replaced list under fixed chrome accepts stale but never claims no-effect (#1601 P1)', async () => {
+  // The reviewer's counterexample: a SUCCESSFUL scroll swapped every list
+  // cell while the tab-bar chrome (discriminating, shared, unmoved) kept the
+  // subset-tolerant classifier at 'unchanged'. The loop may still accept the
+  // stale read — but the agent-facing no-effect claim must be vetoed by the
+  // unmatched discriminating cells on both sides.
+  vi.useFakeTimers();
+  const session = makeSession('ios');
+  session.snapshot = chromeWithListSnapshot(['row-1', 'row-2']);
+  markPostGestureStabilization(session, 'scroll');
+
+  const capture = vi.fn(async () => chromeWithListSnapshot(['row-3', 'row-4']));
+
+  const resultPromise = withDiagnosticsScope({}, async () => {
+    const result = await capturePostGestureStabilizedResult({
+      session,
+      capture,
+      readSnapshot: (snapshot) => snapshot,
+    });
+    return {
+      result,
+      staleAccepts: countDiagnosticEventsByPhase(['post_gesture_snapshot_stale_accept']),
+    };
+  });
+
+  await vi.advanceTimersByTimeAsync(10_000);
+  const { result, staleAccepts } = await resultPromise;
+
+  assert.equal(staleAccepts, 1);
+  assert.equal(result.gestureNoEffect, undefined);
+});
+
 test('formatGestureNoEffectWarning names the gesture and the raw-drag escape hatch', () => {
   const scrollWarning = formatGestureNoEffectWarning('scroll', ['down', '1']);
   assert.match(scrollWarning, /scroll down produced no visible change/);

src/daemon/interaction-outcome-policy.ts

@@ -251,6 +251,44 @@ export function classifyBaselineSurfaceEvidence(
   return discriminatingOverlap > 0 ? 'unchanged' : 'ambiguous';
 }
 
+/**
+ * Full-surface agreement over DISCRIMINATING entries, in BOTH directions —
+ * the stronger bar an agent-facing no-effect claim needs (#1601 review P1).
+ *
+ * `classifyBaselineSurfaceEvidence` is deliberately subset-tolerant for the
+ * distrust loop, where a false 'unchanged' only buys extra polling. But a
+ * fixed-chrome screen whose list cells were fully replaced by a SUCCESSFUL
+ * scroll classifies 'unchanged' on the shared chrome alone — new cells are
+ * absent from the baseline and silently ignored. Requiring the discriminating
+ * entry sets to match exactly (same keys both ways, every rect within
+ * tolerance) vetoes that shape: any appeared or vanished real element kills
+ * the claim. Scope drift between baseline and capture vetoes too — silence
+ * is the safe failure mode for a message that steers the agent's next move.
+ */
+export function haveIdenticalDiscriminatingSurfaces(
+  left: InteractionSurfaceSignature,
+  right: InteractionSurfaceSignature,
+): boolean {
+  const leftEntries = left.filter((entry) => entry.discriminating);
+  const rightEntries = right.filter((entry) => entry.discriminating);
+  if (leftEntries.length === 0 || leftEntries.length !== rightEntries.length) return false;
+  // Keys carry an occurrence ordinal (`|#N`), so a map by key is lossless.
+  const rightByKey = new Map(rightEntries.map((entry) => [entry.key, entry]));
+  for (const entry of leftEntries) {
+    const other = rightByKey.get(entry.key);
+    if (!other) return false;
+    if (
+      Math.abs(entry.x - other.x) > RECT_TOLERANCE_PX ||
+      Math.abs(entry.y - other.y) > RECT_TOLERANCE_PX ||
+      Math.abs(entry.width - other.width) > RECT_TOLERANCE_PX ||
+      Math.abs(entry.height - other.height) > RECT_TOLERANCE_PX
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function supportsInteractionOutcomePolicy(session: SessionState): boolean {
   return isMobilePlatform(session.device);
 }

src/daemon/post-gesture-stabilization.ts

@@ -7,6 +7,7 @@ import {
   areInteractionSurfaceSignaturesStable,
   buildInteractionSurfaceSignature,
   classifyBaselineSurfaceEvidence,
+  haveIdenticalDiscriminatingSurfaces,
   type InteractionSurfaceSignature,
 } from './interaction-outcome-policy.ts';
 import type { SessionState } from './types.ts';
@@ -154,10 +155,14 @@ function emitPostGestureSettleDiagnostic(
 export type PostGestureStabilizedResult<T> = {
   value: T;
   /**
-   * Present when the loop accepted a stale read: the quiet capture PROVABLY
-   * still equals the pre-gesture baseline after the distrust cap (#1600).
-   * Callers surface this to the agent — a diagnostics-only verdict let one
-   * benchmark run burn 40 calls re-issuing scrolls the daemon knew did nothing.
+   * Present ONLY when the accept-stale verdict is corroborated by full-surface
+   * evidence: every discriminating entry of the quiet capture matches the
+   * pre-gesture baseline exactly, in both directions
+   * (`haveIdenticalDiscriminatingSurfaces`). The bare verdict is NOT enough —
+   * it is subset-tolerant by design, and a successful scroll that replaced
+   * every list cell under fixed chrome still reads accept-stale (#1601 review
+   * P1). Callers surface this to the agent: a diagnostics-only signal let one
+   * benchmark run burn 40 calls re-issuing scrolls that moved nothing (#1600).
    */
   gestureNoEffect?: { action: string; positionals: string[] };
 };
@@ -204,7 +209,8 @@ export async function capturePostGestureStabilizedResult<T>(params: {
       emitPostGestureSettleDiagnostic(verdict, pending.action, attempts, elapsedMs);
       return {
         value: current.value,
-        ...(verdict === 'accept-stale'
+        ...(verdict === 'accept-stale' &&
+        haveIdenticalDiscriminatingSurfaces(pending.baselineSignature ?? [], current.signature)
           ? {
               gestureNoEffect: {
                 action: pending.action,