test(daemon): split the two replay test files over the size tripwire (#2455)

* test(daemon): split the two replay test files over the size tripwire

No daemon test file should sit over the 1,000-line tripwire, so the size
ratchet can fail on new size, not only on growth. Split the two files PR
#2417 left over into sibling `<base>-<concern>.test.ts` files:

- session-replay-divergence.test.ts -> suggestions, chrome-filter, overlay,
  capture-policy, observation (13 cases).
- session-replay-runtime-maestro.test.ts -> dispatch, run-script, targeting,
  swipe, keyboard, run-flow, shell-artifacts (43 cases).

Shared setup moves to a dedicated fixtures module per family:
- session-replay-divergence.fixtures.ts holds the device-resolution and
  snapshot-interactor mocks and the shared reset, and re-exports the SUTs so
  siblings load them under the mocks. The freshness-retry `sleep` stub lives in
  a separate retry fixtures module the two retry siblings import first, so it
  cannot no-op the retry delay in siblings that never retry.
- session-replay-runtime-maestro.fixtures.ts declares the Maestro
  device-resolution vi.mock once, so the split does not copy it per file.

The diff is moves, import paths and fixture extraction. The case count under
src/daemon/replay/internal/__tests__ is unchanged (13 + 43 = 56); no test is
deleted or skipped, and assertions are identical.

Closes #2446

* refactor(test): inline the divergence replay mocks, drop the fixtures indirection

The divergence split did not need a shared fixtures module. Its only shared setup was the
dispatch-resolve + interactor mock pair and a reset that legacy-snapshot-capture-fixture
already provides, so routing the SUTs back through a frozen object and import-order-first
fixtures bought nothing and left a load-bearing import invariant that a reordering could
silently break. Each sibling now declares its own vi.mock (Vitest hoists a file's own mock
above its own imports) and imports the SUT directly, matching the existing
session-replay-divergence-android-occlusion.test.ts sibling. The freshness-retry sleep stub
is declared only in the two siblings that exercise a retry branch, so it stays local.

Maestro keeps its fixtures: the 24-line resolveTargetDevice mock cannot be copied per file
(one mock per module per file forbids merging with session-replay-runtime.test.ts) and the
runReplayFixture harness is genuinely shared. 56 tests unchanged.

Author: thymikee

src/__tests__/test-utils/android-ui-hierarchy-fixtures.ts

@@ -121,7 +121,7 @@ export function parseUiHierarchy(
  * node (`status_bar_container`, `status_bar_contents`, ...), unlike a default
  * capture. Shared across the chrome-classification tests
  * (`core/__tests__/snapshot-chrome-android-statusbar.test.ts`) and the replay
- * divergence route test (`daemon/replay/internal/__tests__/session-replay-divergence.test.ts`)
+ * divergence route test (`daemon/replay/internal/__tests__/session-replay-divergence-chrome-filter.test.ts`)
  * so both exercise the exact same real screen through `walkNonRawAndroidFixture`.
  */
 export const ANDROID_IME_CAPTURE_RAW_NODES: RawSnapshotNode[] = imeCapture;

src/daemon/replay/internal/__tests__/session-replay-divergence-capture-policy.test.ts

@@ -0,0 +1,208 @@
+import path from 'node:path';
+import { beforeEach, expect, test, vi } from 'vitest';
+import { mkdtempForTestSync } from '../../../../__tests__/test-utils/tmp-dir.ts';
+import { makeAndroidSession } from '../../../../__tests__/test-utils/session-factories.ts';
+import { SessionStore } from '../../../session-store.ts';
+import { buildReplayFailureDivergence } from '../session-replay-divergence.ts';
+import { replayDivergenceForTest } from './replay-session-fixture.ts';
+import {
+  legacyDispatchCapture,
+  resetLegacySnapshotCapture,
+} from '../../../__tests__/legacy-snapshot-capture-fixture.ts';
+import { captureSnapshotWithInteractor } from '../../../snapshot-interactor-capture.ts';
+
+vi.mock('@agent-device/device-selection/dispatch-resolve', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@agent-device/device-selection/dispatch-resolve')>();
+  return { ...actual, resolveTargetDevice: vi.fn() };
+});
+vi.mock('../../../snapshot-interactor-capture.ts', () => ({
+  captureSnapshotWithInteractor: vi.fn(),
+}));
+// Stubs the Android freshness-retry delay to a no-op so the retry branch runs without
+// a wall-clock wait. Declared only here (and in the observation sibling) — the two
+// siblings that exercise a retry branch — so it cannot no-op the delay elsewhere.
+vi.mock('@agent-device/host-kit/retry', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@agent-device/host-kit/retry')>();
+  return { ...actual, sleep: vi.fn(async () => {}) };
+});
+
+const mockDispatchCommand = legacyDispatchCapture;
+
+// #1264 capture parity: the divergence capture must reach the device through the SAME
+// `captureSnapshot` wrapper a plain `snapshot` uses (so it inherits Android freshness +
+// post-action retry and can never be STALER than a snapshot), and it must build its
+// flags from a fixed diagnostic policy — never from the failed action's narrowing flags.
+
+beforeEach(() => resetLegacySnapshotCapture(vi.mocked(captureSnapshotWithInteractor)));
+
+// #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. The retry delay (`sleep`) is stubbed to a no-op at the top of
+// this file, so the retry BRANCH runs without a real wall-clock wait.
+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 = mkdtempForTestSync('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,
+    ...replayDivergenceForTest(sessionStore, sessionName),
+    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 = mkdtempForTestSync('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,
+    ...replayDivergenceForTest(sessionStore, sessionName),
+    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);
+});