fix: B116/B117/B118 — multi-platform correctness follow-ups

Three benchmark-surfaced bugs from Phase 88 Round 2 Android, all fixed in
this batch with unit tests. 213 -> 225 tests passing.

B118/D637 — platform-aware CDP timeouts
Android emulator JS thread is 50-170× slower than iOS simulator for
Runtime.evaluate. A single 5s CDP_TIMEOUT_MS constant produced false-negatives
on typeText (timed out AFTER the mutation succeeded). Introduced Platform
type + defaultTimeout(platform) + timeoutForMethod(method, platform) in
cdp/timeout-config.ts. Android gets 2×; iOS unchanged. CDPClient routes both
evaluate paths and sendWithTimeout fallbacks through the new helpers using
this._connectedTarget?.platform. 10 new unit tests.

B117/D638 — device_* tools inherit platform from CDP target
runAgentDevice(cliArgs, opts) now accepts optional platform; appends
--platform <p> to agent-device CLI when no session is open. Sessions still
carry device identity so session-happy path unchanged.
createDeviceScreenshotHandler accepts optional getClient and derives platform
from client.connectedTarget?.platform with an explicit args.platform
override. Added `platform` to device_screenshot tool schema. Back-compat
preserved (existing zero-arg call still works). 3 new unit tests.

B116/D639 — simctl listapps cross-check in platform inference
inferPlatforms now reads BOTH adb pm list AND xcrun simctl listapps booted
(via parseSimctlListapps, which extracts top-level bundle IDs from the
NeXTSTEP plist format, skipping nested GroupContainers). Logic:
Android-only→android, iOS-only→ios, both→ios+ambiguousPlatform=true,
neither→ios. Readers are injectable for unit testing without subprocesses.
HermesTarget gains ambiguousPlatform flag. 9 new unit tests.

All 225 tests pass; TypeScript clean; dist/ rebuilt.

Author: Lykhoyda

scripts/cdp-bridge/dist/agent-device-wrapper.js

