@deeeed/metamask-harness 0.56.0 → 0.58.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## Unreleased
 
+## 0.58.0 - 2026-09-18
+
+### Changed
+
+- Pins `@farmslot/agent-runtime` 0.12.0, whose `mark` records step names through the protocol's `checklistStepName`, so SIGNAL.json events and `status --watch` name a step identically.
+- Mobile `verify` is runner-owned TypeScript: `adapters/mobile/verify.sh` (557 lines, with node heredocs assembling `summary.json`) is now `src/adapters/mobile/verify.ts`, run in-process by `mm-harness verify --adapter mobile`. Same flags, env, exit codes, check names and artifacts (`summary.json`, `artifact-manifest.json`, `logs/`, smoke recipes, `runner-live-smoke/`); a live run against the same checkout produced a byte-identical normalised summary. `install` no longer copies a `scripts/verify.sh` into the checkout and dispatch no longer prefers one, so an older overlay cannot shadow the current runner's verify; the mobile overlay's `scripts/` tree is gone and its manifest advertises `runtimeHelpers: {}`, like Core. Extension verify is unchanged.
+- The execution-provenance record is indexed into `artifact-manifest.json` through the same hardened manifest writer every other artifact uses (`indexArtifactManifest`), instead of a private copy that skipped a missing or unreadable manifest without a word. A manifest the run said it wrote but cannot be read is now the error it is.
+
+## 0.57.0 - 2026-09-18
+
+### Changed
+
+- The task and checklist rules the harness shares with Farmslot now come from the Farmslot packages instead of private copies, against `@farmslot/protocol` 0.29.0 and `@farmslot/agent-runtime` 0.11.0 (`@farmslot/recipe-harness` 0.17.0, `@farmslot/expo-recipe` 0.10.0 follow the protocol pin). Which signal statuses are terminal: `isTerminalWorkerSignalStatus`, so `mark` now also protects a `failed` or `done` verdict from a later non-terminal mark, and `status --watch` no longer treats an unknown status as finished. Which box is step N: `enumerateChecklistCheckboxes`, so the `check diff` gate reads the row `mark N` ticks even when an upstream checklist sits under `## Rules` or inside `<details>`. Per-row durations: `deriveChecklistStepDurations`, the same numbers Command Center shows (a task without a recorded start now shows its first row as `0:00` rather than blank). Step names: `checklistStepName`. Which task a checkout is on: `latestTaskDir`, the task written to last by signal or by checklist. File names come from the protocol constants.
+- `status --watch` reads the harness identity from the readiness record (`sandbox.json`) `prepare` writes on every surface; the `artifacts/harness-provenance.json` it looked for is the recipe-cook skill's locked-harness receipt and exists on skill runs only, so the `harness x.y.z` line was blank on every dispatched run.
+
+### Fixed
+
+- `status --watch` no longer reports `no ongoing task detected` while an agent is busy on a long step. The view judged activity only by task-dir writes (`SIGNAL.json`, row marks) and called the task silent after ten minutes, so an investigation step that ran `mm-harness call` every few seconds without ticking a row read as abandoned. The command journal (`temp/recipe/runtime/last-command.json`) now counts as activity, and the view shows it: `last command call ui.navigate · pass · 0:12 ago`. Only the command name and a leading positional argument reach the view; option values never do, and the journal is read through the same hardened reader the harness uses (symlinks and malformed records mean no command line, never a dead watch). A journal older than the task's start belongs to an earlier task and does not count. Piped output logs `command call ui.navigate pass` when the journal moves. `status` itself is not journaled, so watching a checkout never counts as its own activity.
+- `status --watch` renders a Farm checklist the way the Farmslot run view does. Steps, numbers and phases now come from `enumerateChecklistCheckboxes` in `@farmslot/protocol`, the same enumeration the gateway progress view and the `mark` helper use, instead of a private row pattern that rejected Farm's `- [x] **3. Resolve branch:**` rows and only knew `##` headings. A dispatched run therefore showed no rows at all; now it shows `Setup 5/5`, `Reproduce (BEFORE any code changes) 3/9`, … with the bold title as each step's name.
+
 ## 0.56.0 - 2026-09-18
 
 ### Changed

package/adapters/manifest.json

