@deeeed/metamask-harness 0.83.0 → 0.85.0

package/adapters/web-dapp/metamask-signer.mjs

@@ -0,0 +1,212 @@
+// metamask-signer.mjs — MetaMask as web-dapp's extension signer, and the
+// identity the injected strict wallet presents.
+//
+// Purpose:
+//   @farmslot/adapter-web/web-dapp runs the slot browser and wallet host; this
+//   module is the signer module it loads (RECIPE_WEB_DAPP_SIGNER_MODULE or
+//   --signer-module). signer=extension loads the slot's copy of the MetaMask
+//   extension and imports the fixture account through the Extension adapter's
+//   fixture flow (wallet-fixture-state.cjs generate → prefill-profile →
+//   seed-cdp); the wallet host then logs every MetaMask confirmation it sees
+//   open. signer=injected presents the strict test wallet as MetaMask, so the
+//   app connects to it the way it connects to the extension.
+//
+// Inputs: env TERMINAL_EXTENSION_DIR (the MetaMask dist, default
+//   <checkout>/temp/metamask-extension/chrome), TERMINAL_EXTENSION_CHECKOUT (an
+//   installed metamask-extension checkout at the dist commit),
+//   TERMINAL_EXTENSION_NODE (that checkout's node; else asdf's install for its .nvmrc).
+// Outputs: the `signers` hooks; per-slot key files in the runtime dir, which the
+//   launcher removes when the launch ends.
+// Never prints: mnemonics, private keys, the wallet password.
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { fixtureEntry, readinessCheck } from '../../library/actions/web-dapp/platform/adapter-web-lib.mjs';
+
+const HARNESS_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const FIXTURE_STATE_SCRIPT = path.join(HARNESS_ROOT, 'adapters/extension/wallet-fixture-state.cjs');
+// adapter-web's LAUNCH_SERVICES launch method, named as the launch leaf names it.
+const LAUNCH_SERVICES = 'launch-services';
+
+function extensionDirFor(target, env) {
+  return path.resolve(env.TERMINAL_EXTENSION_DIR || path.join(target, 'temp/metamask-extension/chrome'));
+}
+
+// Node of the extension checkout (its native modules, e.g. classic-level, are
+// built for that ABI): TERMINAL_EXTENSION_NODE, else asdf's install for .nvmrc.
+export function resolveExtensionNode(checkout, env = process.env) {
+  if (env.TERMINAL_EXTENSION_NODE) return env.TERMINAL_EXTENSION_NODE;
+  const nvmrc = path.join(checkout, '.nvmrc');
+  if (existsSync(nvmrc)) {
+    const wanted = readFileSync(nvmrc, 'utf8').trim().replace(/^v/u, '');
+    const root = path.join(os.homedir(), '.asdf/installs/nodejs');
+    if (existsSync(root)) {
+      const match = readdirSync(root)
+        .filter((version) => version === wanted || version.startsWith(`${wanted}.`))
+        .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }))[0];
+      if (match) return path.join(root, match, 'bin/node');
+    }
+  }
+  return process.execPath;
+}
+
+// The Extension vault needs a mnemonic keyring, so a privateKey account is
+// imported beside the fixture's first mnemonic account and selected.
+export function slotWalletFixture(fixture, accountName) {
+  const entry = fixtureEntry(fixture, accountName);
+  const accounts = [];
+  if (entry.type === 'privateKey') {
+    const primary = fixture.accounts.find((account) => account?.type === 'mnemonic');
+    if (!primary) throw new Error(`fixture has no mnemonic account to host the imported key ${accountName}.`);
+    accounts.push({ ...primary, count: 1, names: [primary.name] });
+    accounts.push(entry);
+  } else {
+    accounts.push({ ...entry, count: 1, names: [entry.name] });
+  }
+  return { password: fixture.password, settings: fixture.settings ?? {}, accounts, selectedAccount: accountName };
+}
+
+function runFixtureState(node, phase, flags) {
+  return execFileSync(node, [FIXTURE_STATE_SCRIPT, phase, ...flags], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 240000,
+  });
+}
+
+async function extensionIdFor(withBrowserClient, idFile) {
+  if (existsSync(idFile)) return readFileSync(idFile, 'utf8').trim();
+  return withBrowserClient(async (client) => {
+    const deadline = Date.now() + 30000;
+    while (Date.now() < deadline) {
+      const { targetInfos } = await client.send('Target.getTargets');
+      const worker = targetInfos.find((info) => info.type === 'service_worker' && info.url.startsWith('chrome-extension://'));
+      if (worker) return new URL(worker.url).host;
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error('the MetaMask service worker did not start');
+  });
+}
+
+// MetaMask shows dapp requests in its side panel (the fixture default) or a
+// notification/popup window; only request routes count as confirmations.
+const WALLET_SURFACES = ['sidepanel.html', 'notification.html', 'popup.html'];
+const CONFIRMATION_ROUTE = /^\/(connect|confirm-transaction|confirmation|confirm|signature-request)(\/|$)/u;
+
+export const signers = {
+  injected: {
+    identity: {
+      info: {
+        uuid: '5d1e5b4e-e2e0-4c3f-9a1d-000000000001',
+        name: 'MetaMask (strict test wallet)',
+        icon: "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'/>",
+        rdns: 'io.metamask',
+      },
+      isMetaMask: true,
+    },
+  },
+
+  extension: {
+    async prepareProfile({ target, runtime, profile, account, fixture, env, freshProfile, log, writePrivateFile, trackSecret }) {
+      const extensionDir = extensionDirFor(target, env);
+      const checkout = env.TERMINAL_EXTENSION_CHECKOUT ? path.resolve(env.TERMINAL_EXTENSION_CHECKOUT) : null;
+      if (!existsSync(path.join(extensionDir, 'manifest.json'))) {
+        throw new Error(`MetaMask extension dist not found at ${extensionDir}.\nNext: copy a built dist/chrome there or set TERMINAL_EXTENSION_DIR.`);
+      }
+      if (!checkout || !existsSync(path.join(checkout, 'node_modules'))) {
+        throw new Error('signer=extension needs TERMINAL_EXTENSION_CHECKOUT: an installed metamask-extension checkout at the dist commit (fixture state generation).');
+      }
+      const manifest = JSON.parse(readFileSync(path.join(extensionDir, 'manifest.json'), 'utf8'));
+      const node = resolveExtensionNode(checkout, env);
+      // Key material (the slot fixture) and the encrypted vault (fixture state).
+      const slotFixture = trackSecret(path.join(runtime, `wallet-fixture.${account}.json`));
+      const fixtureState = trackSecret(path.join(runtime, `fixture-state.${account}.json`));
+      writePrivateFile(slotFixture, JSON.stringify(slotWalletFixture(fixture, account)));
+      const idFile = path.join(runtime, 'extension.id');
+      runFixtureState(node, 'generate', ['--target', checkout, '--fixture', slotFixture, '--out', fixtureState]);
+      if (freshProfile) {
+        runFixtureState(node, 'prefill-profile', ['--target', checkout, '--state', fixtureState, '--profile', profile, '--extension-dir', extensionDir, '--extension-id-file', idFile]);
+        log(`prefilled extension profile for ${account}`);
+      }
+      return {
+        browserArgs: [
+          '--disable-features=ExtensionContentVerification,DisableLoadExtensionCommandLineSwitch',
+          '--disable-extensions-file-access-check',
+          `--disable-extensions-except=${extensionDir}`,
+          `--load-extension=${extensionDir}`,
+        ],
+        secrets: [],
+        // browser.json's `extension`; the id is filled in once the extension runs.
+        state: { id: undefined, version: manifest.version, dir: extensionDir, checkout },
+        async afterBrowserStart({ cdpPort, launchMethod, withBrowserClient, openBackgroundWindow }) {
+          if (launchMethod === LAUNCH_SERVICES) {
+            // The seed reuses an open MetaMask page; without one it would open a
+            // tab in the foreground and activate the browser.
+            const extensionId = await extensionIdFor(withBrowserClient, idFile);
+            await openBackgroundWindow(`chrome-extension://${extensionId}/home.html`);
+          }
+          runFixtureState(node, 'seed-cdp', [
+            '--target', checkout,
+            '--fixture', slotFixture,
+            '--state', fixtureState,
+            '--cdp-port', String(cdpPort),
+            '--extension-dir', extensionDir,
+            '--extension-id-file', idFile,
+            '--out', path.join(runtime, `seed-report.${account}.json`),
+          ]);
+          const id = readFileSync(idFile, 'utf8').trim();
+          log(`extension ${id} seeded and unlocked for ${account}`);
+          return { state: { id }, hostArgs: ['--extension-id', id] };
+        },
+      };
+    },
+
+    confirm({ args, appendEntry, say, focus }) {
+      const extensionOrigin = args['extension-id'] ? `chrome-extension://${args['extension-id']}` : null;
+      const seenConfirmationUrls = new Map();
+      const isWalletSurfaceUrl = (url) =>
+        Boolean(extensionOrigin) && WALLET_SURFACES.some((surface) => url.startsWith(`${extensionOrigin}/${surface}`));
+      const confirmationRoute = (url) => {
+        const route = (url.split('#')[1] ?? '').split('?')[0];
+        return CONFIRMATION_ROUTE.test(route) ? route.replace(/0x[0-9a-fA-F]{40}/gu, '<address>') : null;
+      };
+      return {
+        isWalletSurfaceUrl,
+        observe(targetId, url) {
+          if (!isWalletSurfaceUrl(url)) return;
+          if (focus && !url.includes('/sidepanel.html') && !seenConfirmationUrls.has(targetId)) {
+            setTimeout(() => focus.observe(url.includes('/popup.html') ? 'popup' : 'notification', 'MetaMask'), 1000);
+          }
+          const route = confirmationRoute(url);
+          if (!route || seenConfirmationUrls.get(targetId) === route) return;
+          seenConfirmationUrls.set(targetId, route);
+          const surface = WALLET_SURFACES.find((name) => url.includes(name))?.replace('.html', '');
+          appendEntry({ kind: 'confirmation-shown', t: Date.now(), surface, route });
+          say(`confirmation shown in ${surface}: ${route}`);
+        },
+      };
+    },
+
+    async readinessChecks({ target, env, required }) {
+      const checks = [];
+      const extensionDir = extensionDirFor(target, env);
+      const manifestPath = path.join(extensionDir, 'manifest.json');
+      if (existsSync(manifestPath)) {
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        checks.push(readinessCheck('metamask-extension', true, `MetaMask ${manifest.version} at ${extensionDir}`, { required }));
+      } else {
+        checks.push(readinessCheck('metamask-extension', false, `no extension dist at ${extensionDir}`, { required }));
+      }
+      const checkout = env.TERMINAL_EXTENSION_CHECKOUT;
+      const checkoutOk = Boolean(checkout) && existsSync(path.join(checkout, 'node_modules/@metamask/browser-passworder'));
+      checks.push(readinessCheck('extension-fixture-tooling', checkoutOk, checkoutOk
+        ? `extension checkout ${checkout} has fixture-state dependencies`
+        : 'TERMINAL_EXTENSION_CHECKOUT unset or not installed (needed to import the wallet into the extension)', { required }));
+      return checks;
+    },
+  },
+};

package/dist/adapters/extension/actions.js

@@ -43,6 +43,11 @@ const extensionActions = {
       }
     })
   }),
