@@ -12,9 +12,11 @@ Accepted (2026-07-10); partially implemented (last updated 2026-07-13). See [Mig
   `REPLAY_DIVERGENCE` repair-loop fix (#1223).
 - Decision 6, the base agent-supervised re-record repair — `replay --save-script` arming, the
   post-watermark healed slice, `repairHint`, and the writer's bare-`@ref` fail-loud guard (#1228).
-- Decision 4 amendment, `screen`'s capture scope and ref selection — the divergence `screen` capture is
-  unified with `snapshot`'s own full-window scope (chrome and meaningful-target filters layered on top as
-  filters, not scopings), and `screen.refs` is ranked within the byte cap (foreign-window dismiss targets
+- Decision 4 amendment, `screen`'s capture scope and ref selection — the divergence `screen` capture runs
+  through the same `captureSnapshot` wrapper as plain `snapshot` (full-window scope + Android freshness /
+  post-action retry parity) under a clean, fixed capture-flags policy (a failed raw/scoped/`-d` action can
+  no longer narrow the diagnostic tree), with the chrome and meaningful-target filters layered on top as
+  filters, not scopings; and `screen.refs` is ranked within the byte cap (foreign-window dismiss targets
   ahead of app content; mass-covered app nodes surfaced rather than emptied) instead of sliced in document
   order, so a captured overlay is never buried past the cap (#1264).
 
@@ -446,14 +448,21 @@ the old session tree. Screen-capture failure never replaces or masks the origina
 > **Amendment (#1264): `screen`'s capture scope and ref selection.** `refs` is a filtered, ranked digest
 > of the exact same tree a plain `snapshot` would return at that moment. Two guarantees back the invariant:
 >
-> 1. **Capture scope.** The capture underneath `screen` is built with `snapshot`'s own full-window scope
->    (Android: the snapshot-helper route, with the existing graceful app-scoped fallback only when the
->    helper is unavailable; iOS: the same capture semantics as the bounded system-modal probe path;
->    macOS/Linux: their surface-scoped branches), never a narrower, app-window-only capture assembled
->    separately for divergence reporting. The chrome filter (#1233/#1256, `collectSettleChromeRefs`) and the
->    meaningful-target filter (label/id or `hittable`) are layered ON TOP of that full capture as
->    **filters**, not as a separate, narrower scoping — a filter may drop a node the full capture contains,
->    but the capture itself must never omit content `snapshot` would show.
+> 1. **Capture scope.** The capture underneath `screen` runs through the **same `captureSnapshot` wrapper**
+>    the plain `snapshot` command's backend calls — not a parallel single-shot dispatch — so it inherits
+>    `snapshot`'s full-window scope (Android: the snapshot-helper route, with the existing graceful
+>    app-scoped fallback only when the helper is unavailable; iOS: the bounded system-modal probe path;
+>    macOS/Linux: their surface-scoped branches) AND its Android freshness / post-action retry policy. A
+>    divergence must not consume a first stale or app-scoped dump while a plain `snapshot` retries to the
+>    fresh full-window tree — that would make the divergence staler or narrower than `snapshot`, violating
+>    the invariant. The divergence capture's flags are a **clean, fixed policy** (full-window, non-raw,
+>    default depth), NOT the failed action's flags: a failed `snapshot --raw`/scoped/`-d` action must never
+>    narrow or reshape the diagnostic tree below what a plain `snapshot` shows, so `snapshotRaw` /
+>    `snapshotScope` / `snapshotDepth` are dropped; only the interactive-only policy (full for non-rect
+>    `get`/`is`/`wait` reads, interactive otherwise) is carried. The chrome filter (#1233/#1256,
+>    `collectSettleChromeRefs`) and the meaningful-target filter (label/id or `hittable`) are layered ON TOP
+>    of that full capture as **filters**, not as a separate, narrower scoping — a filter may drop a node the
+>    full capture contains, but the capture itself must never omit content `snapshot` would show.
 > 2. **Ref selection within the cap.** The `screen.refs` cap is a **byte bound**, not a "first N in document
 >    order" policy. A separate-window overlay enumerates AFTER the app window's nodes, so a document-order
 >    slice truncates a fully-captured overlay away (its dismiss target sits past the cap) — reporting a
 
@@ -815,3 +815,177 @@ test('buildReplayFailureDivergence: a mass-covered app with no actionable overla
   expect(screen.refs.length).toBeGreaterThan(0);
   expect(screen.refs.some((ref) => ref.label === 'Field A')).toBe(true);
 });
+
+// #1264 (capture parity, point 1): the divergence capture must go through the
+// SAME `captureSnapshot` wrapper as a plain `snapshot`, so it inherits Android
+// freshness + post-action retry. Otherwise a divergence could consume the first
+// stale / app-scoped dump while a plain `snapshot` retries to the fresh
+// full-window tree — a divergence STALER than `snapshot`. Here the session
+// carries an active Android freshness marker (baselineCount 20); the first
+// on-device dump is a stale, near-empty tree (sharp node-count drop, no
+// meaningful content → the `sharp-drop` retry trigger), and only the RETRIED
+// second dump contains the system overlay. The divergence must reflect the
+// retried tree.
+test('buildReplayFailureDivergence: routes through the freshness-retry wrapper and uses the retried fresh tree, not the first stale dump (#1264 capture parity)', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-divergence-fresh-'));
+  const sessionStore = new SessionStore(path.join(root, 'sessions'));
+  const sessionName = 'default';
+  const appBundleId = 'com.callstack.agentdevicelab';
+  const session = makeAndroidSession(sessionName, { appBundleId });
+  // Active freshness marker: a navigation-sensitive action just ran, and the
+  // pre-action baseline had 20 nodes, so a near-empty next dump is suspicious.
+  session.androidSnapshotFreshness = {
+    action: 'press',
+    markedAt: Date.now(),
+    baselineCount: 20,
+    routeComparable: false,
+  };
+  sessionStore.set(sessionName, session);
+
+  // Capture 1: stale, near-empty dump (a single bare view — no hittable/label/
+  // id) → `sharp-drop` vs the 20-node baseline → triggers a retry.
+  const staleDump = {
+    nodes: [
+      {
+        index: 0,
+        type: 'android.view.View',
+        bundleId: appBundleId,
+        rect: { x: 0, y: 0, width: 10, height: 10 },
+      },
+    ],
+    truncated: false,
+    backend: 'android',
+  };
+  // Capture 2: the fresh full-window tree, holding the app control AND the
+  // separate-window system overlay's dismiss target.
+  const freshDump = {
+    nodes: [
+      {
+        index: 0,
+        type: 'android.widget.Button',
+        bundleId: appBundleId,
+        label: 'App control',
+        identifier: `${appBundleId}:id/control`,
+        rect: { x: 20, y: 100, width: 200, height: 44 },
+        hittable: true,
+      },
+      {
+        index: 1,
+        type: 'android.widget.ImageButton',
+        bundleId: 'com.android.systemui',
+        identifier: 'com.android.systemui:id/volume_new_ringer_active_icon_container',
+        label: 'Ringer volume',
+        rect: { x: 300, y: 300, width: 44, height: 44 },
+        hittable: true,
+      },
+    ],
+    truncated: false,
+    backend: 'android',
+  };
+  mockDispatchCommand.mockReset();
+  mockDispatchCommand.mockResolvedValueOnce(staleDump).mockResolvedValueOnce(freshDump);
+
+  const action = {
+    ts: 0,
+    command: 'press',
+    positionals: ['label="App control"'],
+    flags: {},
+    result: { selectorChain: ['label="App control"'] },
+  };
+  const divergence = await buildReplayFailureDivergence({
+    error: { code: 'COMMAND_FAILED', message: 'not hittable' },
+    action,
+    index: 0,
+    sourcePath: path.join(root, 'flow.ad'),
+    sourceLine: 1,
+    session: sessionStore.get(sessionName),
+    sessionName,
+    sessionStore,
+    logPath: path.join(root, 'daemon.log'),
+    responseLevel: 'default',
+    planActions: [action],
+    planDigest: 'test-plan-digest',
+  });
+
+  // The freshness wrapper retried past the stale dump (2 on-device captures).
+  expect(mockDispatchCommand).toHaveBeenCalledTimes(2);
+
+  expect(divergence.screen.state).toBe('available');
+  const screen = divergence.screen as Extract<typeof divergence.screen, { state: 'available' }>;
+  // The overlay only exists in the RETRIED capture, so its presence proves the
+  // divergence used the fresh tree — parity with what a plain `snapshot` sees.
+  expect(screen.refs.some((ref) => ref.label === 'Ringer volume')).toBe(true);
+  expect(screen.refs.some((ref) => ref.label === 'App control')).toBe(true);
+});
+
+// #1264 (clean flags policy, point 2): a failed `snapshot --raw`/scoped/`-d`
+// action must never narrow the DIAGNOSTIC divergence tree. The divergence
+// capture builds its flags from a fixed policy (full-window, non-raw, default
+// depth), NOT from the failed action's flags — so `snapshotRaw`/`snapshotScope`/
+// `snapshotDepth` on the action do not reach the capture. This inspects the
+// context handed to the snapshot dispatch and asserts those narrowing flags are
+// dropped while the interactive-only policy is still applied.
+test('buildReplayFailureDivergence: divergence capture drops the action snapshotRaw/scope/depth flags (#1264 clean flags policy)', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-divergence-flags-'));
+  const sessionStore = new SessionStore(path.join(root, 'sessions'));
+  const sessionName = 'default';
+  const appBundleId = 'com.callstack.agentdevicelab';
+  sessionStore.set(sessionName, makeAndroidSession(sessionName, { appBundleId }));
+
+  mockDispatchCommand.mockReset();
+  mockDispatchCommand.mockResolvedValue({
+    nodes: [
+      {
+        index: 0,
+        type: 'android.widget.Button',
+        bundleId: appBundleId,
+        label: 'Submit',
+        identifier: `${appBundleId}:id/submit`,
+        rect: { x: 20, y: 100, width: 200, height: 44 },
+        hittable: true,
+      },
+    ],
+    truncated: false,
+    backend: 'android',
+  });
+
+  // A failed action that itself requested a raw, ref-scoped, depth-limited
+  // snapshot — none of which may reshape the divergence diagnostic tree.
+  const action = {
+    ts: 0,
+    command: 'press',
+    positionals: ['label="Submit"'],
+    flags: { snapshotRaw: true, snapshotScope: '@e5', snapshotDepth: 2 },
+    result: { selectorChain: ['label="Submit"'] },
+  };
+  await buildReplayFailureDivergence({
+    error: { code: 'COMMAND_FAILED', message: 'not hittable' },
+    action,
+    index: 0,
+    sourcePath: path.join(root, 'flow.ad'),
+    sourceLine: 1,
+    session: sessionStore.get(sessionName),
+    sessionName,
+    sessionStore,
+    logPath: path.join(root, 'daemon.log'),
+    responseLevel: 'default',
+    planActions: [action],
+    planDigest: 'test-plan-digest',
+  });
+
+  expect(mockDispatchCommand).toHaveBeenCalled();
+  const context = mockDispatchCommand.mock.calls[0]?.[4] as
+    | {
+        snapshotRaw?: boolean;
+        snapshotScope?: string;
+        snapshotDepth?: number;
+        snapshotInteractiveOnly?: boolean;
+      }
+    | undefined;
+  // The action's narrowing flags are stripped by the fixed divergence policy.
+  expect(context?.snapshotRaw).not.toBe(true);
+  expect(context?.snapshotScope).toBeUndefined();
+  expect(context?.snapshotDepth).toBeUndefined();
+  // The interactive-only policy (press → interactive) is still applied.
+  expect(context?.snapshotInteractiveOnly).toBe(true);
+});
@@ -4,9 +4,10 @@ import { markSessionSnapshotRefsIssued, setSessionSnapshot } from '../session-sn
 import { isSparseSnapshotQualityVerdict } from '../../snapshot/snapshot-quality.ts';
 import { displayLabel, formatRole } from '../../snapshot/snapshot-lines.ts';
 import { redactDiagnosticData } from '../../kernel/redaction.ts';