@@ -378,6 +378,13 @@ export async function runAgentDevice(cliArgs, opts = {}) {
     if (sessionName) {
         args.push('--session', sessionName);
     }
+    else if (opts.platform) {
+        // B117/D638: when no session is open but a platform hint is provided (e.g. from
+        // CDPClient.connectedTarget.platform), pass --platform so agent-device doesn't
+        // default to whichever booted device it finds first. Avoids wrong-device
+        // screenshots when both iOS sim and Android emulator are booted.
+        args.push('--platform', opts.platform);
+    }
     try {
         const { stdout } = await execFile('agent-device', args, {
             timeout: EXEC_TIMEOUT,

scripts/cdp-bridge/dist/cdp-client.js

@@ -4,7 +4,7 @@ import { detectBridge } from './bridge-detector.js';
 import { logger } from './logger.js';
 import { performSetup, reinjectHelpers as reinjectHelpersFn } from './cdp/setup.js';
 import { resetState, setActiveFlag, clearActiveFlag, sleep } from './cdp/state.js';
-import { CDP_TIMEOUT_MS, timeoutForMethod } from './cdp/timeout-config.js';
+import { defaultTimeout, timeoutForMethod } from './cdp/timeout-config.js';
 import { sendWithTimeout as sendMsg, rejectAllPending as rejectPending, handleMessage as handleMsg } from './cdp/transport.js';
 import { wireEventHandlers, parseNetworkHookMessage as parseNetHook } from './cdp/event-handlers.js';
 import { discoverForList } from './cdp/discovery.js';
@@ -114,14 +114,18 @@ export class CDPClient {
         }
         this.rejectAllPending(new Error('Client disconnected'));
     }
+    get effectivePlatform() {
+        return this._connectedTarget?.platform ?? null;
+    }
     async evaluate(expression, awaitPromise = false) {
         if (awaitPromise) {
             return this.evaluateAsync(expression);
         }
+        const timeout = defaultTimeout(this.effectivePlatform);
         const result = await this.sendWithTimeout('Runtime.evaluate', {
             expression,
             returnByValue: true,
-        }, CDP_TIMEOUT_MS);
+        }, timeout);
         if (result?.exceptionDetails) {
             return {
                 error: result.exceptionDetails.text ??
@@ -135,8 +139,9 @@ export class CDPClient {
         // Hermes CDP doesn't support awaitPromise — use global slot + polling
         // Values are JSON-serialized inside Hermes to handle non-serializable objects
         // A deferred cleanup timer ensures the slot is removed even if the caller times out
+        const timeout = defaultTimeout(this.effectivePlatform);
         const slot = '__rn_agent_async_' + (++this.slotId) + '_' + Date.now();
-        const ASYNC_CLEANUP_MS = CDP_TIMEOUT_MS * 2;
+        const ASYNC_CLEANUP_MS = timeout * 2;
         const wrapper = `(function() {
       function safeVal(v) {
         try { return JSON.stringify(v); } catch(e) { return JSON.stringify(String(v)); }
@@ -153,17 +158,17 @@ export class CDPClient {
         const initResult = await this.sendWithTimeout('Runtime.evaluate', {
             expression: wrapper,
             returnByValue: true,
-        }, CDP_TIMEOUT_MS);
+        }, timeout);
         if (initResult?.exceptionDetails) {
             return {
                 error: initResult.exceptionDetails.text ??
                     initResult.exceptionDetails.exception?.description ??
                     'Unknown evaluation error',
             };
         }
-        // B45 fix: Use absolute deadline to guarantee total wall-clock stays within CDP_TIMEOUT_MS.
+        // B45 fix: Use absolute deadline to guarantee total wall-clock stays within timeout.
         // Each poll gets only the remaining time (min 500ms) to avoid overshooting.
-        const deadline = Date.now() + CDP_TIMEOUT_MS;
+        const deadline = Date.now() + timeout;
         while (Date.now() < deadline) {
             const remaining = deadline - Date.now();
             if (remaining < 500)
@@ -194,10 +199,10 @@ export class CDPClient {
             expression: `delete globalThis['${slot}']`,
             returnByValue: true,
         }, 1000).catch(() => { });
-        return { error: 'Promise did not resolve within ' + CDP_TIMEOUT_MS + 'ms' };
+        return { error: 'Promise did not resolve within ' + timeout + 'ms' };
     }
     async send(method, params) {
-        return this.sendWithTimeout(method, params, timeoutForMethod(method));
+        return this.sendWithTimeout(method, params, timeoutForMethod(method, this.effectivePlatform));
     }
     handleMessage(data) {
         handleMsg(data, this.pending, this.eventHandlers, (params) => this.parseNetworkHookMessage(params));
@@ -207,7 +212,7 @@ export class CDPClient {
     }
     async setup() {
         const result = await performSetup({
-            send: (method, params, ms) => this.sendWithTimeout(method, params, ms ?? timeoutForMethod(method)),
+            send: (method, params, ms) => this.sendWithTimeout(method, params, ms ?? timeoutForMethod(method, this.effectivePlatform)),
             evaluate: (expr) => this.evaluate(expr),
             port: this._port,
             connectedTarget: this._connectedTarget,
@@ -226,7 +231,7 @@ export class CDPClient {
         }
     }
     setupEventHandlers() {
-        wireEventHandlers(this.eventHandlers, { console: this._consoleBuffer, network: this._networkBuffer, log: this._logBuffer, scripts: this._scripts }, (method, params, ms) => this.sendWithTimeout(method, params, ms ?? timeoutForMethod(method)), () => this._isPaused, (v) => { this._isPaused = v; });
+        wireEventHandlers(this.eventHandlers, { console: this._consoleBuffer, network: this._networkBuffer, log: this._logBuffer, scripts: this._scripts }, (method, params, ms) => this.sendWithTimeout(method, params, ms ?? timeoutForMethod(method, this.effectivePlatform)), () => this._isPaused, (v) => { this._isPaused = v; });
     }
     handleClose(code) {
         handleCloseFn(this.buildReconnectCtx(), code);

scripts/cdp-bridge/dist/cdp/discovery.js

@@ -51,26 +51,83 @@ export function filterValidTargets(targets) {
             ?.replace(/\[::\]/g, '127.0.0.1'),
     }));
 }
-export function inferPlatforms(targets) {
-    let androidPackages = null;
+/**
+ * B116 (D639): extract top-level bundle IDs from `xcrun simctl listapps booted`.
+ * Output is NeXTSTEP plist; top-level keys are quoted bundle IDs at exactly
+ * 4-space indentation, e.g. `    "com.foo.bar" = {`. We match that pattern
+ * explicitly so we don't pick up nested keys like GroupContainers entries.
+ */
+export function parseSimctlListapps(stdout) {
+    const ids = new Set();
+    const TOP_LEVEL = /^    "([A-Za-z0-9._-]+)"\s*=\s*\{/;
+    for (const line of stdout.split('\n')) {
+        const m = line.match(TOP_LEVEL);
+        if (m)
+            ids.add(m[1]);
+    }
+    return ids;
+}
+function readAndroidPackages() {
     try {
         const out = execFileSync('adb', ['shell', 'pm', 'list', 'packages'], {
             timeout: 3000,
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'ignore'],
         });
-        androidPackages = new Set(out.split('\n')
+        return new Set(out.split('\n')
             .map(line => line.replace('package:', '').trim())
             .filter(Boolean));
     }
     catch {
-        // adb not available or no device — all targets treated as iOS
+        return null;
+    }
+}
+function readIOSPackages() {
+    try {
+        const out = execFileSync('xcrun', ['simctl', 'listapps', 'booted'], {
+            timeout: 5000,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return parseSimctlListapps(out);
     }
+    catch {
+        return null;
+    }
+}
+/**
+ * B116 (D639): look up each target's description against BOTH iOS simctl and
+ * Android adb installed-package sets. If present in only one, tag that
+ * platform. If present in both (same bundleId installed on both devices),
+ * we can't disambiguate from bundleId alone — leave the target ambiguous
+ * (callers must pass `targetId` or `bundleId` + `platform`).
+ * If present in neither (or lookup failed), fall back to iOS (matches prior
+ * behavior — iOS-first bias).
+ *
+ * Readers are injectable for unit testing without spawning subprocesses.
+ */
+export function inferPlatforms(targets, readers = {}) {
+    const androidPackages = (readers.readAndroid ?? readAndroidPackages)();
+    const iosPackages = (readers.readIOS ?? readIOSPackages)();
     for (const t of targets) {
-        if (androidPackages?.has(t.description ?? '')) {
+        const desc = t.description ?? '';
+        const inAndroid = androidPackages?.has(desc) ?? false;
+        const inIOS = iosPackages?.has(desc) ?? false;
+        if (inAndroid && !inIOS) {
             t.platform = 'android';
         }
+        else if (inIOS && !inAndroid) {
+            t.platform = 'ios';
+        }
+        else if (inAndroid && inIOS) {
+            // Ambiguous — same bundleId installed on both. Default to iOS but mark
+            // for downstream so callers can notice and pass targetId/bundleId filter.
+            t.platform = 'ios';
+            t.ambiguousPlatform = true;
+        }
         else {
+            // No information (adb/simctl both failed, or target bundle unknown) —
+            // default to iOS to preserve prior behavior for iOS-only setups.
             t.platform = 'ios';
         }
     }

scripts/cdp-bridge/dist/cdp/timeout-config.js

@@ -1,6 +1,11 @@
 export const CDP_TIMEOUT_FAST = 1500;
 export const CDP_TIMEOUT_MS = 5000;
 export const CDP_TIMEOUT_SLOW = 30000;
+// D637/B118: Android emulator JS thread runs Hermes operations 50-170× slower
+// than iOS simulator (Phase 88 benchmark). A single 5s default gave false-negatives
+// on typeText / complex store reads — the mutation succeeded but the Runtime.evaluate
+// round-trip missed the timeout. 2× multiplier for Android puts p95 back inside budget.
+const ANDROID_MULTIPLIER = 2;
 const METHOD_TIMEOUTS = new Map([
     ['Runtime.getHeapUsage', CDP_TIMEOUT_FAST],
     ['Log.enable', CDP_TIMEOUT_FAST],
@@ -11,6 +16,13 @@ const METHOD_TIMEOUTS = new Map([
     ['Profiler.stop', CDP_TIMEOUT_SLOW],
     ['Network.getResponseBody', CDP_TIMEOUT_SLOW],
 ]);
-export function timeoutForMethod(method) {
-    return METHOD_TIMEOUTS.get(method) ?? CDP_TIMEOUT_MS;
+function applyPlatformMultiplier(base, platform) {
+    return platform === 'android' ? base * ANDROID_MULTIPLIER : base;
+}
+export function timeoutForMethod(method, platform) {
+    const base = METHOD_TIMEOUTS.get(method) ?? CDP_TIMEOUT_MS;
+    return applyPlatformMultiplier(base, platform);
+}
+export function defaultTimeout(platform) {
+    return applyPlatformMultiplier(CDP_TIMEOUT_MS, platform);
 }

scripts/cdp-bridge/dist/index.js

@@ -277,10 +277,11 @@ trackedTool('collect_logs', 'Collect logs from multiple sources in parallel: JS
 }, createCollectLogsHandler(getClient));
 // --- agent-device tools (native device interaction) ---
 trackedTool('device_list', 'List all available iOS simulators and Android emulators. Returns device name, UDID, platform, and status. Use before device_snapshot action=open to confirm the target device.', {}, createDeviceListHandler());
-trackedTool('device_screenshot', 'Capture a screenshot of the active device screen. Returns image data or file path. Prefer JPEG for faster capture.', {
+trackedTool('device_screenshot', 'Capture a screenshot of the active device screen. Returns image data or file path. Prefer JPEG for faster capture. When both iOS sim and Android emulator are booted, defaults to the platform of the currently connected CDP target; override with `platform` if needed.', {
     path: z.string().optional().describe('Output file path (default: auto-generated in /tmp). Use .jpg extension for JPEG.'),
     format: z.enum(['jpeg', 'png']).optional().describe('Image format (default: auto-detect from path extension, or jpeg)'),
-}, createDeviceScreenshotHandler());
+    platform: z.enum(['ios', 'android']).optional().describe('Target device platform. Defaults to the currently-connected CDP target platform.'),
+}, createDeviceScreenshotHandler(getClient));
 trackedTool('device_snapshot', 'Manage device sessions and capture UI snapshots. action=open starts a session (required before other device_ tools). action=snapshot returns the accessibility tree with @ref identifiers for device_press/device_fill. action=close ends the session.', {
     action: z.enum(['open', 'close', 'snapshot']).default('snapshot').describe('open: start session for an app. snapshot: capture UI tree with element refs. close: end session.'),
     appId: z.string().optional().describe('App bundle ID — required for action=open (e.g. "com.example.app")'),

scripts/cdp-bridge/dist/tools/device-list.js

@@ -18,6 +18,15 @@ export function buildScreenshotArgs(args, now = Date.now) {
     }
     return ['screenshot', '--out', outputPath];
 }
-export function createDeviceScreenshotHandler() {
-    return async (args) => runAgentDevice(buildScreenshotArgs(args));
+/**
+ * B117/D638: device_screenshot now accepts an optional `platform` and, when not
+ * provided, falls back to the current CDP target's platform. Prevents
+ * wrong-device screenshots when both iOS sim and Android emulator are booted.
+ * getClient is optional so existing callers/tests still compile.
+ */
+export function createDeviceScreenshotHandler(getClient) {
+    return async (args) => {
+        const platform = args.platform ?? getClient?.()?.connectedTarget?.platform ?? null;
+        return runAgentDevice(buildScreenshotArgs(args), { platform });
+    };
 }

scripts/cdp-bridge/src/agent-device-wrapper.ts

@@ -368,7 +368,7 @@ function cacheRefMapFromResult(result: ToolResult): void {
 
 export async function runAgentDevice(
   cliArgs: string[],
-  opts: { skipSession?: boolean } = {},
+  opts: { skipSession?: boolean; platform?: 'ios' | 'android' | null } = {},
 ): Promise<ToolResult> {
   const sessionName = (!opts.skipSession && activeSession) ? activeSession.name : '';
   const isSnapshotCmd = cliArgs[0] === 'snapshot';
@@ -402,6 +402,12 @@ export async function runAgentDevice(
   const args = [...cliArgs, '--json'];
   if (sessionName) {
     args.push('--session', sessionName);
+  } else if (opts.platform) {
+    // B117/D638: when no session is open but a platform hint is provided (e.g. from
+    // CDPClient.connectedTarget.platform), pass --platform so agent-device doesn't
+    // default to whichever booted device it finds first. Avoids wrong-device
+    // screenshots when both iOS sim and Android emulator are booted.
+    args.push('--platform', opts.platform);
   }
 
   try {

scripts/cdp-bridge/src/cdp-client.ts

@@ -5,7 +5,8 @@ import { logger } from './logger.js';
 import { performSetup, reinjectHelpers as reinjectHelpersFn } from './cdp/setup.js';
 import { resetState, setActiveFlag, clearActiveFlag, sleep } from './cdp/state.js';
 import type { ResettableState } from './cdp/state.js';
-import { CDP_TIMEOUT_MS, timeoutForMethod } from './cdp/timeout-config.js';
+import { defaultTimeout, timeoutForMethod } from './cdp/timeout-config.js';
+import type { Platform } from './cdp/timeout-config.js';
 import { sendWithTimeout as sendMsg, rejectAllPending as rejectPending, handleMessage as handleMsg } from './cdp/transport.js';
 import { wireEventHandlers, parseNetworkHookMessage as parseNetHook } from './cdp/event-handlers.js';
 import { discover, discoverForList } from './cdp/discovery.js';
@@ -154,15 +155,20 @@ export class CDPClient {
     this.rejectAllPending(new Error('Client disconnected'));
   }
 
+  private get effectivePlatform(): Platform {
+    return this._connectedTarget?.platform ?? null;
+  }
+
   async evaluate(expression: string, awaitPromise = false): Promise<EvaluateResult> {
     if (awaitPromise) {
       return this.evaluateAsync(expression);
     }
 
+    const timeout = defaultTimeout(this.effectivePlatform);
     const result = await this.sendWithTimeout('Runtime.evaluate', {
       expression,
       returnByValue: true,
-    }, CDP_TIMEOUT_MS) as { result?: { value?: unknown }; exceptionDetails?: { text?: string; exception?: { description?: string } } };
+    }, timeout) as { result?: { value?: unknown }; exceptionDetails?: { text?: string; exception?: { description?: string } } };
 
     if (result?.exceptionDetails) {
       return {
@@ -178,8 +184,9 @@ export class CDPClient {
     // Hermes CDP doesn't support awaitPromise — use global slot + polling
     // Values are JSON-serialized inside Hermes to handle non-serializable objects
     // A deferred cleanup timer ensures the slot is removed even if the caller times out
+    const timeout = defaultTimeout(this.effectivePlatform);
     const slot = '__rn_agent_async_' + (++this.slotId) + '_' + Date.now();
-    const ASYNC_CLEANUP_MS = CDP_TIMEOUT_MS * 2;
+    const ASYNC_CLEANUP_MS = timeout * 2;
     const wrapper = `(function() {
       function safeVal(v) {
         try { return JSON.stringify(v); } catch(e) { return JSON.stringify(String(v)); }
@@ -197,7 +204,7 @@ export class CDPClient {
     const initResult = await this.sendWithTimeout('Runtime.evaluate', {
       expression: wrapper,
       returnByValue: true,
-    }, CDP_TIMEOUT_MS) as { exceptionDetails?: { text?: string; exception?: { description?: string } } };
+    }, timeout) as { exceptionDetails?: { text?: string; exception?: { description?: string } } };
 
     if (initResult?.exceptionDetails) {
       return {
@@ -207,9 +214,9 @@ export class CDPClient {
       };
     }
 
-    // B45 fix: Use absolute deadline to guarantee total wall-clock stays within CDP_TIMEOUT_MS.
+    // B45 fix: Use absolute deadline to guarantee total wall-clock stays within timeout.
     // Each poll gets only the remaining time (min 500ms) to avoid overshooting.
-    const deadline = Date.now() + CDP_TIMEOUT_MS;
+    const deadline = Date.now() + timeout;
     while (Date.now() < deadline) {
       const remaining = deadline - Date.now();
       if (remaining < 500) break;
@@ -241,11 +248,11 @@ export class CDPClient {
       expression: `delete globalThis['${slot}']`,
       returnByValue: true,
     }, 1000).catch(() => {});
-    return { error: 'Promise did not resolve within ' + CDP_TIMEOUT_MS + 'ms' };
+    return { error: 'Promise did not resolve within ' + timeout + 'ms' };
   }
 
   async send(method: string, params?: unknown): Promise<unknown> {
-    return this.sendWithTimeout(method, params, timeoutForMethod(method));
+    return this.sendWithTimeout(method, params, timeoutForMethod(method, this.effectivePlatform));
   }
 
   private handleMessage(data: WebSocket.RawData): void {
@@ -258,7 +265,7 @@ export class CDPClient {
 
   private async setup(): Promise<void> {
     const result = await performSetup({
-      send: (method, params, ms) => this.sendWithTimeout(method, params, ms ?? timeoutForMethod(method)),
+      send: (method, params, ms) => this.sendWithTimeout(method, params, ms ?? timeoutForMethod(method, this.effectivePlatform)),
       evaluate: (expr) => this.evaluate(expr),
       port: this._port,
       connectedTarget: this._connectedTarget,
@@ -281,7 +288,7 @@ export class CDPClient {
     wireEventHandlers(
       this.eventHandlers,
       { console: this._consoleBuffer, network: this._networkBuffer, log: this._logBuffer, scripts: this._scripts },
-      (method, params, ms) => this.sendWithTimeout(method, params, ms ?? timeoutForMethod(method)),
+      (method, params, ms) => this.sendWithTimeout(method, params, ms ?? timeoutForMethod(method, this.effectivePlatform)),
       () => this._isPaused,
       (v) => { this._isPaused = v; },
     );