+  // The HUD lives only in the extension pages' DOM.
+  async clearHud() {
+    const { clearExtensionHud } = await import("../../../library/actions/extension/platform/cdp.mjs");
+    await clearExtensionHud();
+  },
   trustedMutation: true,
   // ensure_positions and ensure_orders only check state here.
   inputFindings: (nodeId, node) => [

package/dist/adapters/extension/console-capture.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import path from "node:path";
 import { recipeRuntimePath } from "@farmslot/recipe-cli/harness";
 import { verifyCapture } from "../../../library/actions/shared/console-collector.mjs";
 import { ensureConsoleCollector } from "../console-capture.js";
@@ -10,6 +11,21 @@ function extensionCaptureFiles(target) {
     pidFile: recipeRuntimePath(target, "console-tail.pid")
   };
 }
+const EXTENSION_CONSOLE_LAUNCH_FILE = "extension-console.launch.json";
+function recordConsoleLaunchIn(runtimeDir) {
+  const log = path.join(runtimeDir, "extension-console.log");
+  const stat = fs.existsSync(log) ? fs.statSync(log) : null;
+  fs.mkdirSync(runtimeDir, { recursive: true });
+  const launchedAtMs = Date.now();
+  fs.writeFileSync(
+    path.join(runtimeDir, EXTENSION_CONSOLE_LAUNCH_FILE),
+    `${JSON.stringify({ offset: stat?.size ?? 0, inode: stat?.ino ?? null, launchedAtMs, recordedAt: new Date(launchedAtMs).toISOString() })}
+`
+  );
+}
+function recordExtensionConsoleLaunch(target) {
+  recordConsoleLaunchIn(path.dirname(extensionCaptureFiles(target).extensionLog));
+}
 function extensionCdpPort() {
   return process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT;
 }
