refactor: ride the Interactor seam for the element read; drop the bespoke host

Two operations of the same class were reaching their mechanics two different
ways: `findText` rides `Interactor` via `localInteractors.resolve`, while
`readTextAtPoint` had its own host port. That is duplication of MECHANISM, so
the read now rides the same seam.

`Interactor` gains `readTextAtPoint?`, implemented on the Apple, Android and
Linux interactors where those mechanics already live.
`src/platform-runtime-element-text-host.ts` and its `elementText` host wiring
are deleted; the contract binds through the resolver exactly as the snapshot
runtime does.

Size honesty: this removes an 89-line module but the four readers still have to
exist, so they moved into the interactors rather than vanishing. Net production
change is ~4 lines, not ~89. The duplication of mechanism is what is actually
fixed; Wave 5/6 retires the seam for both operations together.

Also from the size investigation:
- `ElementTextRuntimeExecution` was byte-identical to `SnapshotRuntimeExecution`;
  removed and reused, as `find-text-runtime.ts` does.
- Removed a stranded, stale comment in `selector-capture-binding.ts` that still
  claimed a duplication this branch had already retired.
- `FrozenUnavailablePlatformRuntimeFacts` is derived from its input type rather
  than restated, removing a 14-line clone group my new cell had pushed over the
  detector threshold.

Author: agent

packages/contracts/src/element-text-runtime.ts

@@ -1,11 +1,9 @@
 import type { DeviceInfo } from '@agent-device/kernel/device';
 import type { Point } from '@agent-device/kernel/snapshot';
-import type { RunnerContext } from './interactor-types.ts';
+import type { Interactor, RunnerContext } from './interactor-types.ts';
 import type { RuntimeOperationFact } from './platform-runtime.ts';
 import type { SessionSurface } from './session-surface.ts';
-
-/** Runner metadata the selected read implementation needs, without request-owned state. */
-export type ElementTextRuntimeExecution = Readonly<Omit<RunnerContext, 'appBundleId' | 'signal'>>;
+import type { SnapshotRuntimeExecution } from './snapshot-runtime.ts';
 
 /**
  * Neutral intent for one point-addressed element read. The point is already resolved from the
@@ -14,7 +12,8 @@ export type ElementTextRuntimeExecution = Readonly<Omit<RunnerContext, 'appBundl
 export type ReadTextAtPointInput = Readonly<{
   point: Point;
   options?: Readonly<{ appBundleId?: string; surface?: SessionSurface }>;
-  execution?: ElementTextRuntimeExecution;
+  /** Same runner metadata a capture needs; reuses that type rather than restating it. */
+  execution?: SnapshotRuntimeExecution;
 }>;
 
 /**
@@ -71,24 +70,47 @@ export function elementTextRuntimeOperationFacts(
   return Object.freeze({ readTextAtPoint: input.readTextAtPoint });
 }
 
+/** Resolves the selected owner's interactor, exactly as the snapshot runtime does. */
+export type ElementTextInteractorResolver = (
+  device: DeviceInfo,
+  runner: RunnerContext,
+) => Promise<Interactor>;
+
 /**
- * The existing per-family read mechanics, injected by composition. Families reach their own
- * tools through this port rather than importing root modules, matching the snapshot runtime's
- * interactor-resolver seam.
+ * Binds the owner's live point read for the lifetime of a request binding.
+ *
+ * Rides the same `Interactor` seam `findText` uses rather than a bespoke host port: two
+ * operations of the same class reaching their mechanics two different ways is duplication of
+ * mechanism, and Wave 5/6 retires the seam for both together.
  */
