@@ -54,6 +54,6 @@ export type FindBaseOptions = DeviceCommandBaseOptions &
   };
 
 export type FindOptions =
-  | (FindBaseOptions & { action?: 'click' | 'focus' | 'exists' | 'getText' | 'getAttrs' })
+  | (FindBaseOptions & { action?: 'click' | 'focus' | 'exists' | 'getText' | 'getAttrs' | 'list' })
   | (FindBaseOptions & { action: 'wait'; timeoutMs?: number })
   | (FindBaseOptions & { action: 'fill' | 'type'; value: string });
@@ -101,6 +101,7 @@ export type {
   ResolvedTarget,
   SelectorTarget,
   SettleDiffLine,
+  FindReadResult,
   SettleObservation,
   SettleParams,
   SettleTailEntry,
 
@@ -180,6 +180,18 @@ export type SettleParams = {
   timeoutMs?: number;
 };
 
+/**
+ * The find read-action result, consumed verbatim on both sides of the
+ * daemon/engine boundary (R2: the shape lives below both zones — a daemon-side
+ * structural twin drifted into an identical clone before it moved here).
+ */
+export type FindReadResult =
+  | { kind: 'found'; found: true; waitedMs?: number }
+  | { kind: 'text'; ref: string; text: string; node: SnapshotNode }
+  | { kind: 'attrs'; ref: string; node: SnapshotNode }
+  /** #1625: the read-only inspection surface — every match, never a tap. */
+  | { kind: 'list'; matches: Array<{ ref: string; node: SnapshotNode }> };
+
 export type SettleObservation = {
   settled: boolean;
   waitedMs: number;
@@ -365,6 +377,8 @@ export type FindCommandResponseData = {
   waitedMs?: number;
   text?: string;
   node?: SnapshotNode;
+  /** Every match of the read-only `list` action (#1625), each ref pinnable at `refsGeneration`. */
+  matches?: Array<{ ref: string; node: SnapshotNode }>;
   locator?: string;
   query?: string;
   x?: number;
 
@@ -42,6 +42,7 @@ import {
   findBestMatchesByLocator,
   checkFindArgs,
   isReadOnlyFindAction,
+  normalizeFindActionToken,
   parseFindArgs,
   parseFindSelectorExpression,
   FIND_LOCATORS,
@@ -79,6 +80,7 @@ export {
   findBestMatchesByLocator,
   findSelectorChainMatch,
   isReadOnlyFindAction,
+  normalizeFindActionToken,
   isRoleHintWord,
   isSelectorToken,
   isValidSelectorExpression,
 
@@ -20,9 +20,22 @@ export type FindAction =
   | { kind: 'get_text' }
   | { kind: 'get_attrs' }
   | { kind: 'exists' }
-  | { kind: 'wait'; timeoutMs?: number };
+  | { kind: 'wait'; timeoutMs?: number }
+  | { kind: 'list' };
 
-export type ReadOnlyFindAction = 'exists' | 'wait' | 'get_text' | 'get_attrs';
+export type ReadOnlyFindAction = 'exists' | 'wait' | 'get_text' | 'get_attrs' | 'list';
+
+/**
+ * `press` and `tap` are the same action as `click` everywhere else in this CLI
+ * (the interaction layer treats them as synonyms), so `find` accepts them as
+ * aliases of its click action instead of rejecting the vocabulary agents
+ * already use. longpress/swipe stay real exclusions — they are different
+ * gestures with no find form.
+ */
+export function normalizeFindActionToken(token: string | undefined): string | undefined {
+  const lowered = token?.toLowerCase();
+  return lowered === 'press' || lowered === 'tap' ? 'click' : lowered;
+}
 
 /**
  * `find` is the one command whose observation-vs-mutation split is a
@@ -35,7 +48,11 @@ export type ReadOnlyFindAction = 'exists' | 'wait' | 'get_text' | 'get_attrs';
  */
 export function isReadOnlyFindAction(action: FindAction['kind']): action is ReadOnlyFindAction {
   return (
-    action === 'exists' || action === 'wait' || action === 'get_text' || action === 'get_attrs'
+    action === 'exists' ||
+    action === 'wait' ||
+    action === 'get_text' ||
+    action === 'get_attrs' ||
+    action === 'list'
   );
 }
 
@@ -138,14 +155,17 @@ export const FIND_VALUE_REQUIRED_MESSAGE = 'find requires a value';
 /**
  * Shared by both `Unsupported find action` throw sites (this file's raw-token
  * parser and `src/commands/interaction/selectors.ts`'s typed CLI reader) so
- * the recovery guidance cannot drift between them. `find` has no press/
- * longpress/swipe action of its own — the fix is to resolve the ref through
- * `find`, then dispatch the gesture as its own top-level command.
+ * the recovery guidance cannot drift between them. `find` has no longpress/
+ * swipe action of its own — the fix is to inspect matches with the read-only
+ * `list` action, then dispatch the gesture on the chosen @ref as its own
+ * top-level command. (#1625: the old guidance said to run bare `find`, which
+ * CLICKS a unique match — inspection guidance must never point at a mutation.)
  */
 export const UNSUPPORTED_FIND_ACTION_HINT =
-  'find actions: click (default), focus, fill, type, exists, wait, get text, get attrs — ' +
-  'there is no press/longpress/swipe find action. Run find "<text>" to list matches, then ' +
-  'act on the resolved @ref directly, e.g. press @eNN.';
+  'find actions: click (default; press/tap are aliases), list, focus, fill, type, exists, ' +
+  'wait, get text, get attrs — there is no longpress/swipe find action. Run ' +
+  'find "<text>" list to inspect every match with its @ref without acting, then dispatch ' +
+  'the gesture on the chosen ref, e.g. longpress @eNN.';
 
 export type FindArgumentCheck =
   | { ok: true; parsed: ParsedFindArgs }
@@ -184,6 +204,14 @@ export function checkFindArgs(
   return { ok: true, parsed };
 }
 
+/** Single-token actions carrying no extra arguments. */
+const BARE_FIND_ACTIONS = ['exists', 'list', 'click', 'focus'] as const;
+type BareFindAction = (typeof BARE_FIND_ACTIONS)[number];
+
+function isBareFindAction(action: string | undefined): action is BareFindAction {
+  return BARE_FIND_ACTIONS.includes(action as BareFindAction);
+}
+
 export function parseFindArgs(args: string[]): ParsedFindArgs {
   let locator: FindLocator = 'any';
   let queryIndex = 0;
@@ -196,33 +224,30 @@ export function parseFindArgs(args: string[]): ParsedFindArgs {
   if (actionTokens.length === 0) {
     return { locator, query, action: 'click' };
   }
-  const action = actionTokens[0]?.toLowerCase();
+  const action = normalizeFindActionToken(actionTokens[0]);
+  if (isBareFindAction(action)) return { locator, query, action };
   if (action === 'get') {
-    const sub = actionTokens[1]?.toLowerCase();
-    if (sub === 'text') return { locator, query, action: 'get_text' };
-    if (sub === 'attrs') return { locator, query, action: 'get_attrs' };
-    throw new AppError('INVALID_ARGS', 'find get only supports text or attrs');
+    return { locator, query, action: parseFindGetSubAction(actionTokens[1]) };
   }
   if (action === 'wait') {
     const timeoutMs = parseTimeout(actionTokens[1]);
     return { locator, query, action: 'wait', timeoutMs: timeoutMs ?? undefined };
   }
-  if (action === 'exists') return { locator, query, action: 'exists' };
-  if (action === 'click') return { locator, query, action: 'click' };
-  if (action === 'focus') return { locator, query, action: 'focus' };
-  if (action === 'fill') {
-    const value = actionTokens.slice(1).join(' ');
-    return { locator, query, action: 'fill', value };
-  }
-  if (action === 'type') {
-    const value = actionTokens.slice(1).join(' ');
-    return { locator, query, action: 'type', value };
+  if (action === 'fill' || action === 'type') {
+    return { locator, query, action, value: actionTokens.slice(1).join(' ') };
   }
   throw new AppError('INVALID_ARGS', `Unsupported find action: ${actionTokens[0]}`, {
     hint: UNSUPPORTED_FIND_ACTION_HINT,
   });
 }
 
+function parseFindGetSubAction(token: string | undefined): 'get_text' | 'get_attrs' {
+  const sub = token?.toLowerCase();
+  if (sub === 'text') return 'get_text';
+  if (sub === 'attrs') return 'get_attrs';
+  throw new AppError('INVALID_ARGS', 'find get only supports text or attrs');
+}
+
 export function parseFindSelectorExpression(locator: FindLocator, query: string): string | null {
   if (locator !== 'any') return null;
   if (!query.includes('=') && !query.includes('||')) return null;
 
@@ -1408,6 +1408,39 @@ test('interactions expose targetKind-discriminated public response data', async
   );
 });
 
+// #1625: `find … list` through the typed client — `matches` is part of the
+// public response type and rides with the issuing generation, so a caller can
+// pin any listed ref for its next command.
+test('typed client find list returns every match with the issuing generation', async () => {
+  const setup = createTransport(async (req) => {
+    if (req.command === 'find') {
+      assert.deepEqual(req.positionals, ['label', 'Foo', 'list']);
+      return {
+        ok: true,
+        data: {
+          matches: [
+            { ref: '@e5', node: { ref: 'e5', type: 'Button', label: 'Foo' } },
+            { ref: '@e9', node: { ref: 'e9', type: 'Cell', label: 'Foo bar' } },
+          ],
+          refsGeneration: 42,
+        },
+      };
+    }
+    throw new Error(`unexpected command: ${req.command}`);
+  });
+  const client = createAgentDeviceClient(setup.config, { transport: setup.transport });
+
+  const list = await client.interactions.find({ locator: 'label', query: 'Foo', action: 'list' });
+
+  const listType: Equal<typeof list, FindCommandResponseData> = true;
+  assert.ok(listType);
+  assert.deepEqual(
+    list.matches?.map((match) => match.ref),
+    ['@e5', '@e9'],
+  );
+  assert.equal(list.refsGeneration, 42);
+});
+
 test('interaction responses expose additive cost and direct-iOS Maestro fallback fields', async () => {
   const setup = createTransport(async (req) => {
     if (req.command === 'press') {
 
@@ -50,6 +50,7 @@ const FIND_ACTION_VALUES = [
   'click',
   'focus',
   'exists',
+  'list',
   'getText',
   'getAttrs',
   'wait',
 
@@ -50,6 +50,34 @@ describe('find CLI output', () => {
     const output = formatFind({ found: true });
     expect(output.text).toBe('Found: true');
   });
+
+  test('list renders every match with a pinned, paste-ready ref', () => {
+    const output = formatFind({
+      matches: [
+        { ref: '@e5', node: { ref: 'e5', type: 'Button', label: 'Add' } },
+        { ref: '@e9', node: { ref: 'e9', type: 'Cell', value: 'Add another account' } },
+        { ref: '@e12', node: { ref: 'e12', type: 'Other' } },
+      ],
+      refsGeneration: 500014,
+    });
+
+    expect(output.text).toBe(
+      [
+        '3 matches:',
+        '= @e5~s500014 [button] "Add"',
+        '= @e9~s500014 [cell] "Add another account"',
+        '= @e12~s500014 [other]',
+      ].join('\n'),
+    );
+  });
+
+  test('list without a generation still lists refs unpinned rather than hiding them', () => {
+    const output = formatFind({
+      matches: [{ ref: '@e5', node: { ref: 'e5', type: 'Button', label: 'Add' } }],
+    });
+
+    expect(output.text).toBe(['1 match:', '= @e5 [button] "Add"'].join('\n'));
+  });
 });
 
 describe('press CLI output', () => {
 
@@ -1,5 +1,7 @@
 import type { CommandRequestResult } from '@agent-device/contracts/client';
+import type { SnapshotNode } from '@agent-device/kernel/snapshot';
 import type { CliOutput } from '../command-contract.ts';
+import { displayLabel, formatRole } from '../../snapshot/snapshot-lines.ts';
 import { readCommandMessage } from '../../utils/success-text.ts';
 import { messageCliOutput, resultOutput, type CliOutputFormatter } from '../output-common.ts';
 
@@ -32,6 +34,9 @@ function findCliOutput(result: CommandRequestResult): CliOutput {
   const message = readCommandMessage(data);
   if (message) return { data, text: message };
   if (typeof data.text === 'string') return { data, text: data.text };
+  if (Array.isArray(data.matches)) {
+    return { data, text: formatFindMatchLines(data.matches, data.refsGeneration) };
+  }
   // A read-only find that returns a reusable ref renders it pinned (ADR 0014).
   const pinned = pinnedRefText(data.ref, data.refsGeneration);
   if (pinned) return { data, text: `Found: ${pinned}` };
@@ -40,6 +45,28 @@ function findCliOutput(result: CommandRequestResult): CliOutput {
   return defaultCommandCliOutput(data);
 }
 
+type FindMatchView = { ref?: string; node?: SnapshotNode };
+
+// `find … list` (#1625): every match on its own line with a pinned, paste-ready
+// ref (ADR 0014) — the whole point of list is that ANY listed ref can drive the
+// next command, so no line may render a bare `@eN` the daemon would reject.
+// Role/label display goes through the snapshot-line normalizers so a list line
+// reads exactly like the snapshot line for the same node on every platform.
+function formatFindMatchLines(matches: unknown[], refsGeneration: unknown): string {
+  const heading = `${matches.length} match${matches.length === 1 ? '' : 'es'}:`;
+  const lines = matches.map((entry) => formatFindMatchLine(entry as FindMatchView, refsGeneration));
+  return [heading, ...lines].join('\n');
+}
+
+function formatFindMatchLine(view: FindMatchView, refsGeneration: unknown): string {
+  const plain = view.ref ?? '';
+  const body = plain.startsWith('@') ? plain.slice(1) : plain;
+  const ref = pinnedRefText(plain, refsGeneration) ?? `@${body}`;
+  const role = formatRole(view.node?.type ?? 'Element');
+  const label = view.node ? displayLabel(view.node, role) : '';
+  return `= ${ref} [${role}]${label ? ` "${label}"` : ''}`;
+}
+
 function isCliOutput(result: CommandRequestResult): CliOutput {
   const data = result as Record<string, unknown>;
   return { data, text: `Passed: is ${data.predicate ?? 'assertion'}` };
 
@@ -9,6 +9,7 @@ import {
   checkIsPredicate,
   evaluateIsPredicate,
   IS_TEXT_VALUE_REQUIRED_MESSAGE,
+  listSelectorChainMatches,
   readSelectorAlternatives,
   parseFindSelectorExpression,
   type FindAction,
@@ -20,6 +21,7 @@ import type { AgentDeviceRuntime, CommandContext } from '../../../runtime-contra
 import { AppError } from '@agent-device/kernel/errors';
 import type {
   ElementTarget,
+  FindReadResult,
   ResolvedTarget,
   SelectorTarget,
 } from '@agent-device/contracts/interaction';
@@ -60,14 +62,11 @@ export type { ElementTarget, ResolvedTarget, SelectorTarget };
 export type FindReadCommandOptions = CommandContext & {
   locator?: FindLocator;
   query: string;
-  action: Extract<FindAction['kind'], 'exists' | 'wait' | 'get_text' | 'get_attrs'>;
+  action: Extract<FindAction['kind'], 'exists' | 'wait' | 'get_text' | 'get_attrs' | 'list'>;
   timeoutMs?: number;
 } & SelectorSnapshotOptions;
 
-export type FindReadCommandResult =
-  | { kind: 'found'; found: true; waitedMs?: number }
-  | { kind: 'text'; ref: string; text: string; node: SnapshotNode }
-  | { kind: 'attrs'; ref: string; node: SnapshotNode };
+export type FindReadCommandResult = FindReadResult;
 
 export type GetCommandOptions = CommandContext &
   SelectorSnapshotOptions & {
@@ -162,6 +161,9 @@ export const findCommand: RuntimeCommand<FindReadCommandOptions, FindReadCommand
   if (options.action === 'wait') {
     return await waitForFindMatch(runtime, options, locator);
   }
+  if (options.action === 'list') {
+    return await listFindMatches(runtime, options, locator);
+  }
 
   const { capture, match } = await findFirstLocatorMatch(runtime, options, locator);
   if (!match) {
@@ -418,6 +420,39 @@ async function waitForFindMatch(
   throw waitTimeoutError('find wait timed out', polling, deadline);
 }
 
+/**
+ * `find <q> list` (#1625): the inspection path. Returns EVERY match — unique
+ * included — with its ref, and never narrows or taps. The old recovery hint
+ * told agents to run bare `find` to "list matches", which clicks a unique
+ * match; this is the surface that guidance actually needed.
+ */
+async function listFindMatches(
+  runtime: AgentDeviceRuntime,
+  options: FindReadCommandOptions,
+  locator: FindLocator,
+): Promise<Extract<FindReadCommandResult, { kind: 'list' }>> {
+  const selectorExpression = parseFindSelectorExpression(locator, options.query);
+  // Deliberately UNSCOPED: findSnapshotScope narrows the capture to the first
+  // label match, which is exactly wrong for an action whose purpose is to show
+  // every match.
+  const capture = await captureSelectorSnapshot(runtime, options, {
+    updateSession: true,
+    ...deriveSelectorCapturePolicy(),
+  });
+  if (isSparseSnapshotQualityVerdict(capture.snapshot.snapshotQuality)) {
+    throw sparseSelectorSnapshotError(capture.snapshot.snapshotQuality);
+  }
+  const matched = selectorExpression
+    ? (listSelectorChainMatches(capture.snapshot.nodes, selectorExpression, {
+        platform: runtime.backend.platform,
+      })?.matchedNodes ?? [])
+    : findBestMatchesByLocator(capture.snapshot.nodes, locator, options.query, {}).matches;
+  return {
+    kind: 'list',
+    matches: matched.map((node) => ({ ref: `@${node.ref}`, node })),
+  };
+}
+
 async function findFirstLocatorMatch(
   runtime: AgentDeviceRuntime,
   options: FindReadCommandOptions,