@moretea-labs/forge 1.5.1 → 1.7.0

package/src/runtime/plugins/ios-physical-device.ts

@@ -1,8 +1,10 @@
-import { randomUUID } from 'crypto';
-import { existsSync, mkdirSync } from 'fs';
+import { createHash, randomUUID } from 'crypto';
+import { existsSync, mkdirSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { spawnSync } from 'child_process';
+import { performance } from 'perf_hooks';
 import { repositoryControllerRoot } from '../../cli/repositories/controller-home';
+import { runBoundedProcess } from '../execution/thin-harness/async-process';
 import { readJsonFile, writeJsonAtomic } from '../shared/json-files';
 import { AssistantPluginError, toAssistantPluginError } from './errors';
 import {
@@ -19,15 +21,22 @@ import {
 import type {
   AssistantPluginActionDescriptor,
   AssistantPluginActionExecutionInput,
+  AssistantPluginAuthorizationContext,
+  AssistantPluginAuthorizationTarget,
   AssistantPluginCapability,
 } from './types';
+import { executeRemoteXpcHidInput, prewarmRemoteXpcHid, remoteXpcHidStatus, stopRemoteXpcHidForDevice } from './ios/remote-xpc-hid';
 
 const PROVIDER = 'ios-device' as const;
 const SESSION_EXPIRY_MS = 2 * 60 * 60_000;
+const CORE_DEVICE_READY_CACHE_MS = 5 * 60_000;
+const INPUT_UNLOCK_CACHE_MS = 60_000;
+const INPUT_DISPLAY_CACHE_MS = 5 * 60_000;
+const INPUT_FOREGROUND_OBSERVATION_TTL_MS = 30_000;
 const MAX_JSON_BYTES = 64 * 1024;
 const MAX_EVENTS = 200;
-const LOCAL_RUNNER_HOSTS = new Set(['127.0.0.1', 'localhost', '::1', '[::1]']);
-const SENSITIVE_SEMANTICS = /secure\s*text|securetextfield|password|passcode|verification|one[ -]?time|otp|2fa|验证码|校验码|短信码|生物识别|biometric|face\s?id|touch\s?id|支付|付款|购买|下单|提交订单|结算|checkout|payment|purchase|confirm\s+order|bank|card|cvv|身份证/i;
+const MAX_BATCH_STEPS = 20;
+const MAX_BATCH_WAIT_MS = 5_000;
 
 interface CommandResult {
   ok: boolean;
@@ -41,69 +50,69 @@ interface CommandOptions {
   cwd?: string;
   timeoutMs?: number;
   env?: NodeJS.ProcessEnv;
-}
-
-export interface RunnerHttpResult {
-  ok: boolean;
-  status: number;
-  body?: unknown;
-  text: string;
+  signal?: AbortSignal;
 }
 
 export interface IosPhysicalDeviceRuntimeHooks {
   platform(): NodeJS.Platform;
   now(): Date;
   runCommand(command: string, args: string[], options?: CommandOptions): CommandResult;
-  requestJson(method: string, url: string, body?: unknown, timeoutMs?: number): Promise<RunnerHttpResult>;
+  runCommandAsync(command: string, args: string[], options?: CommandOptions): Promise<CommandResult>;
+}
+
+function runCommandSync(command: string, args: string[], options: CommandOptions = {}): CommandResult {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    encoding: 'utf8',
+    timeout: options.timeoutMs ?? 30_000,
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: String(result.stdout ?? ''),
+    stderr: String(result.stderr ?? result.error?.message ?? ''),
+    command: [command, ...args],
+  };
+}
+
+async function runCommandAsync(command: string, args: string[], options: CommandOptions = {}): Promise<CommandResult> {
+  const result = await runBoundedProcess(command, args, {
+    cwd: options.cwd ?? process.cwd(),
+    env: options.env,
+    timeoutMs: options.timeoutMs ?? 30_000,
+    maxOutputBytes: 4 * 1024 * 1024,
+    signal: options.signal,
+  });
+  return {
+    ok: result.ok,
+    status: result.exitCode,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    command: [command, ...args],
+  };
 }
 
 const defaultHooks: IosPhysicalDeviceRuntimeHooks = {
   platform: () => process.platform,
   now: () => new Date(),
-  runCommand: (command, args, options = {}) => {
-    const result = spawnSync(command, args, {
-      cwd: options.cwd,
-      env: options.env,
-      encoding: 'utf8',
-      timeout: options.timeoutMs ?? 30_000,
-      maxBuffer: 4 * 1024 * 1024,
-    });
-    return {
-      ok: result.status === 0,
-      status: result.status,
-      stdout: String(result.stdout ?? ''),
-      stderr: String(result.stderr ?? result.error?.message ?? ''),
-      command: [command, ...args],
-    };
-  },
-  requestJson: async (method, url, body, timeoutMs = 30_000) => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: body === undefined ? undefined : { 'content-type': 'application/json' },
-        body: body === undefined ? undefined : JSON.stringify(body),
-        signal: controller.signal,
-      });
-      const text = await response.text();
-      let parsed: unknown;
-      try { parsed = text ? JSON.parse(text) : undefined; } catch { parsed = undefined; }
-      return { ok: response.ok, status: response.status, body: parsed, text };
-    } finally {
-      clearTimeout(timer);
-    }
-  },
+  runCommand: runCommandSync,
+  runCommandAsync,
 };
 
 let hooks: IosPhysicalDeviceRuntimeHooks = { ...defaultHooks };
 
 export function setIosPhysicalDeviceRuntimeHooksForTest(overrides: Partial<IosPhysicalDeviceRuntimeHooks>): void {
   hooks = { ...defaultHooks, ...overrides };
+  if (overrides.runCommand && !overrides.runCommandAsync) {
+    hooks.runCommandAsync = async (command, args, options = {}) => overrides.runCommand!(command, args, options);
+  }
 }
 
 export function resetIosPhysicalDeviceRuntimeHooksForTest(): void {
   hooks = { ...defaultHooks };
+  coreDeviceReadyCache = undefined;
 }
 
 interface PhysicalDevice {
@@ -124,6 +133,19 @@ interface PhysicalDevice {
   connected: boolean;
 }
 
+interface PhysicalDeviceCapabilitySummary {
+  applicationControl: boolean;
+  screenshot: boolean;
+  displayInfo: boolean;
+  lockState: boolean;
+  viewDeviceScreen: boolean;
+  hidDigitizer: boolean;
+  hidKeyboard: boolean;
+  hidScroll: boolean;
+  hidButton: boolean;
+  universalHid: boolean;
+}
+
 interface InstalledApp {
   name: string;
   bundleIdentifier: string;
@@ -138,25 +160,85 @@ interface PhysicalEvent {
   details?: unknown;
 }
 
+interface DisplayGeometry {
+  width: number;
+  height: number;
+  pointScale?: number;
+}
+
+interface CachedDisplayGeometry extends DisplayGeometry {
+  observedAt: string;
+}
+
+interface PhysicalScreenshotObservation {
+  observationId: string;
+  observedAt: string;
+  label: string;
+}
+
+interface PhysicalForegroundObservation {
+  observationId: string;
+  screenshotObservedAt: string;
+  confirmedAt: string;
+  bundleId: string;
+}
+
 interface PhysicalSessionState {
   schemaVersion: 1;
   interactionId: string;
   device: PhysicalDevice;
   bundleId: string;
-  runner: {
-    configured: boolean;
-    endpoint?: string;
-    ready: boolean;
-    sessionId?: string;
-    error?: string;
-  };
+  display?: CachedDisplayGeometry;
+  unlockVerifiedAt?: string;
+  lastScreenshot?: PhysicalScreenshotObservation;
+  foregroundObservation?: PhysicalForegroundObservation;
   events: PhysicalEvent[];
 }
 
+interface CoreDeviceStatus {
+  available: boolean;
+  platform: NodeJS.Platform;
+  coreDeviceReady: boolean;
+  devicectlVersion?: string;
+  reason?: string;
+  probed?: boolean;
+}
+
+type TimingStages = Record<string, { ms: number; cached?: boolean }>;
+let coreDeviceReadyCache: { checkedAtMs: number; status: CoreDeviceStatus } | undefined;
+
 function timestamp(): string {
   return hooks.now().toISOString();
 }
 
+function elapsedMs(startedAt: number): number {
+  return Math.round((performance.now() - startedAt) * 100) / 100;
+}
+
+function recordTiming(stages: TimingStages, name: string, startedAt: number, cached?: boolean): void {
+  stages[name] = { ms: elapsedMs(startedAt), ...(cached === undefined ? {} : { cached }) };
+}
+
+function finishTimedResult(
+  actionStartedAt: number,
+  stages: TimingStages,
+  result: Record<string, unknown>,
+): Record<string, unknown> {
+  return {
+    ...result,
+    timing: {
+      totalMs: elapsedMs(actionStartedAt),
+      stages,
+    },
+  };
+}
+
+function cacheAgeMs(observedAt: string | undefined): number | undefined {
+  if (!observedAt) return undefined;
+  const parsed = Date.parse(observedAt);
+  return Number.isFinite(parsed) ? Math.max(0, hooks.now().getTime() - parsed) : undefined;
+}
+
 function sanitize(value: string): string {
   return value.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'ios-device';
 }
@@ -235,6 +317,11 @@ function optionalString(value: unknown): string | undefined {
   return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
 
+function requireFiniteNumber(value: unknown, name: string): number {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `${name} must be a finite number.`, { retryable: false });
+}
+
 function requireBundleId(value: unknown): string {
   const bundleId = requireString(value, 'bundle_id');
   if (!/^[A-Za-z0-9][A-Za-z0-9.-]+$/.test(bundleId) || !bundleId.includes('.') || /^[a-z][a-z0-9+.-]*:\/\//i.test(bundleId)) {
@@ -255,18 +342,19 @@ function commandFailure(result: CommandResult, code: string, fallback: string):
   });
 }
 
-function runCoreJson(
+async function runCoreJson(
   input: AssistantPluginActionExecutionInput,
   args: string[],
   code: string,
   timeoutMs = 30_000,
-): Record<string, unknown> {
+): Promise<Record<string, unknown>> {
   if (hooks.platform() !== 'darwin') {
     throw new AssistantPluginError('PLUGIN_DEPENDENCY_MISSING', 'Physical iOS device support requires macOS and Xcode CoreDevice.', { retryable: false });
   }
-  const result = hooks.runCommand('xcrun', ['devicectl', ...args, '--json-output', '-'], {
+  const result = await hooks.runCommandAsync('xcrun', ['devicectl', ...args, '--json-output', '-'], {
     cwd: input.repoRoot,
     timeoutMs,
+    signal: input.signal,
   });
   if (!result.ok) return commandFailure(result, code, 'CoreDevice command failed.');
   let parsed: Record<string, unknown> | undefined;
@@ -289,8 +377,30 @@ function stringField(value: Record<string, unknown>, key: string): string | unde
   return typeof value[key] === 'string' && String(value[key]).trim() ? String(value[key]).trim() : undefined;
 }
 
-function physicalDevices(input: AssistantPluginActionExecutionInput): PhysicalDevice[] {
-  const response = runCoreJson(input, ['list', 'devices'], 'IOS_DEVICE_LIST_FAILED');
+function capabilityNames(value: unknown): string[] {
+  return (Array.isArray(value) ? value : [])
+    .map((entry) => stringField(objectValue(entry), 'name'))
+    .filter((entry): entry is string => Boolean(entry));
+}
+
+function capabilitySummary(names: string[]): PhysicalDeviceCapabilitySummary {
+  const features = new Set(names);
+  return {
+    applicationControl: features.has('Application Control') || features.has('Launch Application'),
+    screenshot: features.has('Capture Screenshot'),
+    displayInfo: features.has('Get Display Information'),
+    lockState: features.has('Get Lock State'),
+    viewDeviceScreen: features.has('View Device Screen'),
+    hidDigitizer: features.has('HID Digitizer'),
+    hidKeyboard: features.has('HID Keyboard'),
+    hidScroll: features.has('HID Scroll'),
+    hidButton: features.has('HID Button'),
+    universalHid: features.has('Universal HID Service Pool') || features.has('UniversalHIDService'),
+  };
+}
+
+async function physicalDevices(input: AssistantPluginActionExecutionInput): Promise<PhysicalDevice[]> {
+  const response = await runCoreJson(input, ['list', 'devices'], 'IOS_DEVICE_LIST_FAILED');
   const result = objectValue(response.result);
   const entries = Array.isArray(result.devices) ? result.devices : [];
   return entries
@@ -299,8 +409,7 @@ function physicalDevices(input: AssistantPluginActionExecutionInput): PhysicalDe
       const hardware = objectValue(entry.hardwareProperties);
       const device = objectValue(entry.deviceProperties);
       const connection = objectValue(entry.connectionProperties);
-      const capabilities = Array.isArray(entry.capabilities) ? entry.capabilities : [];
-      const capabilityNames = capabilities.map((item) => stringField(objectValue(item), 'name')).filter(Boolean);
+      const capabilities = capabilityNames(entry.capabilities);
       const pairingState = stringField(connection, 'pairingState');
       const tunnelState = stringField(connection, 'tunnelState');
       const bootState = stringField(device, 'bootState');
@@ -318,13 +427,13 @@ function physicalDevices(input: AssistantPluginActionExecutionInput): PhysicalDe
         bootState,
         developerMode: stringField(device, 'developerModeStatus'),
         ddiServicesAvailable: device.ddiServicesAvailable === true,
-        screenshotAvailable: capabilityNames.includes('Capture Screenshot'),
+        screenshotAvailable: capabilities.includes('Capture Screenshot'),
         connected: pairingState === 'paired'
           && bootState !== 'shutdown'
           && (tunnelState === 'connected'
             || device.ddiServicesAvailable === true
-            || capabilityNames.includes('Application Control')
-            || capabilityNames.includes('Launch Application')
+            || capabilities.includes('Application Control')
+            || capabilities.includes('Launch Application')
             || connection.transportType === 'usb'
             || connection.transportType === 'wired'),
         reality: stringField(hardware, 'reality'),
@@ -337,9 +446,9 @@ function physicalDevices(input: AssistantPluginActionExecutionInput): PhysicalDe
     .map(({ reality: _reality, platform: _platform, ...entry }) => entry);
 }
 
-function selectDevice(input: AssistantPluginActionExecutionInput, selectorValue: unknown): PhysicalDevice {
+async function selectDevice(input: AssistantPluginActionExecutionInput, selectorValue: unknown): Promise<PhysicalDevice> {
   const selector = requireString(selectorValue, 'device');
-  const inventory = physicalDevices(input);
+  const inventory = await physicalDevices(input);
   const matches = inventory.filter((entry) => entry.identifier === selector || entry.udid === selector || entry.name === selector);
   if (matches.length === 0) {
     throw new AssistantPluginError('IOS_DEVICE_NOT_FOUND', 'No paired physical iPhone matches the exact device selector.', {
@@ -360,14 +469,130 @@ function selectDevice(input: AssistantPluginActionExecutionInput, selectorValue:
   return selected;
 }
 
-function installedApps(
+async function physicalDeviceLockState(input: AssistantPluginActionExecutionInput, device: PhysicalDevice): Promise<Record<string, unknown>> {
+  const response = await runCoreJson(input, [
+    'device', 'info', 'lockState', '--device', device.identifier,
+  ], 'IOS_DEVICE_LOCK_STATE_FAILED', 30_000);
+  return objectValue(response.result);
+}
+
+async function requirePhysicalDeviceUnlocked(input: AssistantPluginActionExecutionInput, device: PhysicalDevice): Promise<void> {
+  const lockState = await physicalDeviceLockState(input, device);
+  if (lockState.passcodeRequired !== true) return;
+  throw new AssistantPluginError(
+    'IOS_DEVICE_LOCKED',
+    `The selected iPhone ${device.name} is locked. Unlock it before launching an app through CoreDevice.`,
+    {
+      retryable: true,
+      details: {
+        device: { identifier: device.identifier, name: device.name },
+        lockState: bounded(lockState),
+      },
+    },
+  );
+}
+
+async function physicalDisplayGeometry(input: AssistantPluginActionExecutionInput, device: PhysicalDevice): Promise<DisplayGeometry> {
+  const displayResponse = await runCoreJson(input, [
+    'device', 'info', 'displays', '--device', device.identifier,
+  ], 'IOS_DEVICE_DISPLAY_INFO_FAILED', 30_000);
+  const result = objectValue(displayResponse.result);
+  const displays = Array.isArray(result.displays) ? result.displays : [];
+  const rows = displays.filter((entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+  const primary = rows.find((entry) => entry.primary === true) ?? rows[0];
+  if (!primary) {
+    throw new AssistantPluginError('IOS_HID_DISPLAY_INVALID', 'CoreDevice did not report a usable iPhone display for input coordinate mapping.', { retryable: true });
+  }
+  const bounds = Array.isArray(primary.bounds) ? primary.bounds : undefined;
+  const size = bounds && Array.isArray(bounds[1]) ? bounds[1] : Array.isArray(primary.nativeSize) ? primary.nativeSize : undefined;
+  const width = Number(size?.[0]);
+  const height = Number(size?.[1]);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 1 || height <= 1) {
+    throw new AssistantPluginError('IOS_HID_DISPLAY_INVALID', 'CoreDevice returned invalid display dimensions for input coordinate mapping.', {
+      retryable: true,
+      details: { display: bounded(primary) },
+    });
+  }
+  return {
+    width: Math.trunc(width),
+    height: Math.trunc(height),
+    pointScale: typeof primary.pointScale === 'number' && Number.isFinite(primary.pointScale) ? primary.pointScale : undefined,
+  };
+}
+
+function pngDisplayGeometry(path: string, pointScale?: number): DisplayGeometry | undefined {
+  try {
+    const header = readFileSync(path).subarray(0, 24);
+    const signature = header.subarray(0, 8).toString('hex');
+    if (header.length < 24 || signature !== '89504e470d0a1a0a') return undefined;
+    const width = header.readUInt32BE(16);
+    const height = header.readUInt32BE(20);
+    if (width <= 1 || height <= 1) return undefined;
+    return { width, height, pointScale };
+  } catch {
+    return undefined;
+  }
+}
+
+async function sessionDisplayGeometry(
+  input: AssistantPluginActionExecutionInput,
+  state: PhysicalSessionState,
+): Promise<{ display: DisplayGeometry; cached: boolean }> {
+  const age = cacheAgeMs(state.display?.observedAt);
+  if (state.display && age !== undefined && age <= INPUT_DISPLAY_CACHE_MS) {
+    const { observedAt: _observedAt, ...display } = state.display;
+    return { display, cached: true };
+  }
+  const display = await physicalDisplayGeometry(input, state.device);
+  state.display = { ...display, observedAt: timestamp() };
+  writeState(input, state);
+  return { display, cached: false };
+}
+
+async function requireSessionUnlocked(
+  input: AssistantPluginActionExecutionInput,
+  state: PhysicalSessionState,
+): Promise<{ cached: boolean }> {
+  const age = cacheAgeMs(state.unlockVerifiedAt);
+  if (age !== undefined && age <= INPUT_UNLOCK_CACHE_MS) return { cached: true };
+  await requirePhysicalDeviceUnlocked(input, state.device);
+  state.unlockVerifiedAt = timestamp();
+  writeState(input, state);
+  return { cached: false };
+}
+
+async function physicalDeviceInfo(input: AssistantPluginActionExecutionInput, device: PhysicalDevice): Promise<Record<string, unknown>> {
+  const detailsResponse = await runCoreJson(input, [
+    'device', 'info', 'details', '--device', device.identifier,
+  ], 'IOS_DEVICE_DETAILS_FAILED', 60_000);
+  const details = objectValue(detailsResponse.result);
+  const deviceProperties = objectValue(details.deviceProperties);
+  const names = capabilityNames(details.capabilities);
+
+  const lockState = await physicalDeviceLockState(input, device);
+  const displayResponse = await runCoreJson(input, [
+    'device', 'info', 'displays', '--device', device.identifier,
+  ], 'IOS_DEVICE_DISPLAY_INFO_FAILED', 30_000);
+
+  return {
+    device,
+    capabilities: capabilitySummary(names),
+    capabilityCount: names.length,
+    screenViewingURL: stringField(deviceProperties, 'screenViewingURL'),
+    lockState: bounded(lockState),
+    displays: bounded(displayResponse.result),
+    inputBackend: remoteXpcHidStatus(input.controllerHome),
+  };
+}
+
+async function installedApps(
   input: AssistantPluginActionExecutionInput,
   device: PhysicalDevice,
   bundleId: string,
-): InstalledApp[] {
+): Promise<InstalledApp[]> {
   let response: Record<string, unknown>;
   try {
-    response = runCoreJson(input, [
+    response = await runCoreJson(input, [
       'device', 'info', 'apps', '--device', device.identifier,
       '--include-all-apps', '--bundle-id', bundleId,
     ], 'IOS_DEVICE_APPS_FAILED', 60_000);
@@ -394,110 +619,23 @@ function installedApps(
     .filter((entry) => entry.bundleIdentifier === bundleId);
 }
 
-function configuredRunner(): { configured: boolean; endpoint?: string; error?: string } {
-  const raw = process.env.FORGE_IOS_DEVICE_RUNNER_URL?.trim();
-  if (!raw) return { configured: false, error: 'Set FORGE_IOS_DEVICE_RUNNER_URL to a trusted localhost WDA-compatible endpoint.' };
-  try {
-    const parsed = new URL(raw);
-    if (parsed.protocol !== 'http:' || !LOCAL_RUNNER_HOSTS.has(parsed.hostname) || parsed.username || parsed.password) {
-      return { configured: false, error: 'The iOS UI runner URL must be an unauthenticated localhost HTTP endpoint.' };
-    }
-    parsed.pathname = parsed.pathname.replace(/\/$/, '');
-    parsed.search = '';
-    parsed.hash = '';
-    return { configured: true, endpoint: parsed.toString().replace(/\/$/, '') };
-  } catch {
-    return { configured: false, error: 'FORGE_IOS_DEVICE_RUNNER_URL is not a valid URL.' };
-  }
-}
-
-function runnerUrl(endpoint: string, path: string): string {
-  return `${endpoint}${path.startsWith('/') ? path : `/${path}`}`;
-}
-
-function responseValue(body: unknown): unknown {
-  const record = objectValue(body);
-  return 'value' in record ? record.value : body;
-}
-
-async function runnerRequest(
-  method: string,
-  endpoint: string,
-  path: string,
-  body: unknown,
-  code: string,
-  sensitive = false,
-): Promise<unknown> {
-  let response: RunnerHttpResult;
-  try {
-    response = await hooks.requestJson(method, runnerUrl(endpoint, path), body, 30_000);
-  } catch (error) {
-    const normalized = toAssistantPluginError(error, {
-      code,
-      message: 'The local iOS UI runner could not be reached.',
-      retryable: true,
-    });
-    throw new AssistantPluginError(normalized.code, normalized.message, {
-      retryable: normalized.retryable,
-      details: sensitive ? { endpoint, response: '<redacted>' } : { endpoint },
-    });
-  }
-  if (!response.ok) {
-    throw new AssistantPluginError(code, sensitive ? 'The local iOS UI runner rejected a sensitive-input action.' : `The local iOS UI runner returned HTTP ${response.status}.`, {
-      retryable: response.status >= 500,
-      details: sensitive ? { status: response.status, response: '<redacted>' } : { status: response.status, response: bounded(response.body ?? response.text) },
+function expirePhysicalDeviceSessions(input: AssistantPluginActionExecutionInput): number {
+  const nowMs = hooks.now().getTime();
+  let expired = 0;
+  for (const record of listInteractionSessions(input.repoRoot, PROVIDER)) {
+    if (!isInteractionSessionActive(record.status)) continue;
+    const expiresAtMs = Date.parse(record.expiresAt);
+    if (!Number.isFinite(expiresAtMs) || nowMs < expiresAtMs) continue;
+    const state = readState(input, record.interactionId);
+    patchInteractionSession(input.repoRoot, PROVIDER, record.interactionId, {
+      status: 'failed',
+      error: { code: 'IOS_DEVICE_SESSION_EXPIRED', message: 'The physical iOS interaction expired.' },
     });
+    appendEvent(input, record.interactionId, 'session_expired');
+    if (state?.device.identifier) stopRemoteXpcHidForDevice(state.device.identifier);
+    expired += 1;
   }
-  return responseValue(response.body);
-}
-
-async function probeRunner(): Promise<{ configured: boolean; endpoint?: string; ready: boolean; error?: string; status?: unknown }> {
-  const configured = configuredRunner();
-  if (!configured.configured || !configured.endpoint) return { ...configured, ready: false };
-  try {
-    const status = await runnerRequest('GET', configured.endpoint, '/status', undefined, 'IOS_DEVICE_UI_RUNNER_UNAVAILABLE');
-    const record = objectValue(status);
-    return {
-      configured: true,
-      endpoint: configured.endpoint,
-      ready: record.ready !== false,
-      status: bounded(status),
-    };
-  } catch (error) {
-    return {
-      configured: true,
-      endpoint: configured.endpoint,
-      ready: false,
-      error: toAssistantPluginError(error, {
-        code: 'IOS_DEVICE_UI_RUNNER_UNAVAILABLE',
-        message: 'The local iOS UI runner is unavailable.',
-        retryable: true,
-      }).message,
-    };
-  }
-}
-
-async function createRunnerSession(endpoint: string, bundleId: string): Promise<string> {
-  const value = await runnerRequest('POST', endpoint, '/session', {
-    capabilities: { alwaysMatch: { bundleId } },
-    desiredCapabilities: { bundleId },
-  }, 'IOS_DEVICE_UI_SESSION_FAILED');
-  const record = objectValue(value);
-  const sessionId = stringField(record, 'sessionId') ?? stringField(objectValue(objectValue(value).capabilities), 'sessionId');
-  if (!sessionId) {
-    throw new AssistantPluginError('IOS_DEVICE_UI_SESSION_FAILED', 'The UI runner did not return a WebDriver session id.', { retryable: false });
-  }
-  return sessionId;
-}
-
-async function closeRunner(state: PhysicalSessionState): Promise<boolean> {
-  if (!state.runner.endpoint || !state.runner.sessionId) return true;
-  try {
-    await runnerRequest('DELETE', state.runner.endpoint, `/session/${encodeURIComponent(state.runner.sessionId)}`, undefined, 'IOS_DEVICE_UI_CLOSE_FAILED');
-    return true;
-  } catch {
-    return false;
-  }
+  return expired;
 }
 
 function requireRecord(input: AssistantPluginActionExecutionInput, allowTerminal = false): { record: InteractionSessionRecord; state: PhysicalSessionState } {
@@ -511,10 +649,7 @@ function requireRecord(input: AssistantPluginActionExecutionInput, allowTerminal
     throw new AssistantPluginError(
       'PLUGIN_ACTION_ARGUMENT_INVALID',
       `Physical iOS interaction ${interactionId} belongs to ${engine ?? 'an unknown engine'}, not the CoreDevice engine.`,
-      {
-        retryable: false,
-        details: { interactionId, expectedEngine: 'coredevice', actualEngine: engine },
-      },
+      { retryable: false, details: { interactionId, expectedEngine: 'coredevice', actualEngine: engine } },
     );
   }
   const state = readState(input, interactionId);
@@ -523,8 +658,7 @@ function requireRecord(input: AssistantPluginActionExecutionInput, allowTerminal
   }
   if (!isInteractionSessionActive(record.status) && !allowTerminal) {
     throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `Physical iOS interaction is ${record.status}.`, {
-      retryable: false,
-      details: { interactionId, status: record.status },
+      retryable: false, details: { interactionId, status: record.status },
     });
   }
   if (isInteractionSessionActive(record.status) && hooks.now().getTime() >= Date.parse(record.expiresAt)) {
@@ -532,103 +666,343 @@ function requireRecord(input: AssistantPluginActionExecutionInput, allowTerminal
       status: 'failed',
       error: { code: 'IOS_DEVICE_SESSION_EXPIRED', message: 'The physical iOS interaction expired.' },
     });
+    appendEvent(input, interactionId, 'session_expired');
+    stopRemoteXpcHidForDevice(state.device.identifier);
     throw new AssistantPluginError('IOS_DEVICE_SESSION_EXPIRED', 'The physical iOS interaction expired; open a new session.', { retryable: false });
   }
   return { record, state };
 }
 
-function requireRunner(state: PhysicalSessionState): { endpoint: string; sessionId: string } {
-  if (!state.runner.ready || !state.runner.endpoint || !state.runner.sessionId) {
-    throw new AssistantPluginError('IOS_DEVICE_UI_RUNNER_UNAVAILABLE', state.runner.error ?? 'No signed WDA-compatible UI runner is attached to this physical-device session.', {
-      retryable: true,
-      details: {
-        configured: state.runner.configured,
-        prerequisites: [
-          'Enable Developer Mode and trust/pair the iPhone with Xcode.',
-          'Build and run a correctly signed WebDriverAgent-compatible runner for this device.',
-          'Forward its HTTP endpoint to localhost and set FORGE_IOS_DEVICE_RUNNER_URL.',
-        ],
-      },
-    });
+function physicalDeviceStatusFromResult(result: CommandResult, platform: NodeJS.Platform): CoreDeviceStatus {
+  return {
+    available: result.ok,
+    platform,
+    coreDeviceReady: result.ok,
+    devicectlVersion: result.ok ? result.stdout.trim() : undefined,
+    reason: result.ok ? undefined : (result.stderr || result.stdout || 'xcrun devicectl is unavailable.'),
+    probed: true,
+  };
+}
+
+export function iosPhysicalDeviceStatus(): CoreDeviceStatus {
+  const platform = hooks.platform();
+  if (platform !== 'darwin') {
+    coreDeviceReadyCache = undefined;
+    return {
+      available: false,
+      platform,
+      coreDeviceReady: false,
+      reason: 'Physical iOS device support requires macOS and Xcode.',
+      probed: true,
+    };
+  }
+  const cached = coreDeviceReadyCache;
+  if (cached && hooks.now().getTime() - cached.checkedAtMs <= CORE_DEVICE_READY_CACHE_MS) return cached.status;
+  return {
+    available: false,
+    platform,
+    coreDeviceReady: false,
+    reason: 'CoreDevice readiness has not been probed by an explicit asynchronous action in this runtime yet.',
+    probed: false,
+  };
+}
+
+async function iosPhysicalDeviceActionStatus(input: AssistantPluginActionExecutionInput): Promise<CoreDeviceStatus> {
+  const platform = hooks.platform();
+  if (platform !== 'darwin') return iosPhysicalDeviceStatus();
+  const result = await hooks.runCommandAsync('xcrun', ['devicectl', '--version'], {
+    cwd: input.repoRoot,
+    timeoutMs: Math.min(5_000, input.timeoutMs ?? 5_000),
+    signal: input.signal,
+  });
+  const status = physicalDeviceStatusFromResult(result, platform);
+  coreDeviceReadyCache = status.coreDeviceReady ? { checkedAtMs: hooks.now().getTime(), status } : undefined;
+  return status;
+}
+
+async function cachedIosPhysicalDeviceActionStatus(input: AssistantPluginActionExecutionInput): Promise<{ status: CoreDeviceStatus; cached: boolean }> {
+  const cached = coreDeviceReadyCache;
+  if (cached && hooks.now().getTime() - cached.checkedAtMs <= CORE_DEVICE_READY_CACHE_MS) {
+    return { status: cached.status, cached: true };
   }
-  return { endpoint: state.runner.endpoint, sessionId: state.runner.sessionId };
+  return { status: await iosPhysicalDeviceActionStatus(input), cached: false };
 }
 
-function rejectSensitiveSemantic(value: string, action: string): void {
-  if (SENSITIVE_SEMANTICS.test(value)) {
-    throw new AssistantPluginError('IOS_DEVICE_HUMAN_ACTION_REQUIRED', `${action} targets a credential, verification, biometric, purchase, checkout, or payment flow and must be completed manually.`, {
-      retryable: false,
-      details: { humanHandoffRequired: true },
-    });
+function recentScreenshotObservation(
+  state: PhysicalSessionState,
+  observationId: string,
+): { observation: PhysicalScreenshotObservation; ageMs: number } {
+  const observation = state.lastScreenshot;
+  const ageMs = cacheAgeMs(observation?.observedAt);
+  if (!observation || observation.observationId !== observationId || ageMs === undefined || ageMs > INPUT_FOREGROUND_OBSERVATION_TTL_MS) {
+    throw new AssistantPluginError(
+      'IOS_DEVICE_SCREEN_OBSERVATION_REQUIRED',
+      'A fresh matching CoreDevice screenshot observation is required before screen-relative physical input.',
+      {
+        retryable: true,
+        details: {
+          deviceIdentifier: state.device.identifier,
+          expectedObservationId: observation?.observationId,
+          providedObservationId: observationId,
+          observationAgeMs: ageMs,
+          observationTtlMs: INPUT_FOREGROUND_OBSERVATION_TTL_MS,
+          hidMutationDispatched: false,
+        },
+      },
+    );
   }
+  return { observation, ageMs };
 }
 
-function locator(target: string): { using: string; value: string } {
-  if (target.startsWith('xpath:')) return { using: 'xpath', value: target.slice(6) };
-  if (target.startsWith('id:')) return { using: 'accessibility id', value: target.slice(3) };
-  return { using: 'accessibility id', value: target };
-}
-
-async function elementId(endpoint: string, sessionId: string, target: string): Promise<string> {
-  const value = await runnerRequest('POST', endpoint, `/session/${encodeURIComponent(sessionId)}/element`, locator(target), 'IOS_DEVICE_ELEMENT_NOT_FOUND');
-  const record = objectValue(value);
-  const id = stringField(record, 'element-6066-11e4-a52e-4f735466cecf') ?? stringField(record, 'ELEMENT');
-  if (!id) throw new AssistantPluginError('IOS_DEVICE_ELEMENT_NOT_FOUND', 'The UI runner did not return an element id.', { retryable: false });
-  return id;
-}
-
-async function inspectElementSemantics(
-  endpoint: string,
-  sessionId: string,
-  elementIdValue: string,
-  target: string,
-  action: string,
-): Promise<void> {
-  const attributes = ['type', 'name', 'label', 'placeholderValue'];
-  const values: string[] = [target];
-  for (const attribute of attributes) {
-    const value = await runnerRequest(
-      'GET',
-      endpoint,
-      `/session/${encodeURIComponent(sessionId)}/element/${encodeURIComponent(elementIdValue)}/attribute/${encodeURIComponent(attribute)}`,
-      undefined,
-      'IOS_DEVICE_ELEMENT_INSPECTION_FAILED',
+function requireObservedPhysicalTargetForeground(state: PhysicalSessionState): PhysicalForegroundObservation {
+  const confirmation = state.foregroundObservation;
+  const screenshot = state.lastScreenshot;
+  const screenshotAgeMs = cacheAgeMs(screenshot?.observedAt);
+  const confirmationAgeMs = cacheAgeMs(confirmation?.confirmedAt);
+  const valid = Boolean(
+    confirmation
+      && screenshot
+      && confirmation.bundleId === state.bundleId
+      && confirmation.observationId === screenshot.observationId
+      && confirmation.screenshotObservedAt === screenshot.observedAt
+      && screenshotAgeMs !== undefined
+      && screenshotAgeMs <= INPUT_FOREGROUND_OBSERVATION_TTL_MS
+      && confirmationAgeMs !== undefined
+      && confirmationAgeMs <= INPUT_FOREGROUND_OBSERVATION_TTL_MS
+  );
+  if (!valid || !confirmation) {
+    throw new AssistantPluginError(
+      'IOS_DEVICE_FOREGROUND_OBSERVATION_REQUIRED',
+      `A recent screenshot explicitly confirmed by the Controller as ${state.bundleId} foreground is required before HID input.`,
+      {
+        retryable: true,
+        details: {
+          bundleId: state.bundleId,
+          deviceIdentifier: state.device.identifier,
+          screenshotObservationId: screenshot?.observationId,
+          screenshotAgeMs,
+          confirmationObservationId: confirmation?.observationId,
+          confirmationAgeMs,
+          observationTtlMs: INPUT_FOREGROUND_OBSERVATION_TTL_MS,
+          hidMutationDispatched: false,
+        },
+      },
     );
-    if (typeof value === 'string') values.push(value);
   }
-  rejectSensitiveSemantic(values.join(' '), action);
+  return confirmation;
 }
 
-export function iosPhysicalDeviceStatus() {
-  if (hooks.platform() !== 'darwin') {
+function resolvePhysicalBatchForegroundObservation(
+  state: PhysicalSessionState,
+  observationId: string | undefined,
+): { foregroundObservation: PhysicalForegroundObservation; source: 'atomic_screenshot' | 'explicit_confirmation'; screenshotAgeMs?: number } {
+  if (observationId) {
+    const { observation, ageMs } = recentScreenshotObservation(state, observationId);
     return {
-      available: false,
-      platform: hooks.platform(),
-      coreDeviceReady: false,
-      uiRunner: { ...configuredRunner(), ready: false },
-      reason: 'Physical iOS device support requires macOS and Xcode.',
+      foregroundObservation: {
+        observationId: observation.observationId,
+        screenshotObservedAt: observation.observedAt,
+        confirmedAt: timestamp(),
+        bundleId: state.bundleId,
+      },
+      source: 'atomic_screenshot',
+      screenshotAgeMs: ageMs,
     };
   }
-  const result = hooks.runCommand('xcrun', ['devicectl', '--version'], { timeoutMs: 5_000 });
   return {
-    available: result.ok,
-    platform: hooks.platform(),
-    coreDeviceReady: result.ok,
-    devicectlVersion: result.ok ? result.stdout.trim() : undefined,
-    uiRunner: { ...configuredRunner(), ready: false, readinessCheckedOnAction: true },
-    reason: result.ok ? undefined : (result.stderr || result.stdout || 'xcrun devicectl is unavailable.'),
+    foregroundObservation: requireObservedPhysicalTargetForeground(state),
+    source: 'explicit_confirmation',
   };
 }
 
+function consumePhysicalScreenObservation(input: AssistantPluginActionExecutionInput, state: PhysicalSessionState): void {
+  state.lastScreenshot = undefined;
+  state.foregroundObservation = undefined;
+  writeState(input, state);
+}
+
+type PhysicalInputBatchKind = 'tap' | 'swipe' | 'type' | 'wait';
+
+interface PhysicalInputBatchStep {
+  kind: PhysicalInputBatchKind;
+  x?: number;
+  y?: number;
+  toX?: number;
+  toY?: number;
+  durationMs?: number;
+  text?: string;
+  textMode?: 'auto' | 'keys' | 'pasteboard';
+  replaceExisting?: boolean;
+}
+
+function physicalInputBatchSteps(value: unknown): PhysicalInputBatchStep[] {
+  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_BATCH_STEPS) {
+    throw new AssistantPluginError(
+      'PLUGIN_ACTION_ARGUMENT_INVALID',
+      `steps must contain between 1 and ${MAX_BATCH_STEPS} physical input steps.`,
+      { retryable: false },
+    );
+  }
+  return value.map((entry, index) => {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `steps[${index}] must be an object.`, { retryable: false });
+    }
+    const row = entry as Record<string, unknown>;
+    const kind = requireString(row.kind, `steps[${index}].kind`) as PhysicalInputBatchKind;
+    if (!['tap', 'swipe', 'type', 'wait'].includes(kind)) {
+      throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `Unsupported steps[${index}].kind: ${kind}.`, { retryable: false });
+    }
+    if (kind === 'tap') {
+      return {
+        kind,
+        x: requireFiniteNumber(row.x, `steps[${index}].x`),
+        y: requireFiniteNumber(row.y, `steps[${index}].y`),
+      };
+    }
+    if (kind === 'swipe') {
+      const durationMs = typeof row.duration_ms === 'number' && Number.isFinite(row.duration_ms)
+        ? Math.max(80, Math.min(3_000, Math.trunc(row.duration_ms)))
+        : 250;
+      return {
+        kind,
+        x: requireFiniteNumber(row.x, `steps[${index}].x`),
+        y: requireFiniteNumber(row.y, `steps[${index}].y`),
+        toX: requireFiniteNumber(row.to_x, `steps[${index}].to_x`),
+        toY: requireFiniteNumber(row.to_y, `steps[${index}].to_y`),
+        durationMs,
+      };
+    }
+    if (kind === 'type') {
+      const textMode = optionalString(row.input_mode) ?? 'auto';
+      if (!['auto', 'keys', 'pasteboard'].includes(textMode)) {
+        throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `Unsupported steps[${index}].input_mode: ${textMode}.`, { retryable: false });
+      }
+      const text = requireString(row.text, `steps[${index}].text`);
+      if (text.length > 2048) {
+        throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `steps[${index}].text exceeds the 2048 character input limit.`, { retryable: false });
+      }
+      if (textMode === 'keys' && [...text].some((character) => character.charCodeAt(0) > 0x7f)) {
+        throw new AssistantPluginError('IOS_HID_UNICODE_TEXT_UNSUPPORTED', `steps[${index}] requests keys mode for Unicode text; use auto or pasteboard mode.`, { retryable: false });
+      }
+      return {
+        kind,
+        text,
+        textMode: textMode as 'auto' | 'keys' | 'pasteboard',
+        replaceExisting: row.replace_existing === true,
+      };
+    }
+    const durationMs = typeof row.duration_ms === 'number' && Number.isFinite(row.duration_ms)
+      ? Math.max(0, Math.min(MAX_BATCH_WAIT_MS, Math.trunc(row.duration_ms)))
+      : 120;
+    return { kind, durationMs };
+  });
+}
+
+function validatePhysicalInputBatchCoordinates(steps: PhysicalInputBatchStep[], display: DisplayGeometry | undefined): void {
+  const touchSteps = steps.filter((step) => step.kind === 'tap' || step.kind === 'swipe');
+  if (touchSteps.length === 0) return;
+  if (!display) {
+    throw new AssistantPluginError('IOS_HID_DISPLAY_INVALID', 'Physical input batch contains touch steps without usable display geometry.', { retryable: true });
+  }
+  const points: Array<{ stepIndex: number; label: string; x: number | undefined; y: number | undefined }> = [];
+  steps.forEach((step, stepIndex) => {
+    if (step.kind === 'tap' || step.kind === 'swipe') points.push({ stepIndex, label: 'from', x: step.x, y: step.y });
+    if (step.kind === 'swipe') points.push({ stepIndex, label: 'to', x: step.toX, y: step.toY });
+  });
+  for (const point of points) {
+    if (point.x === undefined || point.y === undefined || point.x < 0 || point.y < 0 || point.x > display.width - 1 || point.y > display.height - 1) {
+      throw new AssistantPluginError(
+        'IOS_HID_COORDINATE_OUT_OF_BOUNDS',
+        `steps[${point.stepIndex}] ${point.label} coordinate is outside the current CoreDevice display.`,
+        { retryable: false, details: { stepIndex: point.stepIndex, label: point.label, x: point.x, y: point.y, width: display.width, height: display.height, mutationDispatched: false } },
+      );
+    }
+  }
+}
+
+async function waitPhysicalInputBatch(durationMs: number, signal?: AbortSignal): Promise<void> {
+  if (durationMs <= 0) return;
+  await new Promise<void>((resolve, reject) => {
+    let settled = false;
+    let timer: NodeJS.Timeout | undefined;
+    const finish = (error?: Error) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener('abort', abort);
+      if (error) reject(error);
+      else resolve();
+    };
+    const abort = () => finish(new AssistantPluginError('PLUGIN_ACTION_CANCELLED', 'Physical iOS input batch was cancelled during a wait step.', { retryable: true }));
+    timer = setTimeout(() => finish(), durationMs);
+    if (signal?.aborted) abort();
+    else signal?.addEventListener('abort', abort, { once: true });
+  });
+}
+
 export function isIosPhysicalDeviceAction(actionId: string): boolean {
   return actionId.startsWith('physical_device_');
 }
 
+function physicalDeviceAuthorizationTarget(device: PhysicalDevice): AssistantPluginAuthorizationTarget {
+  const identityFingerprint = createHash('sha256')
+    .update(`${device.identifier}\0${device.udid ?? ''}`)
+    .digest('hex');
+  return {
+    kind: 'ios-physical-device',
+    id: device.identifier,
+    identityFingerprint,
+  };
+}
+
+/**
+ * Resolve authorization against the exact CoreDevice identity. Interaction ids are
+ * intentionally never grant identities: follow-up input actions must recover and
+ * verify the immutable device target stored when the session was opened.
+ */
+export async function resolveIosPhysicalDeviceAuthorizationContext(
+  input: AssistantPluginActionExecutionInput,
+): Promise<AssistantPluginAuthorizationContext | undefined> {
+  const action = iosPhysicalDeviceActions().find((entry) => entry.actionId === input.actionId);
+  if (!action || action.confirmation !== 'authorization') return undefined;
+
+  if (input.actionId === 'physical_device_open') {
+    const selected = await selectDevice(input, input.args.device);
+    return {
+      target: physicalDeviceAuthorizationTarget(selected),
+      expiresInMinutes: 30 * 24 * 60,
+    };
+  }
+
+  const { record, state } = requireRecord(input, input.actionId === 'physical_device_close');
+  const aliases = new Set([record.targetId, ...(record.targetAliases ?? [])]);
+  if (record.targetId !== state.device.identifier
+    || !aliases.has(state.device.identifier)
+    || (state.device.udid && !aliases.has(state.device.udid))) {
+    throw new AssistantPluginError(
+      'IOS_DEVICE_AUTHORIZATION_TARGET_MISMATCH',
+      'The persisted physical iOS session no longer matches its exact device authorization identity.',
+      {
+        retryable: false,
+        details: {
+          interactionId: record.interactionId,
+          sessionTargetId: record.targetId,
+          stateDeviceIdentifier: state.device.identifier,
+        },
+      },
+    );
+  }
+  return {
+    target: physicalDeviceAuthorizationTarget(state.device),
+    expiresInMinutes: 30 * 24 * 60,
+  };
+}
+
 export function iosPhysicalDeviceCapabilities(): AssistantPluginCapability[] {
   return [{
     capabilityId: 'ios-physical-device',
     title: 'Physical iOS Computer Use',
-    description: 'Bounded CoreDevice discovery, installed-app launch and screenshot, with optional signed localhost WDA-compatible UI automation.',
+    description: 'CoreDevice lifecycle/observation plus runnerless RemoteXPC HID input for physical iPhones. XCTest remains only an explicit semantic fallback.',
     scopes: ['ios.discover', 'ios.device'],
     actions: iosPhysicalDeviceActions().map((action) => action.actionId),
   }];
@@ -641,10 +1015,10 @@ export function iosPhysicalDeviceActions(): AssistantPluginActionDescriptor[] {
     { resource: 'repo-state' as const, mode: 'write' as const },
   ];
   const interactionProperty = { interaction_id: { type: 'string' } };
-  return [
+  const actions: AssistantPluginActionDescriptor[] = [
     {
       actionId: 'physical_device_status', title: 'Physical iOS device status',
-      description: 'Report CoreDevice readiness and probe an explicitly configured localhost UI runner.',
+      description: 'Report CoreDevice readiness. This provider has no XCTest/WDA Runner lifecycle.',
       readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 30_000, cancellable: true, idempotent: true,
       scopes: ['ios.discover'], resourceClaims: [], argumentsSchema: { type: 'object', properties: {}, additionalProperties: false },
     },
@@ -654,6 +1028,13 @@ export function iosPhysicalDeviceActions(): AssistantPluginActionDescriptor[] {
       readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 30_000, cancellable: true, idempotent: true,
       scopes: ['ios.discover'], resourceClaims: [], argumentsSchema: { type: 'object', properties: {}, additionalProperties: false },
     },
+    {
+      actionId: 'physical_device_info', title: 'Inspect physical iPhone capabilities',
+      description: 'Read CoreDevice details, lock state, display metadata, View Device Screen URL, and HID capability availability without starting a Runner.',
+      readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 90_000, cancellable: true, idempotent: true,
+      scopes: ['ios.device'], resourceClaims: [],
+      argumentsSchema: { type: 'object', properties: { device: { type: 'string' } }, required: ['device'], additionalProperties: false },
+    },
     {
       actionId: 'physical_device_apps', title: 'Find installed physical-device app',
       description: 'Verify one exact bundle identifier is installed on an exact paired iPhone without reading its data container.',
@@ -663,45 +1044,107 @@ export function iosPhysicalDeviceActions(): AssistantPluginActionDescriptor[] {
     },
     {
       actionId: 'physical_device_open', title: 'Open physical iOS app session',
-      description: 'Launch one installed third-party app on an exact paired iPhone and create a bounded interaction session. URLs and deep links are rejected.',
+      description: 'Request activation of one installed third-party app through CoreDevice and create a bounded interaction session. CoreDevice launch metadata is diagnostic only: capture a screenshot and explicitly confirm the observed foreground before any HID input. Set prewarm_input=true when runnerless input will follow; Forge then waits up to 4 seconds for a non-mutating RemoteXPC readiness result so the first HID action does not need a blind retry.',
       readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 2 * 60_000, cancellable: true, idempotent: false,
       scopes: ['ios.device'], resourceClaims: mutationClaims,
-      argumentsSchema: { type: 'object', properties: { device: { type: 'string' }, bundle_id: { type: 'string' }, relaunch: { type: 'boolean' } }, required: ['device', 'bundle_id'], additionalProperties: false },
+      argumentsSchema: { type: 'object', properties: { device: { type: 'string' }, bundle_id: { type: 'string' }, relaunch: { type: 'boolean' }, prewarm_input: { type: 'boolean' } }, required: ['device', 'bundle_id'], additionalProperties: false },
     },
     {
-      actionId: 'physical_device_snapshot', title: 'Snapshot physical iOS UI',
-      description: 'Read bounded UI source through the signed localhost runner. Fails closed when the runner is unavailable.',
-      readOnly: true, risk: 'readonly', confirmation: 'none', defaultTimeoutMs: 60_000, cancellable: true, idempotent: true,
+      actionId: 'physical_device_screenshot', title: 'Capture physical iOS screenshot',
+      description: 'Capture the exact paired iPhone display through CoreDevice into Controller-owned bounded artifact storage and return a short-lived observation ID. A screenshot alone never authorizes input.',
+      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 60_000, cancellable: true, idempotent: false,
+      scopes: ['ios.device'], resourceClaims: mutationClaims,
+      argumentsSchema: { type: 'object', properties: { ...interactionProperty, label: { type: 'string' } }, required: ['interaction_id'], additionalProperties: false },
+    },
+    {
+      actionId: 'physical_device_confirm_foreground', title: 'Confirm observed physical iPhone foreground',
+      description: 'Bind the latest fresh CoreDevice screenshot observation to the session target bundle after the Controller has visually verified that exact app is foreground. This only writes the short-lived observation fence and sends no device input.',
+      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: true,
       scopes: ['ios.device'], resourceClaims: stateClaim,
-      argumentsSchema: { type: 'object', properties: { ...interactionProperty }, required: ['interaction_id'], additionalProperties: false },
+      argumentsSchema: {
+        type: 'object',
+        properties: { ...interactionProperty, observation_id: { type: 'string' }, bundle_id: { type: 'string' } },
+        required: ['interaction_id', 'observation_id', 'bundle_id'], additionalProperties: false,
+      },
     },
     {
-      actionId: 'physical_device_press', title: 'Press physical iOS target',
-      description: 'Press a non-sensitive accessibility target or coordinate through the signed runner. Purchase, payment, biometric and credential semantics are blocked.',
-      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 60_000, cancellable: true, idempotent: false,
+      actionId: 'physical_device_observed_tap', title: 'Tap a freshly observed physical iPhone screen',
+      description: 'One-shot screen-relative tap bound to the latest fresh screenshot observation. It does not reactivate any app and consumes the observation before dispatch, so it can safely navigate system UI such as Spotlight into the target app when CoreDevice activation did not actually foreground it.',
+      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: false,
       scopes: ['ios.device'], resourceClaims: mutationClaims,
-      argumentsSchema: { type: 'object', properties: { ...interactionProperty, target: { type: 'string' }, x: { type: 'number' }, y: { type: 'number' }, purpose: { type: 'string' } }, required: ['interaction_id'], additionalProperties: false },
+      argumentsSchema: {
+        type: 'object',
+        properties: { ...interactionProperty, observation_id: { type: 'string' }, x: { type: 'number', minimum: 0 }, y: { type: 'number', minimum: 0 } },
+        required: ['interaction_id', 'observation_id', 'x', 'y'], additionalProperties: false,
+      },
     },
     {
-      actionId: 'physical_device_fill', title: 'Fill physical iOS target',
-      description: 'Replace non-sensitive text through the signed runner. Text is redacted and passwords, codes, biometrics, checkout and payment targets are blocked.',
+      actionId: 'physical_device_batch', title: 'Run fast physical iPhone input batch',
+      description: 'Preferred fast path for a visually confirmed target app: perform up to 20 tap, swipe, text, or bounded-wait steps under one fresh screenshot foreground fence, one unlock/display readiness pass, and one plugin round-trip. Pass observation_id to atomically bind and consume the latest visually verified screenshot without a separate confirm_foreground round-trip; omitting it preserves the explicit confirm_foreground compatibility path. Stops on the first failed step and never replays a partially-mutated batch.',
       readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 60_000, cancellable: true, idempotent: false,
       scopes: ['ios.device'], resourceClaims: mutationClaims,
-      argumentsSchema: { type: 'object', properties: { ...interactionProperty, target: { type: 'string' }, text: { type: 'string' } }, required: ['interaction_id', 'target', 'text'], additionalProperties: false },
+      argumentsSchema: {
+        type: 'object',
+        properties: {
+          ...interactionProperty,
+          observation_id: { type: 'string' },
+          steps: {
+            type: 'array', minItems: 1, maxItems: MAX_BATCH_STEPS,
+            items: {
+              type: 'object',
+              properties: {
+                kind: { type: 'string', enum: ['tap', 'swipe', 'type', 'wait'] },
+                x: { type: 'number', minimum: 0 }, y: { type: 'number', minimum: 0 },
+                to_x: { type: 'number', minimum: 0 }, to_y: { type: 'number', minimum: 0 },
+                duration_ms: { type: 'number', minimum: 0, maximum: MAX_BATCH_WAIT_MS },
+                text: { type: 'string', maxLength: 2048 },
+                input_mode: { type: 'string', enum: ['auto', 'keys', 'pasteboard'] },
+                replace_existing: { type: 'boolean' },
+              },
+              required: ['kind'], additionalProperties: false,
+            },
+          },
+        },
+        required: ['interaction_id', 'steps'], additionalProperties: false,
+      },
     },
     {
-      actionId: 'physical_device_scroll', title: 'Scroll physical iOS session',
-      description: 'Scroll an active physical-device UI session through the signed runner.',
-      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 60_000, cancellable: true, idempotent: false,
+      actionId: 'physical_device_tap', title: 'Tap physical iPhone coordinate',
+      description: 'Send one runnerless touch through RemoteXPC only while a fresh screenshot observation has been explicitly confirmed as the target app foreground. The observation is consumed before dispatch. For system-screen navigation use physical_device_observed_tap; for known form steps prefer physical_device_batch.',
+      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: false,
       scopes: ['ios.device'], resourceClaims: mutationClaims,
-      argumentsSchema: { type: 'object', properties: { ...interactionProperty, direction: { type: 'string', enum: ['up', 'down', 'left', 'right', 'top', 'bottom'] }, amount: { type: 'number' } }, required: ['interaction_id', 'direction'], additionalProperties: false },
+      argumentsSchema: {
+        type: 'object',
+        properties: { ...interactionProperty, x: { type: 'number', minimum: 0 }, y: { type: 'number', minimum: 0 } },
+        required: ['interaction_id', 'x', 'y'], additionalProperties: false,
+      },
     },
     {
-      actionId: 'physical_device_screenshot', title: 'Capture physical iOS screenshot',
-      description: 'Capture the exact paired iPhone display through CoreDevice into Controller-owned bounded artifact storage.',
-      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 60_000, cancellable: true, idempotent: false,
+      actionId: 'physical_device_swipe', title: 'Swipe physical iPhone',
+      description: 'Send one runnerless touchscreen swipe through RemoteXPC HID only while a fresh screenshot observation has been explicitly confirmed as the target app foreground; the observation is consumed before dispatch.',
+      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: false,
       scopes: ['ios.device'], resourceClaims: mutationClaims,
-      argumentsSchema: { type: 'object', properties: { ...interactionProperty, label: { type: 'string' } }, required: ['interaction_id'], additionalProperties: false },
+      argumentsSchema: {
+        type: 'object',
+        properties: {
+          ...interactionProperty,
+          x: { type: 'number', minimum: 0 }, y: { type: 'number', minimum: 0 },
+          to_x: { type: 'number', minimum: 0 }, to_y: { type: 'number', minimum: 0 },
+          duration_ms: { type: 'number', minimum: 80, maximum: 3000 },
+        },
+        required: ['interaction_id', 'x', 'y', 'to_x', 'to_y'], additionalProperties: false,
+      },
+    },
+    {
+      actionId: 'physical_device_type_text', title: 'Type physical iPhone text',
+      description: 'Type bounded text through reusable runnerless RemoteXPC input only while a fresh screenshot observation has been explicitly confirmed as the target app foreground. Auto mode uses direct HID keys for short ASCII and clipboard-preserving CoreDevice pasteboard + Command-V for Unicode; the observation is consumed before dispatch.',
+      readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 30_000, cancellable: true, idempotent: false,
+      scopes: ['ios.device'], resourceClaims: mutationClaims,
+      argumentsSchema: {
+        type: 'object',
+        properties: { ...interactionProperty, text: { type: 'string', maxLength: 2048 }, input_mode: { type: 'string', enum: ['auto', 'keys', 'pasteboard'] }, replace_existing: { type: 'boolean' } },
+        required: ['interaction_id', 'text'], additionalProperties: false,
+      },
     },
     {
       actionId: 'physical_device_events', title: 'Read physical iOS events',
@@ -712,40 +1155,68 @@ export function iosPhysicalDeviceActions(): AssistantPluginActionDescriptor[] {
     },
     {
       actionId: 'physical_device_close', title: 'Close physical iOS session',
-      description: 'Close the optional UI-runner session and release Controller ownership without shutting down or modifying the iPhone.',
+      description: 'Release Controller ownership without shutting down or modifying the iPhone. No XCTest/WDA Runner is owned by this provider.',
       readOnly: false, risk: 'workspace_write', confirmation: 'authorization', defaultTimeoutMs: 60_000, cancellable: true, idempotent: true,
       scopes: ['ios.device'], resourceClaims: mutationClaims,
       argumentsSchema: { type: 'object', properties: { ...interactionProperty }, required: ['interaction_id'], additionalProperties: false },
     },
   ];
+  return actions.map((action) => action.readOnly || action.actionId === 'physical_device_confirm_foreground'
+    ? action
+    : { ...action, executionMode: 'lightweight_process' });
 }
 
 export async function executeIosPhysicalDeviceAction(input: AssistantPluginActionExecutionInput): Promise<Record<string, unknown>> {
+  const actionStartedAt = performance.now();
+  const timingStages: TimingStages = {};
   if (input.actionId === 'physical_device_status') {
-    return { provider: 'coredevice', ...iosPhysicalDeviceStatus(), uiRunner: await probeRunner() };
+    const startedAt = performance.now();
+    const status = await iosPhysicalDeviceActionStatus(input);
+    recordTiming(timingStages, 'coreDeviceStatus', startedAt, false);
+    return finishTimedResult(actionStartedAt, timingStages, { provider: 'coredevice', ...status });
   }
-  const status = iosPhysicalDeviceStatus();
+  const statusStartedAt = performance.now();
+  const readiness = await cachedIosPhysicalDeviceActionStatus(input);
+  recordTiming(timingStages, 'coreDeviceStatus', statusStartedAt, readiness.cached);
+  const status = readiness.status;
   if (!status.coreDeviceReady) {
-    throw new AssistantPluginError('PLUGIN_DEPENDENCY_MISSING', status.reason ?? 'Xcode CoreDevice is unavailable.', { retryable: false, details: status });
+    throw new AssistantPluginError('PLUGIN_DEPENDENCY_MISSING', status.reason ?? 'Xcode CoreDevice is unavailable.', { retryable: false, details: { ...status } });
   }
   if (input.actionId === 'physical_device_list') {
-    return { provider: 'coredevice', devices: physicalDevices(input) };
+    return { provider: 'coredevice', devices: await physicalDevices(input) };
+  }
+  if (input.actionId === 'physical_device_info') {
+    const selected = await selectDevice(input, input.args.device);
+    return { provider: 'coredevice', ...await physicalDeviceInfo(input, selected) };
   }
   if (input.actionId === 'physical_device_apps') {
-    const selected = selectDevice(input, input.args.device);
+    const selected = await selectDevice(input, input.args.device);
     const bundleId = requireBundleId(input.args.bundle_id);
-    return { provider: 'coredevice', device: selected, apps: installedApps(input, selected, bundleId) };
+    return { provider: 'coredevice', device: selected, apps: await installedApps(input, selected, bundleId) };
   }
   if (input.actionId === 'physical_device_open') {
-    const selected = selectDevice(input, input.args.device);
+    const selectStartedAt = performance.now();
+    const selected = await selectDevice(input, input.args.device);
+    recordTiming(timingStages, 'deviceSelection', selectStartedAt, false);
     const bundleId = requireBundleId(input.args.bundle_id);
-    const apps = installedApps(input, selected, bundleId);
+    const appsStartedAt = performance.now();
+    const lockStartedAt = performance.now();
+    const appsPromise = installedApps(input, selected, bundleId)
+      .finally(() => recordTiming(timingStages, 'installedAppLookup', appsStartedAt, false));
+    const lockPromise = requirePhysicalDeviceUnlocked(input, selected)
+      .finally(() => recordTiming(timingStages, 'lockState', lockStartedAt, false));
+    const [apps] = await Promise.all([appsPromise, lockPromise]);
     if (apps.length !== 1) {
       throw new AssistantPluginError('IOS_DEVICE_APP_NOT_INSTALLED', `The app ${bundleId} is not installed on the selected iPhone.`, { retryable: false });
     }
     const selectedAliases = [selected.identifier, selected.udid];
+    const sessionLookupStartedAt = performance.now();
+    const expiredSessionCount = expirePhysicalDeviceSessions(input);
+    pruneInteractionSessions(input.repoRoot, PROVIDER, 100);
     const conflict = listInteractionSessions(input.repoRoot, PROVIDER).find((entry) =>
       isInteractionSessionActive(entry.status) && interactionMayOwnTarget(entry, selectedAliases));
+    recordTiming(timingStages, 'sessionLookup', sessionLookupStartedAt, false);
+    if (expiredSessionCount > 0) timingStages.sessionReconcile = { ms: timingStages.sessionLookup.ms, cached: false };
     if (conflict) {
       throw new AssistantPluginError('PLUGIN_RESOURCE_BUSY', 'The selected iPhone already has an active forge interaction.', {
         retryable: true,
@@ -757,7 +1228,6 @@ export async function executeIosPhysicalDeviceAction(input: AssistantPluginActio
         },
       });
     }
-    pruneInteractionSessions(input.repoRoot, PROVIDER, 100);
     const interactionId = `ios_device_${randomUUID()}`;
     const createdAt = timestamp();
     const record: InteractionSessionRecord = {
@@ -777,55 +1247,93 @@ export async function executeIosPhysicalDeviceAction(input: AssistantPluginActio
       expiresAt: new Date(hooks.now().getTime() + SESSION_EXPIRY_MS).toISOString(),
     };
     writeInteractionSession(input.repoRoot, record);
-    const runnerProbe = await probeRunner();
     const state: PhysicalSessionState = {
       schemaVersion: 1,
       interactionId,
       device: selected,
       bundleId,
-      runner: {
-        configured: runnerProbe.configured,
-        endpoint: runnerProbe.endpoint,
-        ready: false,
-        error: runnerProbe.error,
-      },
+      unlockVerifiedAt: createdAt,
       events: [{ at: createdAt, type: 'session_created', details: { bundleId, deviceIdentifier: selected.identifier } }],
     };
+    const statePersistStartedAt = performance.now();
     writeState(input, state);
+    recordTiming(timingStages, 'eventPersistence', statePersistStartedAt, false);
     try {
-      const args = ['device', 'process', 'launch', '--device', selected.identifier];
+      const args = ['device', 'process', 'launch', '--device', selected.identifier, '--activate'];
       if (input.args.relaunch === true) args.push('--terminate-existing');
       args.push(bundleId);
-      const launch = runCoreJson(input, args, 'IOS_DEVICE_LAUNCH_FAILED', 60_000);
+      const prewarmStartedAt = performance.now();
+      const prewarmRequested = input.args.prewarm_input === true && Boolean(selected.udid);
+      const inputPrewarm: Record<string, unknown> = prewarmRequested && selected.udid
+        ? prewarmRemoteXpcHid({
+          controllerHome: input.controllerHome,
+          deviceIdentifier: selected.identifier,
+          udid: selected.udid,
+        })
+        : { backend: 'remote-xpc-hid', state: 'not_requested', runnerOwned: false };
+      recordTiming(
+        timingStages,
+        'hidPrewarm',
+        prewarmStartedAt,
+        inputPrewarm.state === 'ready' || inputPrewarm.state === 'test' || input.args.prewarm_input !== true,
+      );
+      const displayStartedAt = performance.now();
+      const display = input.args.prewarm_input === true
+        ? await physicalDisplayGeometry(input, selected).then((result) => {
+          recordTiming(timingStages, 'displayInfo', displayStartedAt, false);
+          return result;
+        }, (error) => {
+          recordTiming(timingStages, 'displayInfo', displayStartedAt, false);
+          throw error;
+        })
+        : undefined;
+      if (input.args.prewarm_input !== true) recordTiming(timingStages, 'displayInfo', displayStartedAt, true);
+      if (display) {
+        state.display = { ...display, observedAt: createdAt };
+        writeState(input, state);
+      }
+      const launchStartedAt = performance.now();
+      const launchPromise = runCoreJson(input, args, 'IOS_DEVICE_LAUNCH_FAILED', 60_000)
+        .finally(() => recordTiming(timingStages, 'activationRequest', launchStartedAt, false));
+      const launch = await launchPromise;
+      const launchEventStartedAt = performance.now();
       appendEvent(input, interactionId, 'app_launched', { bundleId, relaunch: input.args.relaunch === true });
-      if (runnerProbe.ready && runnerProbe.endpoint) {
-        try {
-          state.runner.sessionId = await createRunnerSession(runnerProbe.endpoint, bundleId);
-          state.runner.ready = true;
-          state.runner.error = undefined;
-          writeState(input, state);
-          appendEvent(input, interactionId, 'ui_runner_attached', { endpoint: runnerProbe.endpoint });
-        } catch (error) {
-          state.runner.ready = false;
-          state.runner.error = toAssistantPluginError(error, {
-            code: 'IOS_DEVICE_UI_SESSION_FAILED',
-            message: 'The app launched, but the UI runner session could not be created.',
-            retryable: true,
-          }).message;
-          writeState(input, state);
-          appendEvent(input, interactionId, 'ui_runner_unavailable', { error: state.runner.error });
-        }
+      recordTiming(timingStages, 'eventPersistence', launchEventStartedAt, false);
+      if (input.args.prewarm_input === true) {
+        appendEvent(input, interactionId, 'input_prewarm', {
+          state: inputPrewarm.state,
+          ...(typeof inputPrewarm.waitMs === 'number' ? { waitMs: inputPrewarm.waitMs } : {}),
+          ...(typeof inputPrewarm.errorCode === 'string' ? { errorCode: inputPrewarm.errorCode } : {}),
+          ...(typeof inputPrewarm.phase === 'string' ? { phase: inputPrewarm.phase } : {}),
+        });
       }
+      // CoreDevice is the default physical-device substrate. Never probe, start,
+      // build, install, or attach an XCTest/WDA runner during ordinary app open.
+      // Semantic automation is an explicit opt-in action so repeated computer-use
+      // workflows cannot accidentally create fresh Runner lifecycles.
       const active = patchInteractionSession(input.repoRoot, PROVIDER, interactionId, { status: 'waiting_for_user' }) ?? record;
-      return {
+      return finishTimedResult(actionStartedAt, timingStages, {
         provider: 'coredevice',
         interaction: active,
         device: selected,
         app: apps[0],
         launch: bounded(launch),
-        uiAutomation: bounded(readState(input, interactionId)?.runner),
-      };
+        foregroundVerification: {
+          authority: 'screenshot_observation',
+          required: true,
+          coreDeviceActivatedWhenStartedHint: objectValue(objectValue(launch.result).launchOptions).activatedWhenStarted === true,
+        },
+        inputPrewarm,
+        controlPlane: {
+          lifecycle: 'coredevice',
+          observation: 'coredevice',
+          input: 'remote-xpc-hid',
+          semanticFallback: 'agent-device',
+          runnerOwned: false,
+        },
+      });
     } catch (error) {
+      stopRemoteXpcHidForDevice(selected.identifier);
       const normalized = toAssistantPluginError(error, {
         code: 'IOS_DEVICE_OPEN_FAILED',
         message: 'The physical iOS app could not be opened.',
@@ -840,114 +1348,357 @@ export async function executeIosPhysicalDeviceAction(input: AssistantPluginActio
     }
   }
 
+  const sessionLookupStartedAt = performance.now();
   const { record, state } = requireRecord(input, input.actionId === 'physical_device_close');
+  recordTiming(timingStages, 'sessionLookup', sessionLookupStartedAt, false);
   switch (input.actionId) {
-    case 'physical_device_snapshot': {
-      const runner = requireRunner(state);
-      const value = await runnerRequest('GET', runner.endpoint, `/session/${encodeURIComponent(runner.sessionId)}/source`, undefined, 'IOS_DEVICE_SNAPSHOT_FAILED');
-      appendEvent(input, record.interactionId, 'snapshot');
-      return { provider: 'coredevice', interaction: record, source: bounded(value) };
-    }
-    case 'physical_device_press': {
-      const runner = requireRunner(state);
-      const target = optionalString(input.args.target);
-      const hasPoint = typeof input.args.x === 'number' && typeof input.args.y === 'number';
-      if (!target && !hasPoint) throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'target or x/y is required.', { retryable: false });
-      if (target) {
-        rejectSensitiveSemantic(target, 'Press');
-        const id = await elementId(runner.endpoint, runner.sessionId, target);
-        await inspectElementSemantics(runner.endpoint, runner.sessionId, id, target, 'Press');
-        await runnerRequest('POST', runner.endpoint, `/session/${encodeURIComponent(runner.sessionId)}/element/${encodeURIComponent(id)}/click`, {}, 'IOS_DEVICE_PRESS_FAILED');
-        appendEvent(input, record.interactionId, 'press', { target });
-      } else {
-        const purpose = requireString(input.args.purpose, 'purpose');
-        rejectSensitiveSemantic(purpose, 'Coordinate press');
-        await runnerRequest('POST', runner.endpoint, `/session/${encodeURIComponent(runner.sessionId)}/wda/tap`, {
-          x: Number(input.args.x), y: Number(input.args.y),
-        }, 'IOS_DEVICE_PRESS_FAILED');
-        appendEvent(input, record.interactionId, 'press_coordinate', { x: input.args.x, y: input.args.y, purpose });
-      }
-      return { provider: 'coredevice', interaction: record, success: true };
-    }
-    case 'physical_device_fill': {
-      const runner = requireRunner(state);
-      const target = requireString(input.args.target, 'target');
-      rejectSensitiveSemantic(target, 'Fill');
-      const text = typeof input.args.text === 'string' ? input.args.text : undefined;
-      if (text === undefined) throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'text is required.', { retryable: false });
-      const id = await elementId(runner.endpoint, runner.sessionId, target);
-      await inspectElementSemantics(runner.endpoint, runner.sessionId, id, target, 'Fill');
-      await runnerRequest('POST', runner.endpoint, `/session/${encodeURIComponent(runner.sessionId)}/element/${encodeURIComponent(id)}/clear`, {}, 'IOS_DEVICE_FILL_FAILED', true);
-      await runnerRequest('POST', runner.endpoint, `/session/${encodeURIComponent(runner.sessionId)}/element/${encodeURIComponent(id)}/value`, {
-        text, value: Array.from(text),
-      }, 'IOS_DEVICE_FILL_FAILED', true);
-      appendEvent(input, record.interactionId, 'fill', { target, text: '<redacted>' });
-      return { provider: 'coredevice', interaction: record, success: true, text: '<redacted>' };
-    }
-    case 'physical_device_scroll': {
-      const runner = requireRunner(state);
-      const direction = requireString(input.args.direction, 'direction');
-      if (!['up', 'down', 'left', 'right', 'top', 'bottom'].includes(direction)) {
-        throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'Unsupported scroll direction.', { retryable: false });
-      }
-      const sizeValue = await runnerRequest('GET', runner.endpoint, `/session/${encodeURIComponent(runner.sessionId)}/window/size`, undefined, 'IOS_DEVICE_SCROLL_FAILED');
-      const size = objectValue(sizeValue);
-      const width = Number(size.width ?? 0);
-      const height = Number(size.height ?? 0);
-      if (!(width > 0 && height > 0)) throw new AssistantPluginError('IOS_DEVICE_SCROLL_FAILED', 'The UI runner returned an invalid window size.', { retryable: false });
-      const amount = Math.max(20, Math.min(80, typeof input.args.amount === 'number' ? Math.trunc(input.args.amount) : 60)) / 100;
-      let fromX = width / 2; let toX = width / 2; let fromY = height / 2; let toY = height / 2;
-      if (direction === 'down' || direction === 'bottom') { fromY = height * 0.8; toY = height * (0.8 - amount); }
-      if (direction === 'up' || direction === 'top') { fromY = height * 0.2; toY = height * (0.2 + amount); }
-      if (direction === 'right') { fromX = width * 0.8; toX = width * (0.8 - amount); }
-      if (direction === 'left') { fromX = width * 0.2; toX = width * (0.2 + amount); }
-      await runnerRequest('POST', runner.endpoint, `/session/${encodeURIComponent(runner.sessionId)}/wda/dragfromtoforduration`, {
-        fromX, fromY, toX, toY, duration: 0.25,
-      }, 'IOS_DEVICE_SCROLL_FAILED');
-      appendEvent(input, record.interactionId, 'scroll', { direction, amount });
-      return { provider: 'coredevice', interaction: record, success: true };
-    }
     case 'physical_device_screenshot': {
       const label = sanitize(optionalString(input.args.label) ?? 'screenshot');
       const path = join(artifactDir(input, record.interactionId), `${label}-${hooks.now().getTime()}.png`);
-      const result = runCoreJson(input, [
+      const result = await runCoreJson(input, [
         'device', 'capture', 'screenshot', '--device', state.device.identifier, '--destination', path,
       ], 'IOS_DEVICE_SCREENSHOT_FAILED', 60_000);
       if (!existsSync(path)) {
         throw new AssistantPluginError('IOS_DEVICE_SCREENSHOT_MISSING', 'CoreDevice succeeded without creating the requested screenshot.', { retryable: false });
       }
-      appendEvent(input, record.interactionId, 'screenshot', { label });
-      return {
+      const observedAt = timestamp();
+      const observationId = randomUUID();
+      const screenshotDisplay = pngDisplayGeometry(path, state.display?.pointScale);
+      if (screenshotDisplay) state.display = { ...screenshotDisplay, observedAt };
+      state.lastScreenshot = { observationId, observedAt, label };
+      state.foregroundObservation = undefined;
+      writeState(input, state);
+      const eventStartedAt = performance.now();
+      appendEvent(input, record.interactionId, 'screenshot', { label, observationId });
+      recordTiming(timingStages, 'eventPersistence', eventStartedAt, false);
+      return finishTimedResult(actionStartedAt, timingStages, {
         provider: 'coredevice', interaction: record, result: bounded(result),
+        observation: { observationId, observedAt, label, ttlMs: INPUT_FOREGROUND_OBSERVATION_TTL_MS },
+        fastPath: {
+          actionId: 'physical_device_batch',
+          arguments: { interaction_id: record.interactionId, observation_id: observationId },
+          requires: ['steps'],
+          ttlMs: INPUT_FOREGROUND_OBSERVATION_TTL_MS,
+          oneShot: true,
+        },
         artifactCandidates: [{ kind: 'ios_physical_device_screenshot', mediaType: 'image/png', path }],
+      });
+    }
+    case 'physical_device_confirm_foreground': {
+      const observationId = requireString(input.args.observation_id, 'observation_id');
+      const bundleId = requireString(input.args.bundle_id, 'bundle_id');
+      if (bundleId !== state.bundleId) {
+        throw new AssistantPluginError('IOS_DEVICE_FOREGROUND_OBSERVATION_MISMATCH', `Foreground confirmation bundle ${bundleId} does not match session target ${state.bundleId}.`, {
+          retryable: false,
+          details: { expectedBundleId: state.bundleId, providedBundleId: bundleId, hidMutationDispatched: false },
+        });
+      }
+      const { observation, ageMs } = recentScreenshotObservation(state, observationId);
+      const confirmedAt = timestamp();
+      state.foregroundObservation = {
+        observationId: observation.observationId,
+        screenshotObservedAt: observation.observedAt,
+        confirmedAt,
+        bundleId,
+      };
+      writeState(input, state);
+      appendEvent(input, record.interactionId, 'foreground_confirmed', { observationId, bundleId, screenshotAgeMs: ageMs });
+      return {
+        provider: 'coredevice',
+        interaction: record,
+        foregroundObservation: { observationId, bundleId, screenshotObservedAt: observation.observedAt, confirmedAt, ttlMs: INPUT_FOREGROUND_OBSERVATION_TTL_MS },
+        deviceUnmodified: true,
       };
     }
+    case 'physical_device_observed_tap': {
+      const lockStartedAt = performance.now();
+      const unlock = await requireSessionUnlocked(input, state);
+      recordTiming(timingStages, 'lockState', lockStartedAt, unlock.cached);
+      if (!state.device.udid) throw new AssistantPluginError('IOS_HID_UDID_MISSING', 'The selected iPhone does not expose a hardware UDID for RemoteXPC HID.', { retryable: false });
+      const observationId = requireString(input.args.observation_id, 'observation_id');
+      const observationStartedAt = performance.now();
+      const { observation, ageMs } = recentScreenshotObservation(state, observationId);
+      recordTiming(timingStages, 'screenObservation', observationStartedAt, true);
+      const displayStartedAt = performance.now();
+      const geometry = await sessionDisplayGeometry(input, state);
+      recordTiming(timingStages, 'displayInfo', displayStartedAt, geometry.cached);
+      const display = geometry.display;
+      const x = requireFiniteNumber(input.args.x, 'x');
+      const y = requireFiniteNumber(input.args.y, 'y');
+      consumePhysicalScreenObservation(input, state);
+      const hidStartedAt = performance.now();
+      const result = await executeRemoteXpcHidInput({
+        controllerHome: input.controllerHome, deviceIdentifier: state.device.identifier, udid: state.device.udid,
+        width: display.width, height: display.height, action: 'tap', x, y,
+      });
+      timingStages.hidWorkerReady = { ms: result.timings.workerStartupMs + result.timings.workerReadyMs, cached: result.reusedWorker };
+      timingStages.hidWriteAck = { ms: result.timings.hidMs ?? result.timings.requestMs, cached: false };
+      timingStages.hidRequestTotal = { ms: elapsedMs(hidStartedAt), cached: result.reusedWorker };
+      appendEvent(input, record.interactionId, 'observed_tap', { requestId: input.requestId, observationId: observation.observationId, observationAgeMs: ageMs, x, y, reusedWorker: result.reusedWorker });
+      return finishTimedResult(actionStartedAt, timingStages, { provider: 'coredevice', inputBackend: 'remote-xpc-hid', interaction: record, display, result: bounded(result), observationConsumed: true });
+    }
+    case 'physical_device_batch': {
+      const lockStartedAt = performance.now();
+      const unlock = await requireSessionUnlocked(input, state);
+      recordTiming(timingStages, 'lockState', lockStartedAt, unlock.cached);
+      if (!state.device.udid) throw new AssistantPluginError('IOS_HID_UDID_MISSING', 'The selected iPhone does not expose a hardware UDID for RemoteXPC HID.', { retryable: false });
+      const steps = physicalInputBatchSteps(input.args.steps);
+      let display: DisplayGeometry | undefined;
+      if (steps.some((step) => step.kind === 'tap' || step.kind === 'swipe')) {
+        const displayStartedAt = performance.now();
+        const geometry = await sessionDisplayGeometry(input, state);
+        recordTiming(timingStages, 'displayInfo', displayStartedAt, geometry.cached);
+        display = geometry.display;
+      }
+      validatePhysicalInputBatchCoordinates(steps, display);
+      const foregroundStartedAt = performance.now();
+      const observationId = input.args.observation_id === undefined
+        ? undefined
+        : requireString(input.args.observation_id, 'observation_id');
+      const foreground = resolvePhysicalBatchForegroundObservation(state, observationId);
+      const foregroundObservation = foreground.foregroundObservation;
+      recordTiming(timingStages, 'foregroundObservation', foregroundStartedAt, true);
+      consumePhysicalScreenObservation(input, state);
+      const batchStartedAt = performance.now();
+      const completed: Array<Record<string, unknown>> = [];
+      let completedMutations = 0;
+      for (let index = 0; index < steps.length; index += 1) {
+        const step = steps[index]!;
+        try {
+          if (step.kind === 'wait') {
+            await waitPhysicalInputBatch(step.durationMs ?? 0, input.signal);
+            completed.push({ index, kind: step.kind, durationMs: step.durationMs ?? 0 });
+            continue;
+          }
+          let result: Awaited<ReturnType<typeof executeRemoteXpcHidInput>>;
+          if (step.kind === 'tap') {
+            result = await executeRemoteXpcHidInput({
+              controllerHome: input.controllerHome,
+              deviceIdentifier: state.device.identifier,
+              udid: state.device.udid,
+              width: display?.width,
+              height: display?.height,
+              action: 'tap', x: step.x, y: step.y,
+            });
+          } else if (step.kind === 'swipe') {
+            result = await executeRemoteXpcHidInput({
+              controllerHome: input.controllerHome,
+              deviceIdentifier: state.device.identifier,
+              udid: state.device.udid,
+              width: display?.width,
+              height: display?.height,
+              action: 'swipe', x: step.x, y: step.y, x2: step.toX, y2: step.toY, durationMs: step.durationMs,
+            });
+          } else {
+            result = await executeRemoteXpcHidInput({
+              controllerHome: input.controllerHome,
+              deviceIdentifier: state.device.identifier,
+              udid: state.device.udid,
+              action: 'type', text: step.text, textMode: step.textMode, replaceExisting: step.replaceExisting,
+            });
+          }
+          completedMutations += 1;
+          completed.push({
+            index,
+            kind: step.kind,
+            reusedWorker: result.reusedWorker,
+            requestMs: result.timings.requestMs,
+            hidMs: result.timings.hidMs,
+            ...(step.kind === 'type' ? { inputMode: objectValue(result.result).inputMode } : {}),
+          });
+        } catch (error) {
+          const normalized = toAssistantPluginError(error, {
+            code: 'IOS_HID_BATCH_FAILED',
+            message: `Physical iOS input batch failed at step ${index}.`,
+            retryable: false,
+          });
+          const eventStartedAt = performance.now();
+          const causeDetails = normalized.details && typeof normalized.details === 'object' && !Array.isArray(normalized.details)
+            ? normalized.details as Record<string, unknown>
+            : {};
+          const retryWholeBatch = completedMutations === 0 && causeDetails.mutationDispatched === false;
+          const causePhase = typeof causeDetails.phase === 'string' ? causeDetails.phase : undefined;
+          const causeMutationDispatched = typeof causeDetails.mutationDispatched === 'boolean'
+            ? causeDetails.mutationDispatched
+            : undefined;
+          const causeMessage = normalized.message.startsWith(`${normalized.code}: `)
+            ? normalized.message.slice(normalized.code.length + 2, normalized.code.length + 514)
+            : normalized.message.slice(0, 512);
+          appendEvent(input, record.interactionId, 'batch_failed', {
+            requestId: input.requestId,
+            failedStepIndex: index,
+            failedStepKind: step.kind,
+            completedSteps: completed.length,
+            completedMutations,
+            retryWholeBatch,
+            causeCode: normalized.code,
+            ...(causePhase ? { causePhase } : {}),
+            ...(causeMutationDispatched === undefined ? {} : { mutationDispatched: causeMutationDispatched }),
+            causeMessage,
+          });
+          recordTiming(timingStages, 'eventPersistence', eventStartedAt, false);
+          throw new AssistantPluginError(
+            'IOS_HID_BATCH_FAILED',
+            retryWholeBatch
+              ? `Physical iOS input batch stopped at step ${index} before any HID mutation was sent; retrying the whole batch is safe.`
+              : `Physical iOS input batch stopped at step ${index}; do not retry the whole batch because an earlier or in-flight step may already have mutated the app.`,
+            {
+              retryable: retryWholeBatch,
+              details: {
+                failedStepIndex: index,
+                failedStepKind: step.kind,
+                completedSteps: completed.length,
+                completedMutations,
+                retryWholeBatch,
+                causeCode: normalized.code,
+                ...(causePhase ? { causePhase } : {}),
+                ...(causeMutationDispatched === undefined ? {} : { mutationDispatched: causeMutationDispatched }),
+                causeMessage,
+              },
+            },
+          );
+        }
+      }
+      recordTiming(timingStages, 'hidBatchTotal', batchStartedAt, false);
+      const eventStartedAt = performance.now();
+      appendEvent(input, record.interactionId, 'batch_input', {
+        requestId: input.requestId,
+        stepCount: steps.length,
+        mutationCount: completedMutations,
+        kinds: steps.map((step) => step.kind),
+      });
+      recordTiming(timingStages, 'eventPersistence', eventStartedAt, false);
+      return finishTimedResult(actionStartedAt, timingStages, {
+        provider: 'coredevice',
+        inputBackend: 'remote-xpc-hid',
+        interaction: record,
+        ...(display ? { display } : {}),
+        completed,
+        foregroundObservation: {
+          ...foregroundObservation,
+          consumed: true,
+          source: foreground.source,
+          ...(foreground.screenshotAgeMs === undefined ? {} : { screenshotAgeMs: foreground.screenshotAgeMs }),
+        },
+        executionPlan: {
+          foregroundActivations: 0,
+          foregroundObservationChecks: 1,
+          foregroundObservationSource: foreground.source,
+          unlockChecks: unlock.cached ? 0 : 1,
+          displayLookups: display ? 1 : 0,
+          pluginRoundTrips: 1,
+          runnerOwned: false,
+        },
+      });
+    }
+    case 'physical_device_tap': {
+      const lockStartedAt = performance.now();
+      const unlock = await requireSessionUnlocked(input, state);
+      recordTiming(timingStages, 'lockState', lockStartedAt, unlock.cached);
+      if (!state.device.udid) throw new AssistantPluginError('IOS_HID_UDID_MISSING', 'The selected iPhone does not expose a hardware UDID for RemoteXPC HID.', { retryable: false });
+      const displayStartedAt = performance.now();
+      const geometry = await sessionDisplayGeometry(input, state);
+      recordTiming(timingStages, 'displayInfo', displayStartedAt, geometry.cached);
+      const display = geometry.display;
+      const x = requireFiniteNumber(input.args.x, 'x');
+      const y = requireFiniteNumber(input.args.y, 'y');
+      const foregroundStartedAt = performance.now();
+      const foregroundObservation = requireObservedPhysicalTargetForeground(state);
+      recordTiming(timingStages, 'foregroundObservation', foregroundStartedAt, true);
+      consumePhysicalScreenObservation(input, state);
+      const hidStartedAt = performance.now();
+      const result = await executeRemoteXpcHidInput({
+        controllerHome: input.controllerHome,
+        deviceIdentifier: state.device.identifier,
+        udid: state.device.udid,
+        width: display.width,
+        height: display.height,
+        action: 'tap', x, y,
+      });
+      timingStages.hidWorkerReady = { ms: result.timings.workerStartupMs + result.timings.workerReadyMs, cached: result.reusedWorker };
+      timingStages.hidWriteAck = { ms: result.timings.hidMs ?? result.timings.requestMs, cached: false };
+      timingStages.hidRequestTotal = { ms: elapsedMs(hidStartedAt), cached: result.reusedWorker };
+      const eventStartedAt = performance.now();
+      appendEvent(input, record.interactionId, 'tap', { requestId: input.requestId, x, y, width: display.width, height: display.height, reusedWorker: result.reusedWorker });
+      recordTiming(timingStages, 'eventPersistence', eventStartedAt, false);
+      return finishTimedResult(actionStartedAt, timingStages, { provider: 'coredevice', inputBackend: 'remote-xpc-hid', interaction: record, display, result: bounded(result), foregroundObservation: { ...foregroundObservation, consumed: true } });
+    }
+    case 'physical_device_swipe': {
+      const lockStartedAt = performance.now();
+      const unlock = await requireSessionUnlocked(input, state);
+      recordTiming(timingStages, 'lockState', lockStartedAt, unlock.cached);
+      if (!state.device.udid) throw new AssistantPluginError('IOS_HID_UDID_MISSING', 'The selected iPhone does not expose a hardware UDID for RemoteXPC HID.', { retryable: false });
+      const displayStartedAt = performance.now();
+      const geometry = await sessionDisplayGeometry(input, state);
+      recordTiming(timingStages, 'displayInfo', displayStartedAt, geometry.cached);
+      const display = geometry.display;
+      const x = requireFiniteNumber(input.args.x, 'x');
+      const y = requireFiniteNumber(input.args.y, 'y');
+      const x2 = requireFiniteNumber(input.args.to_x, 'to_x');
+      const y2 = requireFiniteNumber(input.args.to_y, 'to_y');
+      const durationMs = typeof input.args.duration_ms === 'number' ? Math.trunc(input.args.duration_ms) : 250;
+      const foregroundStartedAt = performance.now();
+      const foregroundObservation = requireObservedPhysicalTargetForeground(state);
+      recordTiming(timingStages, 'foregroundObservation', foregroundStartedAt, true);
+      consumePhysicalScreenObservation(input, state);
+      const hidStartedAt = performance.now();
+      const result = await executeRemoteXpcHidInput({
+        controllerHome: input.controllerHome,
+        deviceIdentifier: state.device.identifier,
+        udid: state.device.udid,
+        width: display.width,
+        height: display.height,
+        action: 'swipe', x, y, x2, y2, durationMs,
+      });
+      timingStages.hidWorkerReady = { ms: result.timings.workerStartupMs + result.timings.workerReadyMs, cached: result.reusedWorker };
+      timingStages.hidWriteAck = { ms: result.timings.hidMs ?? result.timings.requestMs, cached: false };
+      timingStages.hidRequestTotal = { ms: elapsedMs(hidStartedAt), cached: result.reusedWorker };
+      const eventStartedAt = performance.now();
+      appendEvent(input, record.interactionId, 'swipe', { requestId: input.requestId, from: [x, y], to: [x2, y2], durationMs, reusedWorker: result.reusedWorker });
+      recordTiming(timingStages, 'eventPersistence', eventStartedAt, false);
+      return finishTimedResult(actionStartedAt, timingStages, { provider: 'coredevice', inputBackend: 'remote-xpc-hid', interaction: record, display, result: bounded(result), foregroundObservation: { ...foregroundObservation, consumed: true } });
+    }
+    case 'physical_device_type_text': {
+      const lockStartedAt = performance.now();
+      const unlock = await requireSessionUnlocked(input, state);
+      recordTiming(timingStages, 'lockState', lockStartedAt, unlock.cached);
+      if (!state.device.udid) throw new AssistantPluginError('IOS_HID_UDID_MISSING', 'The selected iPhone does not expose a hardware UDID for RemoteXPC HID.', { retryable: false });
+      const text = requireString(input.args.text, 'text');
+      const textMode = optionalString(input.args.input_mode) ?? 'auto';
+      if (!['auto', 'keys', 'pasteboard'].includes(textMode)) {
+        throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', `Unsupported input_mode: ${textMode}.`, { retryable: false });
+      }
+      const foregroundStartedAt = performance.now();
+      const foregroundObservation = requireObservedPhysicalTargetForeground(state);
+      recordTiming(timingStages, 'foregroundObservation', foregroundStartedAt, true);
+      consumePhysicalScreenObservation(input, state);
+      const hidStartedAt = performance.now();
+      const result = await executeRemoteXpcHidInput({
+        controllerHome: input.controllerHome,
+        deviceIdentifier: state.device.identifier,
+        udid: state.device.udid,
+        action: 'type', text, textMode: textMode as 'auto' | 'keys' | 'pasteboard', replaceExisting: input.args.replace_existing === true,
+      });
+      timingStages.hidWorkerReady = { ms: result.timings.workerStartupMs + result.timings.workerReadyMs, cached: result.reusedWorker };
+      timingStages.hidWriteAck = { ms: result.timings.hidMs ?? result.timings.requestMs, cached: false };
+      timingStages.hidRequestTotal = { ms: elapsedMs(hidStartedAt), cached: result.reusedWorker };
+      const eventStartedAt = performance.now();
+      appendEvent(input, record.interactionId, 'type_text', { requestId: input.requestId, length: text.length, reusedWorker: result.reusedWorker });
+      recordTiming(timingStages, 'eventPersistence', eventStartedAt, false);
+      return finishTimedResult(actionStartedAt, timingStages, { provider: 'coredevice', inputBackend: 'remote-xpc-hid', interaction: record, result: bounded(result), text: '<redacted>', foregroundObservation: { ...foregroundObservation, consumed: true } });
+    }
     case 'physical_device_events': {
       const limit = Math.max(1, Math.min(MAX_EVENTS, typeof input.args.limit === 'number' ? Math.trunc(input.args.limit) : 50));
       return { provider: 'coredevice', interaction: record, events: bounded(state.events.slice(-limit)) };
     }
     case 'physical_device_close': {
+      const inputWorkerRelease = stopRemoteXpcHidForDevice(state.device.identifier);
       const wasActive = isInteractionSessionActive(record.status);
-      const runnerNeedsCleanup = Boolean(state.runner.endpoint && state.runner.sessionId);
-      if (!wasActive && !runnerNeedsCleanup) return { provider: 'coredevice', interaction: record, alreadyClosed: true };
-      if (wasActive) patchInteractionSession(input.repoRoot, PROVIDER, record.interactionId, { status: 'closing' });
-      const closed = await closeRunner(state);
-      if (!closed) {
-        patchInteractionSession(input.repoRoot, PROVIDER, record.interactionId, {
-          status: 'closing',
-          error: { code: 'IOS_DEVICE_UI_CLOSE_FAILED', message: 'The UI runner session could not be closed; ownership remains fenced.' },
-        });
-        throw new AssistantPluginError('IOS_DEVICE_UI_CLOSE_FAILED', 'The UI runner session could not be closed; retry physical_device_close.', { retryable: true });
-      }
-      state.runner.ready = false;
-      state.runner.sessionId = undefined;
-      writeState(input, state);
-      appendEvent(input, record.interactionId, 'session_closed');
-      if (!wasActive) {
-        return { provider: 'coredevice', interaction: record, alreadyClosed: true, runnerCleaned: runnerNeedsCleanup, deviceUnmodified: true };
-      }
+      if (!wasActive) return { provider: 'coredevice', interaction: record, alreadyClosed: true, deviceUnmodified: true, inputWorkerRelease };
+      patchInteractionSession(input.repoRoot, PROVIDER, record.interactionId, { status: 'closing' });
+      appendEvent(input, record.interactionId, 'session_closed', { inputWorkerRelease });
       const finalRecord = patchInteractionSession(input.repoRoot, PROVIDER, record.interactionId, { status: 'closed', error: undefined }) ?? record;
-      return { provider: 'coredevice', interaction: finalRecord, deviceUnmodified: true };
+      return { provider: 'coredevice', interaction: finalRecord, deviceUnmodified: true, inputWorkerRelease };
     }
     default:
       throw new AssistantPluginError('PLUGIN_ACTION_NOT_SUPPORTED', `ios/${input.actionId} is not supported.`, { retryable: false });