@@ -140,9 +140,9 @@
     },
     {
       "id": "mobile/verify",
-      "entry": "adapters/mobile/verify.sh",
-      "kind": "bash",
-      "purpose": "Verify the mobile harness/runtime is present and healthy (no app launch).",
+      "entry": "src/adapters/mobile/verify.ts",
+      "kind": "module",
+      "purpose": "Verify the mobile harness/runtime is present and healthy (no app launch). Runner-owned: mm-harness verify runs it in-process.",
       "inputs": "--target --artifacts-dir --static-only --platform ios|android --preflight-mode --no-auto-start",
       "outputs": "verify report + evidence; exit 0/1/2"
     },

package/adapters/mobile/inject.sh

@@ -34,7 +34,7 @@ fi
 HARNESS_ROOT="$(harness_root)"
 HARNESS_REL="$HARNESS_ROOT/mobile"
 HARNESS_DIR="$(harness_dir "$TARGET" mobile)"
-for rel in "$HARNESS_REL" "$HARNESS_REL/runner" "$HARNESS_REL/scripts"; do
+for rel in "$HARNESS_REL" "$HARNESS_REL/runner"; do
   current="$TARGET"
   IFS='/' read -r -a parts <<< "$rel"
   for part in "${parts[@]}"; do
@@ -45,7 +45,7 @@ for rel in "$HARNESS_REL" "$HARNESS_REL/runner" "$HARNESS_REL/scripts"; do
 done
 
 rm -rf "$HARNESS_DIR/runner" "$HARNESS_DIR/scripts" "$HARNESS_DIR/bridge-runtime"
-mkdir -p "$HARNESS_DIR/runner/bin" "$HARNESS_DIR/runner/manifests" "$HARNESS_DIR/runner/recipes" "$HARNESS_DIR/scripts/lib"
+mkdir -p "$HARNESS_DIR/runner/bin" "$HARNESS_DIR/runner/manifests" "$HARNESS_DIR/runner/recipes"
 
 RUNNER_EXEC_Q="$(printf '%q' "$RUNNER_DIR/bin/mm-harness")"
 TARGET_Q="$(printf '%q' "$TARGET")"
@@ -76,10 +76,7 @@ cp "$RUNNER_DIR/library/manifests/extension.action-manifest.json" "$HARNESS_DIR/
 rsync -a --delete "$RUNNER_DIR/library/recipes/" "$HARNESS_DIR/runner/recipes/"
 rm -rf "$HARNESS_DIR/runner/flows"
 rm -f "$HARNESS_DIR/runner/library.json"
-cp "$RUNNER_DIR/adapters/mobile/verify.sh" "$HARNESS_DIR/scripts/verify.sh"
 cp -R "$RUNNER_DIR/adapters/mobile/bridge-runtime" "$HARNESS_DIR/bridge-runtime"