-export type ElementTextRuntimeHost = Readonly<{
-  readTextAtPoint(device: DeviceInfo, input: ReadTextAtPointInput): Promise<ElementTextReadOutcome>;
-}>;
-
-/** Captures one selected owner's read authority for the lifetime of a request binding. */
 export function bindElementTextRuntime(
   params: Readonly<{
     device: DeviceInfo;
-    host: ElementTextRuntimeHost;
+    signal: AbortSignal;
+    resolveInteractor: ElementTextInteractorResolver;
   }>,
 ): ElementTextRuntimeOperations {
   return Object.freeze({
-    readTextAtPoint: async (input: ReadTextAtPointInput) =>
-      await params.host.readTextAtPoint(params.device, input),
+    readTextAtPoint: async (input: ReadTextAtPointInput) => {
+      const signal = params.signal;
+      signal.throwIfAborted();
+      const interactor = await params.resolveInteractor(params.device, {
+        ...input.execution,
+        appBundleId: input.options?.appBundleId,
+        signal,
+      });
+      // An owner whose facts advertised the read but whose interactor has none is a runtime
+      // contract error surfaced as a declined read, not a silent empty answer.
+      if (!interactor.readTextAtPoint) {
+        return Object.freeze({ status: 'unreadable', reason: 'surface-not-readable' } as const);
+      }
+      return elementTextRead(
+        await interactor.readTextAtPoint(input.point, {
+          appBundleId: input.options?.appBundleId,
+          surface: input.options?.surface,
+          signal,
+        }),
+      );
+    },
   });
 }

packages/contracts/src/facades/platform.ts

@@ -283,8 +283,7 @@ export {
 } from '../element-text-runtime.ts';
 export type {
   ElementTextReadOutcome,
-  ElementTextRuntimeExecution,
-  ElementTextRuntimeHost,
+  ElementTextInteractorResolver,
   ElementTextRuntimeOperationFacts,
   ElementTextRuntimeOperations,
   ElementTextUnreadableReason,

packages/contracts/src/interactor-types.ts

@@ -222,6 +222,16 @@ export type Interactor = {
   screenshot(outPath: string, options?: ScreenshotOptions): Promise<void>;
   setViewport?(width: number, height: number): Promise<Record<string, unknown> | void>;
   snapshot(options?: SnapshotOptions): Promise<SnapshotResult>;
+  /**
+   * Native reading of the live text at a point, when the backend has one. Answers the text the
+   * owner can see right now, which can exceed what an already-captured node carries (an editable
+   * field whose value is longer than its label). Optional: a backend without it leaves the
+   * captured tree as the complete answer.
+   */
+  readTextAtPoint?(
+    point: Point,
+    options?: { appBundleId?: string; surface?: SessionSurface; signal?: AbortSignal },
+  ): Promise<string | undefined>;
   gestureViewport?(): Promise<Rect>;
   back(mode?: BackMode): Promise<void>;
   home(): Promise<void>;

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

@@ -15,10 +15,7 @@ import type { ScreenRecordingRuntimeOperations } from './screen-recording-runtim
 import type { ScreenshotRuntimeOperations } from './screenshot-runtime.ts';
 import type { SnapshotRuntimeHost, SnapshotRuntimeOperations } from './snapshot-runtime.ts';
 import type { ViewportRuntimeOperations } from './viewport-runtime.ts';
-import type {
-  ElementTextRuntimeHost,
-  ElementTextRuntimeOperations,
-} from './element-text-runtime.ts';
+import type { ElementTextRuntimeOperations } from './element-text-runtime.ts';
 import type {
   DeviceReadinessRuntimeHost,
   DeviceReadinessRuntimeOperations,
@@ -291,7 +288,6 @@ export type PlatformRuntimeHost = AppLogRuntimeHost &
     }>;
     screenRecording: ScreenRecordingRuntimeHost;
     snapshot: SnapshotRuntimeHost;
-    elementText: ElementTextRuntimeHost;
     deviceReadiness: DeviceReadinessRuntimeHost;
     deviceShutdown: DeviceShutdownRuntimeHost;
     localInteractors: LocalApplicationInteractorHost;

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

@@ -35,21 +35,14 @@ export type UnavailablePlatformRuntimeFacts = Readonly<{
   lifecycle: ApplicationLifecycleOperationFacts;
 }>;
 
-type FrozenUnavailablePlatformRuntimeFacts = Readonly<{
-  appLog: RuntimeOperationUnavailability;
-  apps: RuntimeOperationUnavailability;
-  appDeployment: RuntimeOperationUnavailability;
-  appState: RuntimeOperationUnavailability;
-  network: RuntimeOperationUnavailability;
-  screenRecording: RuntimeOperationUnavailability;
-  screenshot: RuntimeOperationUnavailability;
-  snapshot: RuntimeOperationUnavailability;
-  viewport: RuntimeOperationUnavailability;
-  elementText: RuntimeOperationUnavailability;
-  readiness: RuntimeOperationUnavailability;
-  shutdown: RuntimeOperationUnavailability;
-  lifecycle: ApplicationLifecycleOperationFacts;
-}>;
+/**
+ * The same cells with every optional one resolved. Derived from the input type rather than
+ * restated, so a new cell cannot be added to one and forgotten in the other.
+ */
+type FrozenUnavailablePlatformRuntimeFacts = Readonly<
+  Required<Omit<UnavailablePlatformRuntimeFacts, 'lifecycle'>> &
+    Readonly<{ lifecycle: ApplicationLifecycleOperationFacts }>
+>;
 
 export function createUnavailablePlatformRuntimeBinding(
   device: DeviceInfo,

packages/platform-android/src/runtime.ts

@@ -220,7 +220,11 @@ export function createAndroidPlatformRuntime(host: PlatformRuntimeHost): Platfor
               })
             : {}),
           ...(facts.operations.readTextAtPoint.available
-            ? bindElementTextRuntime({ device: request.device, host: host.elementText })
+            ? bindElementTextRuntime({
+                device: request.device,
+                signal: request.scope.signal,
+                resolveInteractor: host.localInteractors.resolve,
+              })
             : {}),
           ensureReady: async (input: EnsureReadyInput) =>
             await ensureAndroidReady(

packages/platform-apple/src/runtime.ts

@@ -288,7 +288,11 @@ export function createApplePlatformRuntime(host: PlatformRuntimeHost): PlatformR
               })
             : {}),
           ...(facts.operations.readTextAtPoint.available
-            ? bindElementTextRuntime({ device: request.device, host: host.elementText })
+            ? bindElementTextRuntime({
+                device: request.device,
+                signal: request.scope.signal,
+                resolveInteractor: host.localInteractors.resolve,
+              })
             : {}),
           ...(facts.operations.ensureReady.available
             ? {

packages/platform-linux/src/runtime.ts

@@ -97,7 +97,11 @@ export function createLinuxPlatformRuntime(host: PlatformRuntimeHost): PlatformR
               })
             : {}),
           ...(facts.operations.readTextAtPoint.available
-            ? bindElementTextRuntime({ device: request.device, host: host.elementText })
+            ? bindElementTextRuntime({
+                device: request.device,
+                signal: request.scope.signal,
+                resolveInteractor: host.localInteractors.resolve,
+              })
             : {}),
         }),
         [Symbol.asyncDispose]: async () => undefined,

