@deeeed/metamask-harness 0.7.5 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.9.0 - 2026-07-07
+
+### Added
+- **`status` auto-probes live app state per device** — the `yarn a:status` successor. Static info prints instantly; within a strict 2s window each device line is enriched with `screen=` (active route via the `__AGENTIC__` bridge, Route objects normalised), `wallet=locked|unlocked|onboarding`, `account=<label> (0x1234…abcd)` and `fixture=READY|missing`. `--fast` skips all probes (guaranteed-instant for scripts); `--json` carries the enriched `devices[]` in one envelope. All RN targets attached to the checkout's Metro are probed and matched per device (exact id → exact name → platform-uniqueness → leftover 1:1), so android + ios side by side on one Metro both report. Honest degradation: `no-bridge` (nothing matched/answering) vs `bridge-absent` (target attached but the installed build predates `__AGENTIC__`, rendered with a rebuild hint) — surfacing pre-bridge builds required the target discovery probe to become three-state (agentic/responsive/unreachable) instead of silently dropping them.
+- **Every action now carries self-discovery metadata.** `action_metadata` (description + example recipe node, derived from the real handler implementations) covers all official and custom actions across the mobile, extension and core manifests — previously `app.status`, `cdp.target` and all 16 `metamask.wallet.*`/`metamask.perps.*` actions were bare names to agents. A new contract guard enforces coverage (including example structure: `node.action` must match), and locks mobile ↔ extension action-set parity with an explicit platform-only allowlist.
+
+## 0.8.0 - 2026-07-07
+
+### Added
+- **`run <name>` — the recipe positional resolves packaged-library recipe names.** An existing file path (absolute or cwd-relative) wins; otherwise the arg is a library recipe name, adapter-scoped first (`run smoke` on mobile → `smoke.mobile.recipe.json`), then adapterless (`run perps-lifecycle`), then the exact library filename. A miss teaches `RECIPE_NOT_FOUND` naming the library recipes available for the adapter — no more `$LIB`-style path prefixes in docs or demo scripts. A directory shadowing a library name never wins, and path-shaped args (containing a separator) never fall through to the library.
+- **`--device <udid|serial|name>` — first-class mobile device targeting on `run`, `call`, and `doctor`.** Resolves against connected devices (adb + booted simulators; exact id first, then exact name with an ambiguity teaching error) and sets the same env `launch --device` does. Mobile `run`/`call` **without** `--device` while more than one targetable device is connected (across android + ios; android state `device`, iOS `Booted`) fail fast listing the devices and the `--device` hint, so a recipe never lands on the wrong device silently. `run --plan`/`--list` are exempt; extension/core teach. Errors honor `--json` with structured envelopes.
+- **`status` gains `devices[]`** (additive): `{platform, id, name, state, selected}` for connected android devices and booted iOS simulators on mobile checkouts — the `yarn a:status` successor; `selected` reflects the current env pinning.
+
 ## 0.7.5 - 2026-07-07
 
 ### Fixed

package/adapters/mobile/bridge-runtime/cdp-bridge.cjs

