feat(daemon): land the selector capture seam with get as its first consumer

Takes ownership of the request-bound selector capture seam from #1876, which
cannot ship standalone: with find's cutover deferred it had no consuming
command (ADR 0019 §10) and was not dead-code clean (check:production-exports
19 -> 20). `get` is its first consumer, so it lands here.

Adopts find's handoff as given. The one shape change, approved by the
coordinator: the selector family gets its own capture uses carrying a PREFERRED
`readTextAtPoint`, declared ALONGSIDE the snapshot uses so `snapshot`/`diff`
keep binding exactly what they bind today. The read is surfaced through the
existing arms of `bindSnapshotCaptureRuntime`, reusing the same
selectActiveAppSnapshot / selectSnapshotWithoutActiveApp selectors — no second
plan-to-operation dispatch.

`get` now runs through `createBoundSelectorRuntime`; `resolveBoundGetRuntime`
and its test are deleted as superseded, and `'get'` leaves the
`createSelectorRuntime` capability union.

The legacy read adapter survives for `find <q> get text` and is selected by
which command constructed the runtime — never by failure, family, environment,
or flag — so `get` cannot reach it. It retires in find's cutover, where the
last consumer moves.

Author: agent

packages/contracts/src/facades/platform.ts

@@ -213,11 +213,16 @@ export {
   appsRuntimeUse,
   captureSnapshotUse,
   defineUse,
+  resolveSelectorCaptureRuntimePlan,
   resolveSnapshotRuntimePlan,
+  selectorCaptureRuntimePlanUses,
   snapshotRuntimePlanUses,
   viewportRuntimeUse,
 } from '../platform-runtime-operations.ts';