-cp "$RUNNER_DIR/adapters/shared/harness-path.sh" "$HARNESS_DIR/scripts/lib/harness-path.sh"
-cp "$RUNNER_DIR/adapters/shared/path-defaults.json" "$HARNESS_DIR/scripts/lib/path-defaults.json"
 chmod -R u+rwX,go+rX "$HARNESS_DIR"
 
 add_git_exclude() {
@@ -114,8 +111,8 @@ fs.writeFileSync(manifestPath, JSON.stringify({
   protocolVersion: 'v1',
   actionManifestPath: `${harnessRel}/action-manifest.json`,
   runnerEntrypoint: `${harnessRel}/runner/bin/mm-harness`,
-  runtimeHelpers: { verify: `${harnessRel}/scripts/verify.sh` },
-  harnessInstalledPaths: [`${harnessRel}/runner`, `${harnessRel}/scripts`, `${harnessRel}/bridge-runtime`, `${harnessRel}/action-manifest.json`],
+  runtimeHelpers: {},
+  harnessInstalledPaths: [`${harnessRel}/runner`, `${harnessRel}/bridge-runtime`, `${harnessRel}/action-manifest.json`],
   productOwnedPaths: ['app/dev-tools/AgenticService', 'app/core/NavigationService/NavigationService.ts'],
   cleanupCommand,
   productDiffExcludes: [`:(exclude)${harnessRoot}`],

package/dist/adapters/mobile/verify.js

@@ -0,0 +1,549 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { readRuntimeContextField } from "../../harness.js";
+import { recipeHarnessPath, recipeHarnessRoot, recipeRuntimeDir, runnerDir } from "../../paths.js";
+const USAGE = "Usage: mm-harness verify --adapter mobile -- [--target <metamask-mobile>] [--artifacts-dir <dir>] [--static-only] [--platform ios|android] [--preflight-mode fast|auto|default|rebuild-native|clean] [--no-auto-start]";
+const ENV_FILES = [".js.env", ".env", ".env.local"];
+const PREFLIGHT_MODES = ["fast", "auto", "default", "rebuild-native", "clean"];
+const AUTO_START_TRUE = ["1", "true", "TRUE", "True", "yes", "YES", "Yes", "on", "ON", "On"];
+const AUTO_START_FALSE = ["0", "false", "FALSE", "False", "no", "NO", "No", "off", "OFF", "Off", ""];
+const AUTO_START_REFUSAL = "Mobile auto-start is not allowed from product-local scripts. Start or prepare the app through the runner/slot runtime, then rerun verify with --no-auto-start.";
+const EVM_READINESS_EXPRESSION = "(async function(){try{var engine=globalThis.Engine;var controller=engine&&engine.context&&engine.context.NetworkController;if(!controller||typeof controller.getSelectedNetworkClient!=='function')throw new Error('NetworkController selected client is unavailable');var client=controller.getSelectedNetworkClient();if(!client||!client.provider||typeof client.provider.request!=='function')throw new Error('selected EVM provider is unavailable');var result=await client.provider.request({method:'eth_blockNumber'});if(typeof result!=='string'||!/^0x[0-9a-f]+$/i.test(result))throw new Error('eth_blockNumber returned an invalid result');return {ok:true,result:result};}catch(error){return {ok:false,error:error&&(error.message||String(error))};}})()";
+const STATUS_SMOKE_RECIPE = `{
+  "$schema": "https://farmslot.io/schemas/recipe-v1.schema.json",
+  "title": "Mobile runner status smoke",
+  "description": "Checks that the installed runner can read Mobile app status before live verification.",
+  "workflow": {
+    "entry": "status",
+    "nodes": {
+      "status": { "action": "app.status", "intent": "Read Mobile app status through the runner-owned bridge", "next": "done" },
+      "done": { "action": "end", "status": "pass" }
+    }
+  }
+}
+`;
+const LIVE_SMOKE_RECIPE = `{
+  "$schema": "https://farmslot.io/schemas/recipe-v1.schema.json",
+  "title": "Mobile v1 runner live bridge smoke",
+  "description": "Verifies the installed MetaMask runner can read the React Native debug bridge without mutating wallet state.",
+  "workflow": {
+    "entry": "status",
+    "nodes": {
+      "status": { "action": "app.status", "intent": "Read Mobile app status through the v1 runner", "next": "cdp-probe" },
+      "cdp-probe": { "action": "cdp.target", "intent": "Verify the React Native debug bridge target is reachable", "require_reachable": true, "timeout_ms": 60000, "cdp_timeout_ms": 60000, "next": "done" },
+      "done": { "action": "end", "status": "pass" }
+    }
+  }
+}
+`;
+function parseMobileVerifyArgs(argv, env = process.env) {
+  let target = process.cwd();
+  let artifactsDir;
+  let staticOnly = false;
+  let platform = env.RECIPE_HARNESS_PLATFORM || env.PLATFORM || "ios";
+  let preflightMode = env.RECIPE_HARNESS_MOBILE_PREFLIGHT_MODE || "fast";
+  let autoStart = env.RECIPE_HARNESS_MOBILE_AUTO_START ?? "false";
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    const needsValue = () => {
+      if (i + 1 >= argv.length) return void 0;
+      i += 1;
+      return argv[i];
+    };
+    switch (arg) {
+      case "--target": {
+        const value = needsValue();
+        if (value === void 0) return { kind: "error", message: "Missing value for --target", exitCode: 2 };
+        target = value;
+        break;
+      }
+      case "--artifacts-dir": {
+        const value = needsValue();
+        if (value === void 0) return { kind: "error", message: "Missing value for --artifacts-dir", exitCode: 2 };
+        artifactsDir = value;
+        break;
+      }
+      case "--static-only":
+        staticOnly = true;
+        break;
+      case "--platform": {
+        const value = needsValue();
+        if (value === void 0) return { kind: "error", message: "Missing value for --platform", exitCode: 2 };
+        platform = value;
+        break;
+      }
+      case "--preflight-mode": {
+        const value = needsValue();
+        if (value === void 0) return { kind: "error", message: "Missing value for --preflight-mode", exitCode: 2 };
+        preflightMode = value;
+        break;
+      }
+      case "--auto-start":
+        autoStart = "true";
+        break;
+      case "--no-auto-start":
+        autoStart = "false";
+        break;
+      case "-h":
+      case "--help":
+        return { kind: "help", usage: USAGE };
+      default:
+        return { kind: "error", message: `Unknown arg: ${arg}`, exitCode: 2 };
+    }
+  }
+  if (!PREFLIGHT_MODES.includes(preflightMode)) {
+    return { kind: "error", message: `Unknown --preflight-mode: ${preflightMode}`, exitCode: 2 };
+  }
+  if (platform !== "ios" && platform !== "android") {
+    return { kind: "error", message: `Unknown --platform: ${platform} (expected ios or android)`, exitCode: 2 };
+  }
+  if (!AUTO_START_TRUE.includes(autoStart) && !AUTO_START_FALSE.includes(autoStart)) {
+    return { kind: "error", message: `Unknown RECIPE_HARNESS_MOBILE_AUTO_START value: ${autoStart}`, exitCode: 2 };
+  }
+  return {
+    kind: "options",
+    options: {
+      target,
+      artifactsDir,
+      staticOnly,
+      platform,
+      preflightMode,
+      autoStart: AUTO_START_TRUE.includes(autoStart)
+    }
+  };
+}
+function isNumericWatcherPort(port) {
+  return port.length > 0 && /^[0-9]+$/u.test(port);
+}
+function classifyMobileRuntimeOwner(portHolder, startedByVerify, liveSmokeStatus) {
+  if (!portHolder) return "static-only";
+  if (startedByVerify) return "harness-owned";
+  if (!portHolder.listening) return "none";
+  return liveSmokeStatus === "pass" ? "compatible-external-or-harness" : "incompatible-external-or-stale";
+}
+function buildMobileVerifySummary(input) {
+  const liveRuntimeCheck = input.checks.find((check) => check.name === "runner v1 live bridge smoke");
+  const runtimeOwner = classifyMobileRuntimeOwner(input.portHolder, input.startedByVerify, liveRuntimeCheck?.status);
+  return {
+    adapter: "mobile",
+    status: input.status,
+    runtimeClassification: {
+      runtimeOwner,
+      recipeControllable: liveRuntimeCheck?.status === "pass",
+      startedByVerify: input.startedByVerify
+    },
+    cleanupOwnership: {
+      mayStop: input.startedByVerify,
+      reason: input.startedByVerify ? "verify launched the runtime through harness preflight" : "verify did not launch this runtime; do not stop human-owned or pre-existing processes automatically"
+    },
+    gitStatus: input.gitStatus,
+    runtimePolicy: {
+      preflightMode: input.preflightMode,
+      nativeBuildPolicy: input.preflightMode === "fast" ? "verify does not start product-local Mobile scripts; start/reuse a runner-owned or slot-owned runtime before live proof" : "verify did not start product-local Mobile scripts"
+    },
+    fixtureStatus: input.fixtureStatus,
+    portHolder: input.portHolder,
+    runtimeNotes: input.runtimeNotes,
+    checks: input.checks,
+    generatedAt: input.generatedAt
+  };
+}
+function resolveWatcherPort(target, env = process.env) {
+  const explicit = env.WATCHER_PORT || "";
+  if (explicit) return explicit;
+  for (const file of ENV_FILES) {
+    const full = path.join(target, file);
+    if (!fs.existsSync(full)) continue;
+    const match = fs.readFileSync(full, "utf8").match(/^\s*(?:export\s+)?WATCHER_PORT=(["']?)([0-9]+)\1/mu);
+    if (match) return match[2];
+  }
+  return "8081";
+}
+function resolveJsEnvValue(target, name, env = process.env) {
+  const fromProcess = env[name] || "";
+  if (fromProcess) return fromProcess;
+  const pattern = new RegExp(`^\\s*(?:export\\s+)?${name}=(["']?)([^"'\\n]+)\\1`, "mu");
+  for (const file of ENV_FILES) {
+    const full = path.join(target, file);
+    if (!fs.existsSync(full)) continue;
+    const match = fs.readFileSync(full, "utf8").match(pattern);
+    if (match) return match[2];
+  }
+  return "";
+}
+function runtimeContextValue(target, names) {
+  const file = path.join(target, recipeRuntimeDir(), "agentic-runtime.json");
+  for (const name of names) {
+    const value = readRuntimeContextField(file, name);
+    if (value !== void 0 && value !== "") return value;
+  }
+  return "";
+}
+function mobileDeviceTarget(target, platform, env) {
+  if (platform === "android") {
+    return env.ADB_SERIAL || env.ANDROID_SERIAL || env.ANDROID_DEVICE || runtimeContextValue(target, ["adbSerial", "androidDevice", "device"]);
+  }
+  return env.SIM_UDID || env.IOS_SIMULATOR || runtimeContextValue(target, ["simulator", "iosSimulator", "device"]);
+}
+function mobileFixtureStatus(target) {
+  const runtimeDir = recipeRuntimeDir();
+  const fixture = path.join(target, runtimeDir, "wallet-fixture.json");
+  if (!fs.existsSync(fixture)) {
+    return {
+      status: "MISSING_FIXTURES",
+      message: `No wallet fixture found. This run may spend time repairing wallet/perps state manually. For a clean isolated sandbox, create ${runtimeDir}/wallet-fixture.json.`,
+      setupCommand: `mkdir -p ${runtimeDir} && edit ${runtimeDir}/wallet-fixture.json with password + accounts`
+    };
+  }
+  const fixtureRaw = fs.readFileSync(fixture);
+  let valid = false;
+  let accountCount = null;
+  let hasPassword = false;
+  try {
+    const parsed = JSON.parse(fixtureRaw.toString("utf8"));
+    valid = true;
+    accountCount = Array.isArray(parsed.accounts) ? parsed.accounts.length : 0;
+    hasPassword = typeof parsed.password === "string" && parsed.password.length > 0;
+  } catch {
+    valid = false;
+  }
+  const relative = path.relative(target, fixture);
+  const ready = valid && hasPassword && (accountCount ?? 0) > 0;
+  return {
+    status: ready ? "READY" : "STALE_OR_INVALID",
+    path: relative,
+    sha256: crypto.createHash("sha256").update(fixtureRaw).digest("hex"),
+    modifiedAt: fs.statSync(fixture).mtime.toISOString(),
+    accountCount,
+    hasPassword,
+    message: ready ? `Fixture status: READY (${relative}, accounts=${accountCount}).` : `Fixture status: STALE_OR_INVALID (${relative}). Validate password/accounts before relying on a clean sandbox.`
+  };
+}
+function capture(command, args) {
+  try {
+    return execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return "";
+  }
+}
+function mobilePortHolder(port) {
+  const pid = capture("lsof", [`-iTCP:${port}`, "-sTCP:LISTEN", "-t"]).split("\n")[0] ?? "";
+  const command = /^[0-9]+$/u.test(pid) ? capture("ps", ["-p", pid, "-o", "command="]) : "";
+  return {
+    port,
+    listening: Boolean(pid),
+    pid: pid || null,
+    command: command || null,
+    metroStatusReachable: null,
+    metroHttpProbeSkipped: true,
+    note: "HTTP /status probing is skipped during live verify because the React Native bridge is the authoritative readiness path for Mobile."
+  };
+}
+function spawnToLog(logPath, command, args, options = {}) {
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  const fd = fs.openSync(logPath, "w");
+  try {
+    const result = spawnSync(command, args, {
+      cwd: options.cwd,
+      env: options.env ?? process.env,
+      stdio: ["ignore", fd, fd],
+      ...options.timeoutMs === void 0 ? {} : { timeout: options.timeoutMs }
+    });
+    if (result.error) {
+      const timedOut = result.error.code === "ETIMEDOUT";
+      fs.writeSync(
+        fd,
+        timedOut ? `Timed out after ${(options.timeoutMs ?? 0) / 1e3}s: ${[command, ...args].join(" ")}
+` : `${result.error.message}
+`
+      );
+      return timedOut ? 124 : 127;
+    }
+    return result.status ?? 1;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function readJsonFile(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function gitStatusSummary(target, harnessRootExclude) {
+  const runGit = (args) => {
+    try {
+      return execFileSync("git", ["-C", target, ...args], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+      }).trim();
+    } catch {
+      return null;
+    }
+  };
+  const statusShort = runGit(["status", "--short", "--", ".", `:(exclude)${harnessRootExclude}`]);
+  const dirty = statusShort ? statusShort.split("\n").filter(Boolean) : [];
+  return {
+    branch: runGit(["branch", "--show-current"]),
+    head: runGit(["rev-parse", "--short", "HEAD"]),
+    dirtyCount: dirty.length,
+    dirtyPreview: dirty.slice(0, 25)
+  };
+}
+function utcStamp(date) {
+  return `${date.toISOString().replace(/[-:]/gu, "").split(".")[0]}Z`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+const defaultIo = {
+  out: (line) => process.stdout.write(`${line}
+`),
+  err: (line) => process.stderr.write(`${line}
+`)
+};
+async function runMobileVerify(argv, io = defaultIo) {
+  const parsed = parseMobileVerifyArgs(argv);
+  if (parsed.kind === "help") {
+    io.out(parsed.usage);
+    return 0;
+  }
+  if (parsed.kind === "error") {
+    io.err(parsed.message);
+    return parsed.exitCode;
+  }
+  const { staticOnly, platform, preflightMode, autoStart } = parsed.options;
+  const target = path.resolve(parsed.options.target);
+  if (!fs.existsSync(target)) {
+    io.err(`Refusing mobile verify: target checkout does not exist: ${target}`);
+    io.err("  Next: pass --target <metamask-mobile checkout>");
+    return 1;
+  }
+  const harnessRoot = recipeHarnessRoot();
+  const harnessRel = `${harnessRoot}/mobile`;
+  const harnessDir = recipeHarnessPath(target, "mobile");
+  const runnerBin = path.join(harnessDir, "runner/bin/mm-harness");
+  const artifacts = parsed.options.artifactsDir ? path.resolve(parsed.options.artifactsDir) : path.join(harnessDir, "verify", utcStamp(/* @__PURE__ */ new Date()));
+  fs.mkdirSync(path.join(artifacts, "logs"), { recursive: true });
+  const notesPath = path.join(artifacts, "logs/runtime-notes.txt");
+  const addNote = (note) => {
+    fs.appendFileSync(notesPath, `${note}
+`);
+  };
+  let status = "pass";
+  const checks = [];
+  const checkFile = (rel) => {
+    const ok = fs.existsSync(path.join(target, rel));
+    checks.push({ name: rel, status: ok ? "pass" : "fail" });
+    if (!ok) status = "fail";
+  };
+  const checkContains = (name, file, needle) => {
+    let ok = false;
+    try {
+      ok = fs.readFileSync(path.join(target, file), "utf8").includes(needle);
+    } catch {
+      ok = false;
+    }
+    checks.push({ name, status: ok ? "pass" : "fail" });
+    if (!ok) status = "fail";
+  };
+  checkFile(`${harnessRel}/manifest.json`);
+  checkFile(`${harnessRel}/action-manifest.json`);
+  checkFile(`${harnessRel}/runner/bin/mm-harness`);
+  checkFile("package.json");
+  checkFile("app/dev-tools/AgenticService/AgenticService.ts");
+  checkContains("NavigationService agentic bridge", "app/core/NavigationService/NavigationService.ts", "AgenticService.install");
+  checkContains("App AgentStepHud", "app/components/Nav/App/App.tsx", "AgentStepHud");
+  let fixtureStatus = null;
+  let portHolder = null;
+  if (!staticOnly) {
+    const port = resolveWatcherPort(target);
+    if (!isNumericWatcherPort(port)) {
+      io.err(`Refusing mobile verify: resolved watcher port is not numeric: '${port}' (check WATCHER_PORT)`);
+      return 2;
+    }
+    let deviceTarget = mobileDeviceTarget(target, platform, process.env);
+    if (!deviceTarget) {
+      deviceTarget = platform === "android" ? resolveJsEnvValue(target, "ADB_SERIAL") || resolveJsEnvValue(target, "ANDROID_DEVICE") : resolveJsEnvValue(target, "IOS_SIMULATOR");
+    }
+    const deviceArgs = deviceTarget ? ["--device", deviceTarget] : [];
+    const statusSmokeRecipe = path.join(artifacts, "mobile-status-smoke.recipe.json");
+    const precheckLog = path.join(artifacts, "logs/app-status-precheck.log");
+    let liveRuntimeOk = false;
+    for (let attempt = 1; attempt <= 5; attempt += 1) {
+      fs.writeFileSync(statusSmokeRecipe, STATUS_SMOKE_RECIPE);
+      const code = spawnToLog(precheckLog, runnerBin, [
+        "run",
+        statusSmokeRecipe,
+        "--adapter",
+        "mobile",
+        "--target",
+        target,
+        ...deviceArgs,
+        "--watcher-port",
+        port,
+        "--artifacts-dir",
+        path.join(artifacts, "runner-status-smoke"),
+        "--json"
+      ], { cwd: target });
+      if (code === 0) {
+        liveRuntimeOk = true;
+        break;
+      }
+      const deviceNotFound = /"code"[ \t]*:[ \t]*"DEVICE_NOT_FOUND"/u.test(
+        fs.readFileSync(precheckLog, "utf8")
+      );
+      if (attempt < 5 && deviceNotFound) {
+        io.err(`Waiting for Mobile device discovery (${attempt}/5): ${deviceTarget || "configured target"}`);
+        await sleep(1e3);
+        continue;
+      }
+      break;
+    }
+    if (!liveRuntimeOk && autoStart) io.err(AUTO_START_REFUSAL);
+    checks.push(liveRuntimeOk ? { name: "mobile runtime controllable precheck", status: "pass" } : { name: "mobile runtime controllable precheck", status: "fail", detail: "see logs/app-status-precheck.log" });
+    if (!liveRuntimeOk) status = "fail";
+    fixtureStatus = mobileFixtureStatus(target);
+    fs.writeFileSync(path.join(artifacts, "logs/fixture-status.json"), `${JSON.stringify(fixtureStatus)}
+`);
+    const fixtureCheck = {
+      name: "fixture status",
+      status: fixtureStatus.status === "READY" ? "pass" : "warn",
+      detail: fixtureStatus.path || fixtureStatus.status || "",
+      message: fixtureStatus.message || fixtureStatus.status
+    };
+    io.err(fixtureCheck.message);
+    addNote(fixtureCheck.message);
+    checks.push(fixtureCheck);
+    portHolder = mobilePortHolder(port);
+    fs.writeFileSync(path.join(artifacts, "logs/port-holder.json"), `${JSON.stringify(portHolder)}
+`);
+    if (status !== "fail" && portHolder.listening) {
+      const waiter = path.join(runnerDir, "adapters/mobile/wait-for-bridge.sh");
+      if (!fs.existsSync(waiter)) {
+        addNote("Mobile bridge settle skipped: wait-for-bridge.sh not found under the runner adapters; reinstall the runner.");
+      } else {
+        const waiterCode = spawnToLog(
+          path.join(artifacts, "logs/wait-for-bridge.log"),
+          "bash",
+          [waiter, "--target", target, "--port", port, "--platform", platform],
+          {
+            env: {
+              ...process.env,
+              MOBILE_BRIDGE_READY_TIMEOUT_MS: process.env.MOBILE_BRIDGE_READY_TIMEOUT_MS || "90000",
+              MOBILE_BRIDGE_UNRESPONSIVE_GRACE_MS: process.env.MOBILE_BRIDGE_UNRESPONSIVE_GRACE_MS || "90000"
+            }
+          }
+        );
+        addNote(waiterCode === 0 ? "Mobile bridge settled before the live smoke (logs/wait-for-bridge.log)." : `Mobile bridge settle did not complete (waiter exit ${waiterCode}); running the live smoke anyway (logs/wait-for-bridge.log).`);
+      }
+    }
+    const liveSmokeRecipe = path.join(artifacts, "mobile-v1-live-smoke.recipe.json");
+    fs.writeFileSync(liveSmokeRecipe, LIVE_SMOKE_RECIPE);
+    const iosSimulatorResolved = resolveJsEnvValue(target, "IOS_SIMULATOR");
+    const adbSerialResolved = resolveJsEnvValue(target, "ADB_SERIAL");
+    const liveSmokeCode = spawnToLog(
+      path.join(artifacts, "logs/runner-live-smoke.log"),
+      runnerBin,
+      [
+        "run",
+        liveSmokeRecipe,
+        "--adapter",
+        "mobile",
+        "--target",
+        target,
+        ...deviceArgs,
+        "--watcher-port",
+        port,
+        "--artifacts-dir",
+        path.join(artifacts, "runner-live-smoke"),
+        "--json"
+      ],
+      {
+        cwd: target,
+        env: {
+          ...process.env,
+          METAMASK_RECIPE_AUTO_HUD: "0",
+          IOS_SIMULATOR: process.env.IOS_SIMULATOR || iosSimulatorResolved,
+          ADB_SERIAL: process.env.ADB_SERIAL || adbSerialResolved,
+          ANDROID_SERIAL: process.env.ANDROID_SERIAL || adbSerialResolved
+        }
+      }
+    );
+    if (liveSmokeCode === 0) {
+      checks.push({ name: "runner v1 live bridge smoke", status: "pass" });
+    } else {
+      checks.push({ name: "runner v1 live bridge smoke", status: "fail", detail: "see logs/runner-live-smoke.log" });
+      addNote("Runner v1 live bridge smoke failed; inspect logs/runner-live-smoke.log and runner-live-smoke/trace.json.");
+      status = "fail";
+    }
+    const evmLog = path.join(artifacts, "logs/evm-rpc-readiness.log");
+    const bridge = path.join(harnessDir, "bridge-runtime/cdp-bridge.cjs");
+    let evmOk = false;
+    if (!fs.existsSync(bridge)) {
+      fs.writeFileSync(evmLog, `Mobile bridge is missing at ${bridge}
+`);
+    } else {
+      const evmCode = spawnToLog(evmLog, process.execPath, [bridge, "eval-async", EVM_READINESS_EXPRESSION], {
+        timeoutMs: 25e3,
+        env: {
+          ...process.env,
+          APP_ROOT: target,
+          WATCHER_PORT: port,
+          IOS_SIMULATOR: process.env.IOS_SIMULATOR || iosSimulatorResolved,
+          ADB_SERIAL: process.env.ADB_SERIAL || adbSerialResolved,
+          ANDROID_SERIAL: process.env.ANDROID_SERIAL || adbSerialResolved
+        }
+      });
+      evmOk = evmCode === 0 && readJsonFile(evmLog)?.ok === true;
+    }
+    if (evmOk) {
+      checks.push({ name: "live EVM RPC readiness", status: "pass" });
+    } else {
+      checks.push({ name: "live EVM RPC readiness", status: "fail", detail: "see logs/evm-rpc-readiness.log" });
+      addNote(`EVM RPC readiness probe failed. Infura configured \u2260 RPC reachable. Next: confirm ${target}/.js.env has a real MM_INFURA_PROJECT_ID (not 00000000000), then rerun mm-harness launch ${platform} --verify --target '${target}'.`);
+      status = "fail";
+    }
+  }
+  const summary = buildMobileVerifySummary({
+    status,
+    preflightMode,
+    startedByVerify: fs.existsSync(path.join(artifacts, "logs/harness-started-runtime")),
+    fixtureStatus: readJsonFile(path.join(artifacts, "logs/fixture-status.json")),
+    portHolder: readJsonFile(path.join(artifacts, "logs/port-holder.json")),
+    runtimeNotes: readRuntimeNotes(notesPath),
+    checks,
+    gitStatus: gitStatusSummary(target, harnessRoot),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  fs.writeFileSync(path.join(artifacts, "summary.json"), `${JSON.stringify(summary, null, 2)}
+`);
+  fs.writeFileSync(
+    path.join(artifacts, "artifact-manifest.json"),
+    `${JSON.stringify({ artifacts: fs.readdirSync(artifacts).map((name) => ({ path: name })) }, null, 2)}
+`
+  );
+  io.out(`Mobile harness verify ${status}: ${path.join(artifacts, "summary.json")}`);
+  return status === "pass" ? 0 : 1;
+}
+function readRuntimeNotes(notesPath) {
+  try {
+    return fs.readFileSync(notesPath, "utf8").trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+export {
+  buildMobileVerifySummary,
+  classifyMobileRuntimeOwner,
+  isNumericWatcherPort,
+  parseMobileVerifyArgs,
+  resolveJsEnvValue,
+  resolveWatcherPort,
+  runMobileVerify
+};