@@ -173,10 +173,11 @@ const COMMANDS = {
 
   async status(client, _args, { deviceName, platform } = {}) {
     const expr = `(function() {
+      var agenticPresent = typeof globalThis.__AGENTIC__ !== 'undefined';
       var route = globalThis.__AGENTIC__?.getRoute() || null;
       var account = null;
       try { account = globalThis.__AGENTIC__?.getSelectedAccount() || null; } catch(e) {}
-      return { route: route, account: account };
+      return { route: route, account: account, agenticPresent: agenticPresent };
     })()`;
     const snapshot = await cdpEval(client, expr);
     return { ...snapshot, deviceName: deviceName || '', platform: platform || '' };
@@ -658,7 +659,9 @@ Environment:
         const result = await handler(client, args.slice(1), { deviceName: target.deviceName, platform });
         results.push(result);
       } catch {
-        // Target not responsive — skip
+        // Recovery is correct: status probes every target advisory; an
+        // unresponsive one degrades to absent-from-the-listing rather than
+        // failing the whole multi-target command.
       } finally {
         if (client) client.close();
       }

package/adapters/mobile/bridge-runtime/lib/target-discovery.cjs

@@ -48,6 +48,18 @@ async function fetchJSON(url) {
  * Returns true if __AGENTIC__ is installed, false otherwise.
  */
 async function probeTarget(wsUrl) {
+  return (await probeTargetDetailed(wsUrl)) === 'agentic';
+}
+
+/**
+ * Three-state probe so callers can tell a pre-__AGENTIC__ build apart from a
+ * dead target:
+ *   'agentic'     — JS runtime answered and __AGENTIC__ is installed.
+ *   'responsive'  — the target evaluated JS but has no __AGENTIC__ (an app build
+ *                   that predates the bridge, or a non-runtime page).
+ *   'unreachable' — connect/eval failed.
+ */
+async function probeTargetDetailed(wsUrl) {
   try {
     const client = await createWSClient(wsUrl, 3000);
     try {
@@ -56,13 +68,13 @@ async function probeTarget(wsUrl) {
         returnByValue: true,
         awaitPromise: false,
       });
-      return result?.result?.value === 'object';
+      return result?.result?.value === 'object' ? 'agentic' : 'responsive';
     } finally {
       client.close();
     }
   } catch {
-    // Connection failed — target is not the right one
-    return false;
+    // Connection failed — target is not usable at all
+    return 'unreachable';
   }
 }
 
@@ -186,18 +198,32 @@ async function discoverAllTargets(port) {
     return bPage - aPage;
   });
 
-  // Group by deviceName, probe each to find the JS runtime target
-  const seen = new Set();
-  const results = [];
+  // Group by deviceName, probe each to find the JS runtime target. Prefer the
+  // device's __AGENTIC__-bearing target; when a device has none, keep its first
+  // RESPONSIVE candidate (candidates are sorted JS-runtime-first) so a build
+  // that predates the bridge still surfaces — the status consumer reports it as
+  // bridge-absent instead of the device silently vanishing from discovery.
+  // Known ambiguity: when a device's JS runtime is attached-but-busy while its
+  // native C++ Hermes page answers, that page is also 'responsive' (no
+  // __AGENTIC__ in the native context), so the device reports bridge-absent even
+  // though the app build may carry the bridge. Low probability, and the degraded
+  // report is informative rather than harmful.
+  const agenticByDevice = new Map();
+  const responsiveByDevice = new Map();
   for (const candidate of candidates) {
     const device = candidate.deviceName || candidate.id || candidate.webSocketDebuggerUrl;
-    if (seen.has(device)) continue;
-    const hasAgentic = await probeTarget(candidate.webSocketDebuggerUrl);
-    if (hasAgentic) {
-      seen.add(device);
-      results.push({ wsUrl: candidate.webSocketDebuggerUrl, deviceName: device });
+    if (agenticByDevice.has(device)) continue;
+    const state = await probeTargetDetailed(candidate.webSocketDebuggerUrl);
+    if (state === 'agentic') {
+      agenticByDevice.set(device, { wsUrl: candidate.webSocketDebuggerUrl, deviceName: device });
+    } else if (state === 'responsive' && !responsiveByDevice.has(device)) {
+      responsiveByDevice.set(device, { wsUrl: candidate.webSocketDebuggerUrl, deviceName: device });
     }
   }
+  const results = [...agenticByDevice.values()];
+  for (const [device, entry] of responsiveByDevice) {
+    if (!agenticByDevice.has(device)) results.push(entry);
+  }
   return results;
 }
 

package/dist/cli-commands.js