@@ -37,8 +53,10 @@ async function verifyExtensionConsoleControl(capture) {
   return verifyCapture({ cdpPort: capture.cdpPort, log: capture.extensionLog, target: "extension", extensionId });
 }
 export {
+  EXTENSION_CONSOLE_LAUNCH_FILE,
   ensureExtensionConsoleCapture,
   extensionCaptureFiles,
   extensionCdpPort,
+  recordExtensionConsoleLaunch,
   verifyExtensionConsoleControl
 };

package/dist/adapters/extension/fixtures.js

@@ -4,6 +4,7 @@ import { colorHumanMessage, EXIT, shellQuote, spawnScriptStreaming } from "@farm
 import { FIXTURE_STREAM_TIMEOUT_MS } from "../../commands/fixtures.js";
 import { sameFeatureFlags } from "../../feature-flags.js";
 import { runnerDir } from "../../paths.js";
+import { recordExtensionConsoleLaunch } from "./console-capture.js";
 import { readExtensionPinnedFlags } from "./feature-flags.js";
 import { releaseArtifactState } from "./runtime-decision.js";
 async function applyExtensionFixture({
@@ -96,6 +97,7 @@ async function applyExtensionFixture({
   }
   process.stderr.write(`${colorHumanMessage(`\u2192 fixtures ${action} extension \u2014 resetting and seeding the slot-owned profile from the existing build\u2026`)}
 `);
+  recordExtensionConsoleLaunch(target);
   const liveScript = path.join(runnerDir, "adapters/extension/live.sh");
   const args = ["--target", target, "--launch-existing-dist", "--launch-only", "--reset-profile"];
   const flagKeys = Object.keys(fixtureFlags);

package/dist/adapters/extension/overlay.js

@@ -1,13 +1,14 @@
-import { readRuntimeContextField, resolveRuntimeContextPath } from "@farmslot/recipe-cli/harness";
+import { readRuntimeContextField, recipeRuntimeDir, resolveRuntimeContextPath } from "@farmslot/recipe-cli/harness";
 import fs from "node:fs";
+import path from "node:path";
+import { ownsRuntimeContext } from "../../../adapters/shared/resolve-slot-ports-core.mjs";
 import { resolveExtensionSlotPorts } from "../slot-ports.js";
 function hasArg(args, needle) {
   return args.some((arg) => arg === needle || arg.startsWith(`${needle}=`));
 }
 function applyExtensionRuntimeEnv(target, args) {
-  const contextPath = resolveRuntimeContextPath(target);
-  const contextExists = fs.existsSync(contextPath);
-  if (contextExists) {
+  const contextPath = [resolveRuntimeContextPath(target), path.join(target, recipeRuntimeDir(), "agentic-runtime.json")].find((file) => fs.existsSync(file) && ownsRuntimeContext(file, target));
+  if (contextPath) {
     process.env.RECIPE_RUNTIME_CONTEXT = contextPath;
     if (!process.env.RECIPE_SLOT_ID) {
       const slotId = readRuntimeContextField(contextPath, "slotId");

package/dist/adapters/extension/run.js

@@ -9,6 +9,7 @@ import {
   verifyExtensionConsoleControl
 } from "./console-capture.js";
 import { emitProofFailure } from "../proof-failure.js";
+import { refuseLockedSession } from "../session-lock.js";
 import { launchedBrowser } from "./launched-browser.js";
 const AUTOLAUNCH_ENV = "METAMASK_RECIPE_EXTENSION_AUTOLAUNCH";
 const extensionRun = {
@@ -39,8 +40,9 @@ const extensionRun = {
     });
   },
   // The proof runtime is checked on the run's own ports (the engine's scope).
-  runtimeCheck({ target, heal, state, json, onRecovery }) {
-    return () => ensureExtensionProofRuntime(target, heal, state, json, { onRecovery });
+  // The Extension browser is always headful: a locked session refuses first.
+  runtimeCheck({ target, options, heal, state, json, onRecovery }) {
+    return async () => refuseLockedSession(json, options) ?? ensureExtensionProofRuntime(target, heal, state, json, { onRecovery });
   },
   launchedBrowser: (target, artifactsDir, cdpPort) => launchedBrowser(target, artifactsDir, cdpPort),
   browserProvenance: (browser) => ({

package/dist/adapters/extension/runtime.js

@@ -4,7 +4,9 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { importRecipeHarnessRuntimeBrowserExtension, importRecipeHarnessRuntimeCdp, resolveFarmslotPoolDir, runnerDir } from "../../paths.js";
+import { recordExtensionConsoleLaunch } from "./console-capture.js";
 import { poolFilesForHost } from "../resolve-slot-ports.js";
+import { macosSessionLocked, SESSION_LOCKED_MESSAGE, SESSION_LOCKED_USER_ACTION } from "../../../adapters/shared/session-lock.mjs";
 import { profileProcessPids } from "./validation-process-ownership.js";
 const require2 = createRequire(import.meta.url);
 const { RUNTIME_NONCE_PREFIX, detachedLaunchUnprovenPath, hasDetachedLaunchUnproven, shellQuote } = require2(
@@ -62,7 +64,7 @@ async function assertHealthyExtensionRuntime(options) {
       seededLaunchDir: options.seededLaunchDir
     });
     if (lastReport.status === "PASS") return lastReport;
-    if (lastReport.errorCode === "UI_COMPOSITOR_SUSPENDED" || lastReport.errorCode === "EXTENSION_BACKGROUND_UNRESPONSIVE") {
+    if (lastReport.errorCode === "SESSION_LOCKED" || lastReport.errorCode === "UI_COMPOSITOR_SUSPENDED" || lastReport.errorCode === "EXTENSION_BACKGROUND_UNRESPONSIVE") {
       throw new Error(formatHealthFailure(lastReport, options.projectRoot));
     }
     if (lastReport.errorCode === "FIXTURE_SEED_NOT_APPLIED") {
@@ -149,18 +151,17 @@ async function checkExtensionRuntimeHealth(projectRoot, cdpPort, options = {}) {
       Math.min(1e3, cdpCallTimeoutMs)
     );
     if (compositor.status === "suspended") {
-      const userAction = compositorRecoveryAction(projectRoot);
+      const suspended = `UI_COMPOSITOR_SUSPENDED: the Extension page is reachable over CDP but its render compositor is not advancing (${compositor.reason ?? "unknown reason"}).`;
+      const locked = macosSessionLocked() === true;
       return {
         status: "FAIL",
-        errorCode: "UI_COMPOSITOR_SUSPENDED",
-        userAction,
+        errorCode: locked ? "SESSION_LOCKED" : "UI_COMPOSITOR_SUSPENDED",
+        userAction: locked ? SESSION_LOCKED_USER_ACTION : compositorRecoveryAction(projectRoot),
         cdpPort,
         targetUrl: target.url,
         extensionId: safeExtensionId(target),
         extensionPageTargets: extensionTargets.length,
-        findings: [
-          `UI_COMPOSITOR_SUSPENDED: the Extension page is reachable over CDP but its render compositor is not advancing (${compositor.reason ?? "unknown reason"}).`
-        ],
+        findings: locked ? [`SESSION_LOCKED: ${SESSION_LOCKED_MESSAGE}`, suspended] : [suspended],
         details: {
           projectRoot,
           targetUrls: targets.map((entry) => entry.url).filter(Boolean),
@@ -666,10 +667,11 @@ async function launchLockedValidationBrowser(options) {
   fs.mkdirSync(validationProfileRoot, { recursive: true });
   fs.mkdirSync(validationArtifactsRoot, { recursive: true });
   assertNoQuarantinedValidationProfiles(validationProfileRoot);
+  recordExtensionConsoleLaunch(options.projectRoot);
   await stopOwnedCdpListener(options.cdpPort, [
     validationRuntimePath,
     path.join(options.projectRoot, recipeRuntimeDir())
-  ]);
+  ], path.join(options.projectRoot, recipeRuntimeDir()));
   assertNoLiveValidationProfileOwners(validationProfileRoot);
   pruneValidationRuns(validationProfileRoot, 0);
   pruneValidationRuns(validationArtifactsRoot, 4);
@@ -933,16 +935,32 @@ function runProcess(command, args, options) {
     });
   });
 }
-async function stopOwnedCdpListener(cdpPort, runtimePaths) {
+async function stopOwnedCdpListener(cdpPort, runtimePaths, checkoutRuntimeRoot) {
   if (process.platform !== "darwin" && process.platform !== "linux") return;
   let listenerPids = await inspectCdpListenerPids(cdpPort);
   if (listenerPids.length === 0) return;
   const identity = runtimePaths.map((runtimePath) => readValidationRuntimeIdentity(runtimePath, cdpPort)).find((candidate) => candidate?.pid === listenerPids[0]);
-  if (!identity || listenerPids.length !== 1 || listenerPids[0] !== identity.pid || !await browserEchoesRuntimeNonce(cdpPort, identity.nonce)) {
-    throw new Error(`Extension validation will not stop an unowned CDP listener on port ${cdpPort}.`);
+  let pid;
+  if (identity && listenerPids.length === 1 && listenerPids[0] === identity.pid && await browserEchoesRuntimeNonce(cdpPort, identity.nonce)) {
+    pid = identity.pid;
+  }
+  if (pid === void 0) {
+    const listeners = await listenerCommands(listenerPids);
+    const listener = listenerPids.length === 1 ? listeners.get(listenerPids[0]) : void 0;
+    if (listener?.chrome && !listener.ambiguous && pathInsideReal(checkoutRuntimeRoot, listener.profile) && (await listenerCommands(listenerPids)).get(listenerPids[0])?.command === listener.command) {
+      pid = listenerPids[0];
+    } else {
+      const seen = listenerPids.map((candidate) => {
+        const profile = listeners.get(candidate)?.profile;
+        return profile ? `pid ${candidate} --user-data-dir=${profile}` : `pid ${candidate}`;
+      }).join("; ");
+      throw new Error(
+        `Extension validation will not stop an unowned CDP listener on port ${cdpPort} (${seen}). Next: if that is this slot's browser, stop it (kill ${listenerPids.join(" ")}); otherwise free port ${cdpPort}. Then rerun.`
+      );
+    }
   }
   try {
-    process.kill(identity.pid, "SIGTERM");
+    process.kill(pid, "SIGTERM");
   } catch (error) {
     if (error.code !== "ESRCH") throw error;
   }
@@ -950,10 +968,10 @@ async function stopOwnedCdpListener(cdpPort, runtimePaths) {
   do {
     await sleep(50);
     listenerPids = await inspectCdpListenerPids(cdpPort);
-  } while ((listenerPids.length > 0 || processExists(identity.pid)) && Date.now() < termDeadline);
-  if (listenerPids.length > 0 || processExists(identity.pid)) {
+  } while ((listenerPids.length > 0 || processExists(pid)) && Date.now() < termDeadline);
+  if (listenerPids.length > 0 || processExists(pid)) {
     try {
-      process.kill(identity.pid, "SIGKILL");
+      process.kill(pid, "SIGKILL");
     } catch (error) {
       if (error.code !== "ESRCH") throw error;
     }
@@ -961,12 +979,48 @@ async function stopOwnedCdpListener(cdpPort, runtimePaths) {
     do {
       await sleep(50);
       listenerPids = await inspectCdpListenerPids(cdpPort);
-    } while ((listenerPids.length > 0 || processExists(identity.pid)) && Date.now() < killDeadline);
+    } while ((listenerPids.length > 0 || processExists(pid)) && Date.now() < killDeadline);
   }
-  if (listenerPids.length > 0 || processExists(identity.pid)) {
+  if (listenerPids.length > 0 || processExists(pid)) {
     throw new Error(`Extension validation could not stop its CDP listener on port ${cdpPort}.`);
   }
 }
+async function listenerCommands(pids) {
+  const listeners = /* @__PURE__ */ new Map();
+  const result = await runProcess("ps", ["-ww", "-o", "pid=,command=", "-p", pids.join(",")], {
+    cwd: runnerDir,
+    env: process.env,
+    timeoutMs: 5e3
+  });
+  if (result.timedOut) return listeners;
+  for (const line of result.stdout.split("\n")) {
+    const match = line.match(/^\s*(\d+)\s+(.*)$/u);
+    if (!match) continue;
+    const command = match[2];
+    const flags = [...command.matchAll(/(?:^|\s)--user-data-dir=/gu)];
+    const last = flags.at(-1);
+    if (!last) continue;
+    const value = command.slice(last.index + last[0].length);
+    const ends = [...value.matchAll(/\s--/gu)].map((end) => end.index);
+    const profile = value.slice(0, ends[0] ?? value.length);
+    const longerReadings = [...ends.slice(1), value.length].map((end) => value.slice(0, end));
+    listeners.set(Number(match[1]), {
+      command,
+      profile,
+      chrome: /chrom/iu.test(path.basename(command.split(/\s-/u)[0])),
+      ambiguous: flags.length > 1 || !path.isAbsolute(profile) || ends.length > 0 && longerReadings.some((reading) => fs.existsSync(reading))
+    });
+  }
+  return listeners;
+}
+function pathInsideReal(root, candidate) {
+  try {
+    const relative = path.relative(fs.realpathSync(root), fs.realpathSync(candidate));
+    return Boolean(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  } catch {
+    return false;
+  }
+}
 async function inspectCdpListenerPids(cdpPort) {
   const result = await runProcess("lsof", ["-ti", `tcp:${cdpPort}`, "-sTCP:LISTEN"], {
     cwd: runnerDir,
@@ -1040,5 +1094,6 @@ export {
   extensionBackgroundProbeTimeoutMs,
   formatHealthFailure,
   prepareExtensionRuntime,
-  seededLaunchDir
+  seededLaunchDir,
+  stopOwnedCdpListener
 };

package/dist/adapters/mobile/devices.js

@@ -9,7 +9,11 @@ import {
 } from "../../commands/mobile-device-view.js";
 const mobileDevices = {
   view: mobileDeviceView,
-  live: mobileDeviceLiveView,
+  // adapter-sdk's live view names the app's feature-flag overrides `featureFlags`.
+  async live(target, view) {
+    const live = await mobileDeviceLiveView(target, view);
+    return { ...live, featureFlags: live.featureFlagOverrides };
+  },
   renderList: renderMobileDeviceList,
   renderAdditional: renderAdditionalReachableDevices,
   renderLive: renderMobileLiveBlock,

package/dist/adapters/mobile/launch.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import path from "node:path";
 import { recipeRuntimePath, EXIT, str, writeInteractiveProgress } from "@farmslot/recipe-cli/harness";
 import { applyDeviceTargeting } from "../../commands/device-target.js";
 import { launchMobile } from "../../commands/launch/mobile.js";
@@ -49,6 +50,14 @@ function metroLaunchEvidence(target) {
     if (descriptor !== void 0) fs.closeSync(descriptor);
   }
 }
+function recordMobileConsoleLaunch(target) {
+  const file = recipeRuntimePath(target, "app-console.launch.json");
+  const launchedAtMs = Date.now();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify({ launchedAtMs, recordedAt: new Date(launchedAtMs).toISOString() })}
+`);
+}
+const markedLaunches = /* @__PURE__ */ new WeakSet();
 const mobileLaunchProfile = {
   refuseFlags({ platformTarget }) {
     if (!platformTarget) {
@@ -104,7 +113,14 @@ const mobileLaunchProfile = {
   },
   nativeInputs: ["ios", "android", "package.json", "yarn.lock"],
   rebuildCommand: ({ platformTarget }) => `mm-harness launch ${platformTarget} --build`,
-  compose: ({ target, platformTarget, machine, remoteFlagRequest }, tier, restartApp, clearMetro) => launchMobile(target, platformTarget, tier, machine, restartApp, clearMetro, remoteFlagRequest?.flags),
+  compose: (launch, tier, restartApp, clearMetro) => {
+    const { target, platformTarget, machine, remoteFlagRequest } = launch;
+    if (restartApp || !markedLaunches.has(launch)) {
+      markedLaunches.add(launch);
+      recordMobileConsoleLaunch(target);
+    }
+    return launchMobile(target, platformTarget, tier, machine, restartApp, clearMetro, remoteFlagRequest?.flags);
+  },
   classify(_launch, output) {
     if (output.includes("open-device: Android device is locked.")) {
       return {
@@ -187,5 +203,6 @@ const mobileLaunchProfile = {
   evidence: metroLaunchEvidence
 };
 export {
-  mobileLaunchProfile
+  mobileLaunchProfile,
+  recordMobileConsoleLaunch
 };

package/dist/adapters/mobile/provision.js

@@ -4,7 +4,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { resolveSlotPortsByRepo } from "../../../adapters/shared/resolve-slot-ports-core.mjs";
+import { ownsRuntimeContext, resolveSlotPortsByRepo } from "../../../adapters/shared/resolve-slot-ports-core.mjs";
 const RUNWAY_IOS_METADATA = {
   artifactName: "ios-app-main-dev-expo",
   workflow: "expo-dev-build.yml",
@@ -177,8 +177,10 @@ function fail(target, platform, code, message, rerunCommand, slot) {
   };
 }
 function readSlotContext(target, runtimeDir) {
+  const envContext = process.env.RECIPE_RUNTIME_CONTEXT;
   const candidates = [
-    process.env.RECIPE_RUNTIME_CONTEXT,
+    // Another checkout's context would name its slot and simulator.
+    envContext && ownsRuntimeContext(envContext, target) ? envContext : void 0,
     runtimeContextPath(target, runtimeDir),
     path.join(target, recipeRuntimeDir(), "agentic-runtime.json"),
     path.join(target, "temp/recipe/runtime/agentic-runtime.json"),

package/dist/adapters/mobile/run.js

@@ -57,7 +57,8 @@ const mobileRun = {
     // matches its target against it.
     RECIPE_RN_EXPLICIT_PLATFORM: process.env.RECIPE_RN_EXPLICIT_PLATFORM
   }),
-  // An installed release artifact is opaque: no harness HUD inside it.
+  // An installed release artifact is opaque: it has no dev bridge and no
+  // AgentStepHud, so there is nothing to draw the HUD with.
   autoHud: () => process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME !== "1",
   // Always clear a HUD step the engine left on-device (a failed run strands
   // the FAIL banner). Best-effort — never masks the run's real outcome.
@@ -82,7 +83,7 @@ async function ensureMobileProofRuntime(target, _heal, state, json, deps = {}) {
   }
   if (initial.status === "current") return null;
   const targetArg = JSON.stringify(path.resolve(target));
-  const userAction = `mm-harness call app.lifecycle --arg command=restart --adapter mobile --target ${targetArg}`;
+  const userAction = `mm-harness call app.lifecycle command=restart --adapter mobile --target ${targetArg}`;
   const message = `Mobile loaded source is not current (${initial.status}).`;
   emitProofFailure(json, {
     recoverable: true,

package/dist/adapters/mobile/surface.js

@@ -53,9 +53,8 @@ const mobileSurface = defineAdapter({
   devServer: {
     label: "metro",
     describe: () => "Metro dev server",
-    // Metro's leaves read the port as METRO_PORT; run and call take it as --metro-port.
+    // Metro's leaves read the port as METRO_PORT.
     portEnv: ["METRO_PORT"],
-    portFlags: ["metroPort"],
     stop(target) {
       const leaf = path.join(runnerDir, "adapters", "mobile", "stop-metro.sh");
       const args = ["--target", target];