-export type { SnapshotRuntimePlan } from '../platform-runtime-operations.ts';
+export type {
+  SelectorCaptureRuntimePlan,
+  SnapshotRuntimePlan,
+} from '../platform-runtime-operations.ts';
 export type {
   PlatformRuntimeHost,
   PlatformRuntimeModule,
@@ -233,13 +238,8 @@ export {
   appStateRuntimeUses,
   appStateUse,
   shutdownTargetUse,
-  elementReadRuntimeUse,
-  elementReadRuntimePlan,
-} from '../platform-runtime-operations.ts';
-export type {
-  DeviceReadinessRuntimePlan,
-  ElementReadRuntimePlan,
 } from '../platform-runtime-operations.ts';
+export type { DeviceReadinessRuntimePlan } from '../platform-runtime-operations.ts';
 export {
   bindLocalSnapshotInteractor,
   bindProviderSnapshotInteractor,

packages/contracts/src/platform-runtime-operations.ts

@@ -69,30 +69,6 @@ export const bootTargetHeadlessUse = defineUse({
 export const appsRuntimeUse = defineUse({ required: ['ensureReady', 'listApps'] });
 export const captureSnapshotUse = defineUse({ required: ['captureSnapshot'] });
 export const viewportRuntimeUse = defineUse({ required: ['setViewport'] });
-/**
- * `get` reads one element's text or attributes. The required path answers from the captured
- * tree on every supported cell; `readTextAtPoint` is the owner-provided live read that recovers
- * fuller text for editable/expandable elements, so it is preferred rather than required (ADR
- * 0019 §2). An owner without it still executes `get` completely.
- */
-export const elementReadRuntimeUse = defineUse({
-  required: ['captureSnapshot'],
-  preferred: ['readTextAtPoint'],
-});
-
-/**
- * `get`'s use does not vary with its input, so there is nothing to resolve: the one plan is a
- * frozen constant rather than a `resolve…RuntimePlan` over a single row.
- */
-export type ElementReadRuntimePlan = Readonly<{
-  kind: 'element-read';
-  use: typeof elementReadRuntimeUse;
-}>;
-
-export const elementReadRuntimePlan: ElementReadRuntimePlan = Object.freeze({
-  kind: 'element-read',
-  use: elementReadRuntimeUse,
-});
 const captureSnapshotWithCustomActionsUse = defineUse({
   required: ['captureSnapshot', 'captureSnapshotWithCustomActions'],
 });
@@ -107,6 +83,31 @@ const captureSnapshotWithCustomActionsWithoutActiveAppUse = defineUse({
   ],
 });
 
+/**
+ * The selector family's capture uses. Declared ALONGSIDE the snapshot uses above, never in place
+ * of them: `snapshot`/`diff` keep binding exactly what they bind today. The only difference is the
+ * PREFERRED element read — every selector read's required path answers from the captured tree, so
+ * an owner without the read still executes the command completely (ADR 0019 §2), but an owner that
+ * has one lets `get text` return the live value a truncated snapshot node cannot.
+ */
+const selectorCaptureUse = defineUse({
+  required: ['captureSnapshot'],
+  preferred: ['readTextAtPoint'],
+});
+const selectorCaptureWithoutActiveAppUse = defineUse({
+  required: ['captureSnapshot', 'captureSnapshotWithoutActiveApp'],
+  preferred: ['readTextAtPoint'],
+});
+
+/**
+ * The selector family (`find`, `get`, `is`, `wait`) resolves targets from the plain accessibility
+ * capture: it exposes no `--actions` surface, so only the active-app split applies.
+ */
+export const selectorCaptureRuntimePlanUses = Object.freeze([
+  selectorCaptureUse,
+  selectorCaptureWithoutActiveAppUse,
+] as const);
+
 export const snapshotRuntimePlanUses = Object.freeze([
   captureSnapshotUse,
   captureSnapshotWithCustomActionsUse,
@@ -136,30 +137,67 @@ export type SnapshotRuntimePlan =
       use: typeof captureSnapshotWithoutActiveAppUse;
     }>;
 
+/**
+ * Same two `kind`s the snapshot plan uses for this split — deliberately, so the shared
+ * admit-then-bind path keeps ONE set of arms rather than growing a parallel dispatch — but
+ * carrying the selector uses, which add the preferred element read.
+ */
+export type SelectorCaptureRuntimePlan =
+  | Readonly<{
+      kind: 'selector-active-app';
+      operation: 'captureSnapshot';
+      use: typeof selectorCaptureUse;
+    }>
+  | Readonly<{
+      kind: 'selector-without-active-app';
+      operation: 'captureSnapshotWithoutActiveApp';
+      use: typeof selectorCaptureWithoutActiveAppUse;
+    }>;
+
+/**
+ * The active-app split every selector capture selects from. The selector family exposes no
+ * `--actions` surface, so custom actions are outside its declaration.
+ */
+export function resolveSelectorCaptureRuntimePlan(
+  input: Readonly<{ hasActiveApp: boolean }>,
+): SelectorCaptureRuntimePlan {
+  return input.hasActiveApp
+    ? Object.freeze({
+        kind: 'selector-active-app',
+        operation: 'captureSnapshot',
+        use: selectorCaptureUse,
+      })
+    : Object.freeze({
+        kind: 'selector-without-active-app',
+        operation: 'captureSnapshotWithoutActiveApp',
+        use: selectorCaptureWithoutActiveAppUse,
+      });
+}
+
 /** Selects one owner-fact-backed capture plan from normalized command/session intent. */
 export function resolveSnapshotRuntimePlan(input: {
   customActions: boolean;
   hasActiveApp: boolean;
 }): SnapshotRuntimePlan {
-  if (input.customActions) {
+  if (!input.customActions) {
     return input.hasActiveApp
-      ? Object.freeze({
-          kind: 'custom-actions-active-app',
-          operation: 'captureSnapshotWithCustomActions',
-          use: captureSnapshotWithCustomActionsUse,
-        })
+      ? Object.freeze({ kind: 'active-app', operation: 'captureSnapshot', use: captureSnapshotUse })
       : Object.freeze({
-          kind: 'custom-actions-without-active-app',
-          operation: 'captureSnapshotWithCustomActions',
-          use: captureSnapshotWithCustomActionsWithoutActiveAppUse,
+          kind: 'without-active-app',
+          operation: 'captureSnapshotWithoutActiveApp',
+          use: captureSnapshotWithoutActiveAppUse,
         });
   }
   return input.hasActiveApp
-    ? Object.freeze({ kind: 'active-app', operation: 'captureSnapshot', use: captureSnapshotUse })
+    ? Object.freeze({
+        kind: 'custom-actions-active-app',
+        operation: 'captureSnapshotWithCustomActions',
+        use: captureSnapshotWithCustomActionsUse,
+      })
     : Object.freeze({
-        kind: 'without-active-app',
-        operation: 'captureSnapshotWithoutActiveApp',
-        use: captureSnapshotWithoutActiveAppUse,
+        kind: 'custom-actions-without-active-app',
+        operation: 'captureSnapshotWithCustomActions',
+        use: captureSnapshotWithCustomActionsWithoutActiveAppUse,
       });
 }
 export const deviceBootRuntimeUses = Object.freeze([bootTargetUse, bootTargetHeadlessUse] as const);

scripts/layering/runtime-command-cutover-table.ts

@@ -521,13 +521,18 @@ export const MIGRATED_COMMAND_CUTOVERS: readonly MigratedCommandCutover[] = [
       routeNames: ['WEB_QUERY_COMMANDS_WITH_GET', 'HARMONYOS_GET_SUPPORT'],
     },
     runtimeTypeNames: ['ElementTextRuntimeOperations', 'SnapshotRuntimeOperations'],
-    operations: { names: ['captureSnapshot', 'readTextAtPoint'] },
+    operations: {
+      names: ['captureSnapshot', 'captureSnapshotWithoutActiveApp', 'readTextAtPoint'],
+    },
     singularExecution: {
       routes: ['dispatchGetViaRuntime'],
-      operations: ['captureSnapshot', 'readTextAtPoint'],
+      operations: ['captureSnapshot', 'captureSnapshotWithoutActiveApp', 'readTextAtPoint'],
+      // `get` executes through the shared selector seam, so the capture owners are the SAME
+      // selectors `snapshot`/`diff` count; only the preferred element read is this unit's own.
       operationOwners: {
-        captureSnapshot: ['selectElementReadOperations'],
-        readTextAtPoint: ['selectElementTextRead'],
+        captureSnapshot: ['selectActiveAppSnapshot'],
+        captureSnapshotWithoutActiveApp: ['selectSnapshotWithoutActiveApp'],
+        readTextAtPoint: ['bindElementRead'],
       },
     },
   },

src/__tests__/test-utils/session-factories.ts

@@ -51,6 +51,15 @@ export function makeIosSession(name: string, overrides?: Partial<SessionState>):
   return makeSession(name, { device: IOS_SIMULATOR, ...overrides });
 }
 
+/**
+ * An iOS session with a tracked app — what `open <app>` produces. The shared snapshot
+ * runtime exposes capture on an iOS leaf only through the active-app plan row, so a test
+ * that captures on iOS needs this rather than a bare session.
+ */
+export function makeIosAppSession(name: string, overrides?: Partial<SessionState>): SessionState {
+  return makeIosSession(name, { appBundleId: 'com.example.app', ...overrides });
+}
+
 export function makeAndroidSession(name: string, overrides?: Partial<SessionState>): SessionState {
   return makeSession(name, { device: ANDROID_EMULATOR, ...overrides });
 }

src/core/command-descriptor/registry.ts

@@ -26,7 +26,7 @@ import {
   readySendPushNotificationUse,
   openApplicationRuntimePlanUses,
   closeApplicationRuntimePlanUses,
-  elementReadRuntimeUse,
+  selectorCaptureRuntimePlanUses,
   snapshotRuntimePlanUses,
   prepareAppleRunnerRuntimeUse,
   runtimeCommandRuntimePlanUses,
@@ -1190,7 +1190,7 @@ export const RAW_COMMAND_DESCRIPTORS = [
     daemon: { route: 'interaction', refFrameEffect: 'preserve' },
     timeoutPolicy: postActionObservationTimeoutPolicy('get', PRESERVE_DAEMON_TIMEOUT_POLICY),
     batchable: true,
-    platformExecution: { kind: 'device-runtime', uses: [elementReadRuntimeUse] as const },
+    platformExecution: { kind: 'device-runtime', uses: selectorCaptureRuntimePlanUses },
   },
   {
     name: 'read',