@@ -7,7 +7,7 @@ const SPEC = {
     { name: "help", aliases: ["-h", "--help"], desc: "Show usage" }
   ],
   shared: [
-    { name: "status", aliases: ["health", "home"], desc: "Home status + next commands", flags: ["--json"] },
+    { name: "status", aliases: ["health", "home"], desc: "Home status + next commands", flags: ["--json", "--fast"] },
     { name: "ports", desc: "Slot ports and runtime paths", flags: ["--json"] },
     { name: "up", desc: "Decide + run minimum work to reach ready", flags: ["--json", "--dry-run"] },
     { name: "sync", desc: "Refresh harness + canonicalize wallet fixture", flags: ["--json"] },
@@ -15,8 +15,8 @@ const SPEC = {
     { name: "debug", aliases: ["devtools", "inspect"], desc: "Open DevTools UI", flags: ["--json", "--no-open"] },
     { name: "fixtures", desc: "Manage the canonical wallet fixture (sync/set/generate)", args: ["sync", "set", "generate"], flags: ["--fixture", "--out", "--adapter", "--target", "--json"] },
     { name: "actions", desc: "List runnable recipe actions", flags: ["--json"] },
-    { name: "doctor", desc: "Check harness/orchestration health", flags: ["--json", "--target", "--adapter", "--runtime-dir", "--expect-live", "--cdp-port"] },
-    { name: "run", desc: "Execute a proof recipe", args: ["recipe.json"], flags: ["--list"] },
+    { name: "doctor", desc: "Check harness/orchestration health", flags: ["--json", "--target", "--adapter", "--runtime-dir", "--expect-live", "--cdp-port", "--device"] },
+    { name: "run", desc: "Execute a proof recipe (path or library name, e.g. run smoke)", args: ["recipe.json|name"], flags: ["--list", "--device"] },
     { name: "recipe-quality", desc: "Build the recipe-quality artifact from compact JSON", args: ["build"], flags: ["--input", "--output", "--json"] },
     { name: "interactive", aliases: ["menu"], desc: "Interactive command menu" },
     { name: "prepare", desc: "Install harness (+ optional validate)", flags: ["--target", "--runtime-dir", "--json"] },

package/dist/cli.js

@@ -18,6 +18,7 @@ import { handleLogs } from "./commands/logs.js";
 import { handleDebug } from "./commands/debug.js";
 import { handleFixtures } from "./commands/fixtures.js";
 import { handleRecipeQuality } from "./commands/recipe-quality.js";
+import { handleStatus } from "./commands/status.js";
 import { parseArgs, targetPath } from "./commands/parse-args.js";
 import { runOneNode } from "./commands/run-engine.js";
 const COMMANDS = {
@@ -92,6 +93,9 @@ async function main(argv) {
     usage();
     return command ? 0 : 2;
   }
+  if (command === "status" || command === "health" || command === "home") {
+    return handleStatus(parseArgs(argv.slice(1), "status"));
+  }
   if (command === "flows") return handleFlows(argv.slice(1));
   if (command === "call") return handleCall(argv.slice(1));
   if (command === "completion-candidates") return handleCompletionCandidates(argv.slice(1));

package/dist/commands/call.js

@@ -15,6 +15,7 @@ import {
   usageError
 } from "./parse-args.js";
 import { handleListExecutables } from "./list-executables.js";
+import { applyDeviceTargeting } from "./device-target.js";
 import {
   emitHealViolation,
   executeWithHealBounds,
@@ -57,6 +58,12 @@ async function handleCall(argv) {
     return EXIT.usage;
   }
   const { adapter, target } = resolveAdapter(options);
+  const dtResult = applyDeviceTargeting("call", adapter, options, { gate: true, rerun: "" });
+  if ("code" in dtResult) {
+    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "call", adapter, error: { code: dtResult.code, message: dtResult.message } }, null, 2));
+    else console.error(`\u2717 call: ${dtResult.message}`);
+    return EXIT.usage;
+  }
   if (recipeRunning(target)) {
     const msg = "a recipe is currently running \u2014 refusing to start while another recipe executes.";
     if (json) {

package/dist/commands/device-target.js

@@ -0,0 +1,105 @@
+import { listConnectedDevices } from "../devices.js";
+import { optionString } from "./parse-args.js";
+function setAndroidDeviceEnv(id) {
+  process.env.ADB_SERIAL = id;
+  process.env.ANDROID_SERIAL = id;
+  process.env.ANDROID_DEVICE = id;
+}
+function setIosDeviceEnv(id) {
+  process.env.IOS_SIMULATOR = id;
+}
+function formatConnectedDevices(devices) {
+  return devices.map((d) => `    - ${d.id}${d.name ? ` (${d.name})` : ""} [${d.state}] ${d.platform}`).join("\n");
+}
+function renderDeviceList(devices, out) {
+  console.log(
+    `${out("label", "devices:")} ${devices.length === 0 ? out("dim", "none connected (adb devices / booted iOS simulators)") : `${devices.length} connected`}`
+  );
+  for (const device of devices) {
+    const marker = device.selected ? out("ok", "\u25CF selected") : out("dim", "\u25CB");
+    console.log(
+      `  ${marker} ${device.id}${device.name ? ` (${device.name})` : ""} ${out("dim", `[${device.state}] ${device.platform}`)}`
+    );
+  }
+}
+function deviceSelected(device) {
+  if (device.platform === "android") {
+    return process.env.ADB_SERIAL === device.id || process.env.ANDROID_SERIAL === device.id;
+  }
+  return process.env.IOS_SIMULATOR === device.id;
+}
+function isTargetable(device) {
+  if (device.platform === "android") return device.state === "device";
+  if (device.platform === "ios") return device.state === "Booted";
+  return false;
+}
+function applyDeviceTargeting(command, adapter, options, opts) {
+  const device = optionString(options, "device");
+  if (adapter !== "mobile") {
+    if (device !== void 0) {
+      return {
+        ok: false,
+        code: "DEVICE_WRONG_ADAPTER",
+        message: `--device is only supported on the mobile adapter (the ${adapter} adapter has no device to target).
+  Drop --device, or run this ${command} inside a metamask-mobile checkout.`
+      };
+    }
+    return { ok: true };
+  }
+  if (device !== void 0) {
+    const connected2 = listConnectedDevices();
+    const androidById = connected2.find((d) => d.platform === "android" && d.id === device);
+    if (androidById) {
+      setAndroidDeviceEnv(device);
+      return { ok: true };
+    }
+    const iosById = connected2.find((d) => d.platform === "ios" && d.id === device);
+    if (iosById) {
+      setIosDeviceEnv(device);
+      return { ok: true };
+    }
+    const byName = connected2.filter((d) => d.name === device);
+    if (byName.length === 1) {
+      const matched = byName[0];
+      if (matched.platform === "android") setAndroidDeviceEnv(matched.id);
+      else setIosDeviceEnv(matched.id);
+      return { ok: true };
+    }
+    if (byName.length > 1) {
+      return {
+        ok: false,
+        code: "DEVICE_NAME_AMBIGUOUS",
+        message: `device name '${device}' is ambiguous; use the id:
+` + byName.map((d) => `    - ${d.id}${d.name ? ` (${d.name})` : ""} [${d.state}] ${d.platform}`).join("\n")
+      };
+    }
+    return {
+      ok: false,
+      code: "DEVICE_NOT_FOUND",
+      message: `--device ${device} did not match any connected device.
+` + (connected2.length > 0 ? `  Connected devices:
+${formatConnectedDevices(connected2)}` : `  No devices are currently connected (adb devices / booted iOS simulators).`)
+    };
+  }
+  if (!opts.gate) return { ok: true };
+  const connected = listConnectedDevices();
+  const targetable = connected.filter(isTargetable);
+  if (targetable.length > 1) {
+    return {
+      ok: false,
+      code: "DEVICE_AMBIGUOUS",
+      message: `${targetable.length} mobile devices available \u2014 ${command} needs exactly one target.
+  Connected devices:
+${formatConnectedDevices(connected)}
+  Add --device <id> to disambiguate, e.g.:${targetable.map((d) => `
+    --device ${d.id}`).join("")}`
+    };
+  }
+  return { ok: true };
+}
+export {
+  applyDeviceTargeting,
+  deviceSelected,
+  formatConnectedDevices,
+  renderDeviceList
+};

package/dist/commands/doctor.js

@@ -7,6 +7,8 @@ import { assertAdapter, runnerDir } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
 import { loadActionManifest, validateManifest } from "../manifest.js";
 import { ensureOverlay, newHealState, recipeRunning } from "../heal-bounds.js";
+import { listConnectedDevices } from "../devices.js";
+import { applyDeviceTargeting, deviceSelected, renderDeviceList } from "./device-target.js";
 import { ADAPTER_DETECT_NEXT, EXIT, usageOut } from "./shared.js";
 import {
   actionManifestPathOption,
@@ -39,6 +41,12 @@ async function handleDoctor({ options }) {
     return usageOut(json, "doctor", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
   }
   assertAdapter(adapter);
+  const dtResult = applyDeviceTargeting("doctor", adapter, options, { gate: false, rerun: "" });
+  if ("code" in dtResult) {
+    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "doctor", adapter, target, error: { code: dtResult.code, message: dtResult.message } }, null, 2));
+    else console.error(`\u2717 doctor: ${dtResult.message}`);
+    return EXIT.usage;
+  }
   const actionManifestPath = actionManifestPathOption(options, adapter);
   const manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
   const manifestValidation = await validateManifest(manifest);
@@ -60,8 +68,9 @@ async function handleDoctor({ options }) {
   }
   const orphanMetros = adapter === "mobile" ? detectOrphanMetros(target, process.env.WATCHER_PORT) : [];
   const capture = captureHelperHealth();
-  if (expectLive) return emitExpectLive(adapter, target, runtime, result, orphanMetros, capture, json);
-  if (json) console.log(JSON.stringify({ ...result, runtime, orphanMetros, capture }, null, 2));
+  const devices = adapter === "mobile" ? enumerateSelectedDevices() : [];
+  if (expectLive) return emitExpectLive(adapter, target, runtime, result, orphanMetros, capture, devices, json);
+  if (json) console.log(JSON.stringify({ ...result, runtime, orphanMetros, capture, devices }, null, 2));
   else {
     const out = (style, text) => color(style, text, { stream: process.stdout });
     const stateStyle = (value, good) => value === good ? "ok" : "warn";
@@ -91,13 +100,17 @@ async function handleDoctor({ options }) {
         console.log(`  ${out("dim", "Next: grant Screen Recording (System Settings \u2192 Privacy & Security \u2192 Screen Recording), or run: capture-helper doctor --open-permissions")}`);
       }
     }
+    if (adapter === "mobile") renderDeviceList(devices, out);
   }
   return result.status === "pass" ? 0 : 1;
 }