src/core/interactors/android.ts

@@ -65,6 +65,11 @@ export function createAndroidInteractor(
     performGesture: (plan) => executeAndroidTouchPlan(device, plan),
     gestureViewport: () => readAndroidGestureViewport(device),
     screenshot: (outPath, options) => screenshotAndroid(device, outPath, options),
+    // uiautomator reads the node covering a point; `undefined` means nothing covers it.
+    readTextAtPoint: async (point) => {
+      const { readAndroidTextAtPoint } = await import('../../platforms/android/input-actions.ts');
+      return (await readAndroidTextAtPoint(device, point.x, point.y)) ?? undefined;
+    },
     snapshot: async (options) => {
       const snapshotOptions = options ?? {};
       const result = await withDiagnosticTimer(

src/core/interactors/linux.ts

@@ -45,6 +45,12 @@ export function createLinuxInteractor(): Interactor {
       await swipeLinux(start.x, start.y, end.x, end.y, plan.durationMs);
     },
     screenshot: (outPath, options) => screenshotLinux(outPath, options),
+    // The Linux read is value-first (AXValue/title/description) where the captured tree is
+    // label-first, so this genuinely reads differently from its snapshot text.
+    readTextAtPoint: async (point, options) => {
+      const { readLinuxTextAtPoint } = await import('../../platforms/linux/snapshot.ts');
+      return await readLinuxTextAtPoint(point.x, point.y, options?.surface);
+    },
     snapshot: async (options) => {
       return await withDiagnosticTimer(
         'snapshot_capture',