+import type { CommandFlags } from '../../core/dispatch.ts';
 import type { DaemonError, ResponseLevel } from '../../kernel/contracts.ts';
 import type { SnapshotNode } from '../../kernel/snapshot.ts';
-import { buildSnapshotState, captureSnapshotData } from './snapshot-capture.ts';
+import { captureSnapshot } from './snapshot-capture.ts';
 import {
   buildSelectorChainForNode,
   resolveSelectorChain,
@@ -202,16 +203,28 @@ export function toReplayRepairHintCapture(
  * Sparse captures do not write back (selector-capture reliability contract),
  * so a sparse verdict degrades the whole observation.
  *
- * ADR 0012 decision 4 amendment (#1264): this reuses `captureSnapshotData` —
- * the SAME function the `snapshot` command itself builds its capture with
- * (Android: snapshot-helper full-window route with the graceful app-scoped
- * fallback; iOS: the bounded system-modal probe path; macOS/Linux: their
- * surface-scoped branches) — instead of a parallel hand-rolled dispatch. An
- * agent must never see a healthier `screen` in a divergence report than a
- * plain `snapshot` would show it, so `screen` cannot be built from a narrower
- * capture than `snapshot`'s. The chrome filter (`collectSettleChromeRefs`)
- * and the meaningful-target filter below stay layered ON TOP of this full
- * capture as FILTERS, never as a narrower scoping.
+ * ADR 0012 decision 4 amendment (#1264): this routes through `captureSnapshot`
+ * — the EXACT wrapper the `snapshot` command's backend calls
+ * (`dispatchSnapshotViaRuntime` -> `createDaemonSnapshotBackend`), which owns
+ * Android freshness + post-action retry (`capturePostActionAwareSnapshot`) on
+ * top of the per-platform capture (Android snapshot-helper full-window route
+ * with its graceful app-scoped fallback; iOS bounded system-modal probe path;
+ * macOS/Linux surface-scoped branches). Calling the inner single-shot
+ * `captureSnapshotData` instead would let a divergence consume a first stale /
+ * app-scoped dump while a plain `snapshot` retries to the fresh full-window
+ * tree — a divergence STALER or NARROWER than `snapshot`, which is exactly the
+ * invariant this amendment forbids: an agent must never see a healthier
+ * `screen` in a divergence report than a plain `snapshot` would show it.
+ *
+ * The capture flags are a CLEAN, fixed divergence-capture policy, NOT the
+ * failed action's flags: `snapshotRaw`/`snapshotScope`/`snapshotDepth` from a
+ * failed `snapshot --raw`/scoped/`-d` action would narrow or reshape the
+ * diagnostic tree below what a plain `snapshot` shows, so they are dropped. The
+ * only carried policy is interactive-only (`divergenceCaptureInteractiveOnly` —
+ * full for non-rect `get`/`is`/`wait` reads so static-text targets survive,
+ * interactive otherwise), matching heal's long-standing rule. The chrome filter
+ * (`collectSettleChromeRefs`) and the meaningful-target filter stay layered ON
+ * TOP of this full capture as FILTERS, never as a narrower scoping.
  */
 export async function captureDivergenceObservation(params: {
   session: SessionState;
@@ -221,16 +234,15 @@ export async function captureDivergenceObservation(params: {
   action: SessionAction;
 }): Promise<DivergenceObservation> {
   const { session, sessionName, sessionStore, logPath, action } = params;
-  const snapshotInteractiveOnly = divergenceCaptureInteractiveOnly(action);
-  const flags = { ...(action.flags ?? {}), snapshotInteractiveOnly };
+  const flags = divergenceCaptureFlags(action);
   try {
-    const data = await captureSnapshotData({
+    const capture = await captureSnapshot({
       device: session.device,
       session,
       flags,
       logPath,
     });
-    const snapshot = buildSnapshotState(data, flags);
+    const snapshot = capture.snapshot;
     if (isSparseSnapshotQualityVerdict(snapshot.snapshotQuality)) {
       return {
         state: 'unavailable',
@@ -256,6 +268,17 @@ export async function captureDivergenceObservation(params: {
   }
 }
 
+/**
+ * The clean, fixed flags for a divergence capture (#1264): full-window
+ * (no `snapshotScope`), non-raw (no `snapshotRaw`), default depth (no
+ * `snapshotDepth`) — a failed scoped/raw/depth-limited action must never
+ * produce a narrowed divergence `screen`. Only the interactive-only policy is
+ * carried, since it governs whether static-text suggestion targets survive.
+ */
+function divergenceCaptureFlags(action: SessionAction): CommandFlags {
+  return { snapshotInteractiveOnly: divergenceCaptureInteractiveOnly(action) };
+}
+
 /**
  * Interactive-only capture, except for non-rect selector reads
  * (`get`/`is`/`wait`) whose suggestion targets include static text — the