-function emitExpectLive(adapter, target, runtime, result, orphanMetros, capture, json) {
+function enumerateSelectedDevices() {
+  return listConnectedDevices().map((device) => ({ ...device, selected: deviceSelected(device) }));
+}
+function emitExpectLive(adapter, target, runtime, result, orphanMetros, capture, devices, json) {
   const live = runtime?.decision === "ready";
   if (json) {
-    console.log(JSON.stringify({ ...result, runtime, orphanMetros, capture }, null, 2));
+    console.log(JSON.stringify({ ...result, runtime, orphanMetros, capture, devices }, null, 2));
     return live ? EXIT.ok : EXIT.runtime;
   }
   const out = (style, text) => color(style, text, { stream: process.stdout });

package/dist/commands/parse-args.js

@@ -29,6 +29,7 @@ function parseArgs(argv, command) {
     "force",
     "resolveOnly",
     "expectLive",
+    "fast",
     "help"
   ]);
   for (let i = 0; i < argv.length; i += 1) {

package/dist/commands/run-engine.js

@@ -14,6 +14,7 @@ import { getAdapterSurface } from "../adapters/surface.js";
 import {
   importRecipeHarness,
   importRecipeProtocol,
+  recipePath,
   runnerDir
 } from "../paths.js";
 import { captureHelperSupportsRecordSessionSnapshots } from "../recording-target.js";
@@ -131,11 +132,47 @@ async function validateRecipeAdapterAware(recipe, manifest, librarySources) {
   const warnings = findings.length - errors;
   return { status: errors > 0 ? "invalid" : "valid", findings, summary: { errors, warnings } };
 }
+function isRecipeFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveRunRecipeArg(recipeArg, adapter) {
+  const direct = path.resolve(recipeArg);
+  if (isRecipeFile(direct)) return { recipeFile: direct };
+  if (!recipeArg.includes("/") && !recipeArg.includes(path.sep)) {
+    for (const name of [`${recipeArg}.${adapter}.recipe.json`, `${recipeArg}.recipe.json`, recipeArg]) {
+      const file = recipePath(name);
+      if (isRecipeFile(file)) return { recipeFile: file };
+    }
+  }
+  const names = libraryRecipeNames(adapter);
+  return {
+    notFound: `recipe not found: ${recipeArg} \u2014 not a file, and no packaged library recipe matched. ` + (names.length > 0 ? `Library recipes for ${adapter}: ${names.join(", ")} (mm-harness run <name>).` : `The packaged library has no recipes for ${adapter}.`)
+  };
+}
+function libraryRecipeNames(adapter) {
+  let entries;
+  try {
+    entries = fs.readdirSync(recipePath(""));
+  } catch {
+    return [];
+  }
+  const scopes = ["mobile", "extension", "core"];
+  const names = entries.filter((f) => f.endsWith(".recipe.json")).map((f) => f.slice(0, -".recipe.json".length)).filter((n) => {
+    const scope = n.split(".").pop() ?? "";
+    return !scopes.includes(scope) || scope === adapter;
+  }).map((n) => n.endsWith(`.${adapter}`) ? n.slice(0, -(adapter.length + 1)) : n);
+  return [...new Set(names)].sort();
+}
 async function validateRunRecipeStatic(recipeArg, adapter, options) {
-  const recipeFile = path.resolve(recipeArg);
+  const resolved = resolveRunRecipeArg(recipeArg, adapter);
+  const recipeFile = "recipeFile" in resolved ? resolved.recipeFile : path.resolve(recipeArg);
   const empty = { recipe: void 0, recipeFile, findings: [], errorCount: 0, manifestOk: false, schemaValid: false };
-  if (!fs.existsSync(recipeFile)) {
-    return { ...empty, usageError: { code: "RECIPE_NOT_FOUND", message: `recipe not found: ${recipeFile}` } };
+  if ("notFound" in resolved) {
+    return { ...empty, usageError: { code: "RECIPE_NOT_FOUND", message: resolved.notFound } };
   }
   let recipe;
   try {
@@ -333,6 +370,7 @@ export {
   executeWithHealBounds,
   prepareHeal,
   resolveMetaMaskLibrarySources,
+  resolveRunRecipeArg,
   runOneNode,
   runRecipe,
   synthesizeOneNodeRecipe,

package/dist/commands/run.js

@@ -20,6 +20,7 @@ import {
   validateRunRecipeStatic
 } from "./run-engine.js";
 import { handleListExecutables } from "./list-executables.js";
+import { applyDeviceTargeting } from "./device-target.js";
 async function handleRun({ positional, options }) {
   if (optionFlag(options, "list")) return handleListExecutables("run", options);
   const targetRecipe = positional[0];
@@ -27,6 +28,10 @@ async function handleRun({ positional, options }) {
   if (optionFlag(options, "plan")) return handleRunPlan(targetRecipe, options);
   const { adapter, target } = resolveAdapter(options);
   const json = optionFlag(options, "json");
+  const dtResult = applyDeviceTargeting("run", adapter, options, { gate: true, rerun: "" });
+  if ("code" in dtResult) {
+    return emitRunUsageError(json, adapter, targetRecipe, dtResult.code, dtResult.message);
+  }
   const artifactsDir = requiredOption(options, "artifactsDir", "run requires --artifacts-dir <dir>.");
   const prepared = await prepareHeal(adapter, target, options, json);
   if (typeof prepared === "number") return prepared;
@@ -45,7 +50,9 @@ async function handleRun({ positional, options }) {
     stdoutIsMachineContract: json
   };
   const { result, violation } = await executeWithHealBounds(
-    () => runRecipe(adapter, targetRecipe, artifactsDir, target, optionString(options, "actionManifest"), runtimeOptions),
+    // validated.recipeFile, not the raw arg: the arg may be a library recipe NAME
+    // that only the resolver knows how to turn into a file.
+    () => runRecipe(adapter, validated.recipeFile, artifactsDir, target, optionString(options, "actionManifest"), runtimeOptions),
     adapter,
     target,
     heal,

package/dist/commands/status-probe.js

@@ -0,0 +1,167 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fixtureSummary } from "../doctor.js";
+import { runnerDir } from "../paths.js";
+const PROBE_TIMEOUT_MS = 2e3;
+function bridgeScriptPath() {
+  return process.env.METAMASK_RECIPE_MOBILE_BRIDGE_SCRIPT ?? path.join(runnerDir, "adapters", "mobile", "bridge-runtime", "cdp-bridge.cjs");
+}
+function truncateAddress(address) {
+  if (!address || address.length <= 10) return address;
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+function routeToString(route) {
+  if (typeof route === "string") return route;
+  if (route && typeof route === "object" && "name" in route) {
+    const n = route.name;
+    if (typeof n === "string") return n;
+  }
+  return void 0;
+}
+function deriveWalletState(account, route) {
+  const routeStr = (routeToString(route) ?? "").toLowerCase();
+  if (routeStr.includes("onboard")) return "onboarding";
+  if (account !== null && account !== void 0 && typeof account === "object") return "unlocked";
+  return "locked";
+}
+function parseBridgeEntries(raw) {
+  if (!raw || typeof raw !== "object") return [];
+  const items = Array.isArray(raw) ? raw : [raw];
+  return items.filter((e) => Boolean(e && typeof e === "object" && !Array.isArray(e))).map((e) => ({
+    route: e.route,
+    account: e.account,
+    deviceName: typeof e.deviceName === "string" ? e.deviceName : "",
+    platform: typeof e.platform === "string" ? e.platform : "",
+    // agenticPresent is only set when the bridge explicitly sends it (false = absent).
+    // Omitted by older bridge versions → leave undefined so caller treats as present.
+    ...typeof e.agenticPresent === "boolean" ? { agenticPresent: e.agenticPresent } : {}
+  }));
+}
+function matchBridgeEntry(device, entries) {
+  const byId = entries.find((e) => e.deviceName === device.id);
+  if (byId) return byId;
+  if (device.name) {
+    const byName = entries.find((e) => e.deviceName === device.name);
+    if (byName) return byName;
+  }
+  const platformEntries = entries.filter((e) => e.platform === device.platform);
+  if (platformEntries.length === 1) return platformEntries[0];
+  return null;
+}
+function probeMobileBridge(target) {
+  const script = bridgeScriptPath();
+  if (!fs.existsSync(script)) {
+    return Promise.resolve({ ok: false, liveState: "no-bridge" });
+  }
+  return new Promise((resolve) => {
+    const env = {
+      ...process.env,
+      APP_ROOT: target,
+      CDP_TIMEOUT: String(PROBE_TIMEOUT_MS)
+    };
+    let settled = false;
+    let stdout = "";
+    const child = spawn(process.execPath, [script, "status"], {
+      cwd: target,
+      env,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill("SIGTERM");
+      const killTimer = setTimeout(() => child.kill("SIGKILL"), 500);
+      child.once("close", () => clearTimeout(killTimer));
+      resolve({ ok: false, liveState: "no-bridge" });
+    }, PROBE_TIMEOUT_MS);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code !== 0) {
+        resolve({ ok: false, liveState: "no-bridge" });
+        return;
+      }
+      try {
+        const raw = JSON.parse(stdout);
+        const entries = parseBridgeEntries(raw);
+        if (entries.length === 0) {
+          resolve({ ok: false, liveState: "no-bridge" });
+          return;
+        }
+        resolve({ ok: true, entries });
+      } catch {
+        resolve({ ok: false, liveState: "no-bridge" });
+      }
+    });
+    child.on("error", () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ ok: false, liveState: "no-bridge" });
+    });
+  });
+}
+function resolveFixtureStatus(target) {
+  const summary = fixtureSummary(target);
+  return summary.status === "ready" ? "READY" : "missing";
+}
+async function probeMobileLiveState(target, devices) {
+  const result = /* @__PURE__ */ new Map();
+  if (devices.length === 0) return result;
+  const fixtureStatus = resolveFixtureStatus(target);
+  const probeResult = await probeMobileBridge(target);
+  if (!probeResult.ok) {
+    for (const device of devices) result.set(device.id, { fixtureStatus, liveState: "no-bridge" });
+    return result;
+  }
+  const { entries } = probeResult;
+  const matched = /* @__PURE__ */ new Map();
+  const usedEntries = /* @__PURE__ */ new Set();
+  for (const device of devices) {
+    const entry = matchBridgeEntry(device, entries.filter((e) => !usedEntries.has(e)));
+    if (entry) {
+      matched.set(device.id, entry);
+      usedEntries.add(entry);
+    }
+  }
+  const leftoverEntries = entries.filter(
+    (e) => !usedEntries.has(e) && e.platform === "" && e.agenticPresent === false
+  );
+  const unmatchedDevices = devices.filter((d) => !matched.has(d.id));
+  if (leftoverEntries.length === 1 && unmatchedDevices.length === 1) {
+    matched.set(unmatchedDevices[0].id, leftoverEntries[0]);
+  }
+  for (const device of devices) {
+    const entry = matched.get(device.id);
+    if (!entry) {
+      result.set(device.id, { fixtureStatus, liveState: "no-bridge" });
+      continue;
+    }
+    if (entry.agenticPresent === false) {
+      result.set(device.id, { fixtureStatus, liveState: "bridge-absent" });
+      continue;
+    }
+    const account = entry.account;
+    const walletState = deriveWalletState(account, entry.route);
+    const currentScreen = routeToString(entry.route);
+    const addrRaw = typeof account?.address === "string" ? account.address : void 0;
+    const labelRaw = typeof account?.name === "string" ? account.name : void 0;
+    const liveEntry = {
+      fixtureStatus,
+      walletState,
+      ...currentScreen !== void 0 ? { currentScreen } : {},
+      ...labelRaw !== void 0 && addrRaw !== void 0 ? { selectedAccount: { label: labelRaw, address: truncateAddress(addrRaw) } } : {}
+    };
+    result.set(device.id, liveEntry);
+  }
+  return result;
+}
+export {
+  probeMobileLiveState,
+  resolveFixtureStatus
+};