@deeeed/metamask-harness 0.79.0 → 0.80.0

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

@@ -0,0 +1,20 @@
+'use strict';
+
+// MetaMask Mobile recovery lines for the bridge error codes that
+// @farmslot/adapter-rn classifies; cdp-bridge.cjs prints one after a coded failure.
+//
+// Every coded failure teaches the escape for the caller's ACTUAL situation — a
+// down/transitioning target is recoverable, so the Next: line names the action
+// that brings it back rather than leaving the operator to guess.
+const TEACHING_BY_ERROR_CODE = {
+  NO_TARGET:
+    'Next: bring the app to the foreground with `mm-harness launch <platform>` so a debug target is available.',
+  CDP_TIMEOUT:
+    'Next: the app is reloading or busy — retry, or `mm-harness launch <platform>` to foreground it.',
+  WS_CLOSED:
+    'Next: the Hermes debug page closed (app reload/backgrounded) — retry once the app settles.',
+  METRO_UNREACHABLE:
+    'Next: start Metro with `mm-harness start-metro` (if it is already up, check the slot WATCHER_PORT).',
+};
+
+module.exports = { TEACHING_BY_ERROR_CODE };

package/adapters/mobile/inject.sh

@@ -77,6 +77,22 @@ 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 -R "$RUNNER_DIR/adapters/mobile/bridge-runtime" "$HARNESS_DIR/bridge-runtime"
+# cdp-bridge.cjs runs from the target checkout, which cannot resolve the runner's
+# packages; vendor the bridge libraries it requires next to it.
+node - "$RUNNER_DIR" "$HARNESS_DIR/bridge-runtime/node_modules/@farmslot" <<'NODE' || exit 1
+const fs = require('node:fs');
+const path = require('node:path');
+const { createRequire } = require('node:module');
+const [runnerDir, dest] = process.argv.slice(2);
+const requireFromRunner = createRequire(path.join(runnerDir, 'package.json'));
+for (const [name, dirs] of [['adapter-rn', ['bridge-runtime']], ['recipe-runner', ['cdp-broker']]]) {
+  const packageJson = requireFromRunner.resolve(`@farmslot/${name}/package.json`);
+  const target = path.join(dest, name);
+  fs.mkdirSync(target, { recursive: true });
+  fs.copyFileSync(packageJson, path.join(target, 'package.json'));
+  for (const dir of dirs) fs.cpSync(path.join(path.dirname(packageJson), dir), path.join(target, dir), { recursive: true });
+}
+NODE
 chmod -R u+rwX,go+rX "$HARNESS_DIR"
 
 add_git_exclude() {

package/adapters/mobile/launch-console-forwarder.cjs

@@ -2,7 +2,6 @@
 'use strict';
 
 const fs = require('node:fs');
-const path = require('node:path');
 const { spawn } = require('node:child_process');
 
 const args = { port: '', out: '', err: '' };
@@ -25,7 +24,7 @@ if (!args.port || !args.out || !args.err) {
   process.exit(2);
 }
 
-const forwarder = path.join(__dirname, 'bridge-runtime', 'console-forwarder.cjs');
+const forwarder = require.resolve('@farmslot/adapter-rn/bridge-runtime/console-forwarder.cjs');
 const errFd = fs.openSync(args.err, 'a');
 try {
   const child = spawn(process.execPath, [forwarder, '--port', args.port, '--out', args.out], {

package/adapters/mobile/open-device.sh

@@ -28,7 +28,7 @@ PLATFORM="ios"
 TARGET="$PWD"
 SIMULATOR="${SIM_UDID:-${IOS_SIMULATOR:-booted}}"
 ADB_SERIAL_ARG="${ADB_SERIAL:-${ANDROID_SERIAL:-}}"
-ADB_BIN="${MM_HARNESS_ADB_PATH:-}"
+ADB_BIN="${RECIPE_RN_ADB_PATH:-}"
 PREFLIGHT_MODE="${MOBILE_PREFLIGHT_MODE:-fast}"
 PORT="${WATCHER_PORT:-${METRO_PORT:-8081}}"
 UI_ONLY=false
@@ -67,7 +67,7 @@ if [ "$PLATFORM" = "android" ]; then
     printf 'Next: brew install android-platform-tools\n' >&2
     exit 1
   fi
-  export MM_HARNESS_ADB_PATH="$ADB_BIN"
+  export RECIPE_RN_ADB_PATH="$ADB_BIN"
 fi
 
 TARGET="$(cd "$TARGET" && pwd)"

package/adapters/mobile/reload-app.mjs

@@ -4,13 +4,13 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
-import { resolveMobileToolPath } from '../../library/actions/mobile/platform/tool-paths.mjs';
+import { resolveMobileToolPath } from '@farmslot/adapter-rn';
 
 const require = createRequire(import.meta.url);
 const WebSocket = require('ws');
-const { discoverTarget, rankRuntimeCandidates } = require('./bridge-runtime/lib/target-discovery.cjs');
-const { brokerSocketPath, createBrokerClient, deviceIdFromUrl } = require('./bridge-runtime/lib/cdp-broker.cjs');
-const { createWSClient } = require('./bridge-runtime/lib/ws-client.cjs');
+const { discoverTarget, rankRuntimeCandidates } = require('@farmslot/adapter-rn/bridge-runtime/lib/target-discovery.cjs');
+const { brokerSocketPath, createBrokerClient, deviceIdFromUrl } = require('@farmslot/recipe-runner/cdp-broker');
+const { createWSClient } = require('@farmslot/adapter-rn/bridge-runtime/lib/ws-client.cjs');
 
 async function observeRuntimeReset(port, target) {
   const socketPath = brokerSocketPath(

package/adapters/mobile/reset-app-data.sh

@@ -6,7 +6,7 @@ PLATFORM="${PLATFORM:-ios}"
 TARGET="$PWD"
 SIMULATOR="${SIM_UDID:-${IOS_SIMULATOR:-booted}}"
 ADB_SERIAL_ARG="${ADB_SERIAL:-${ANDROID_SERIAL:-}}"
-ADB_BIN="${MM_HARNESS_ADB_PATH:-}"
+ADB_BIN="${RECIPE_RN_ADB_PATH:-}"
 MM_RESET_TEMP_ROOT=""
 MM_RESET_STAGING_DIR=""
 

package/adapters/mobile/start-console-forwarder.sh

@@ -23,13 +23,14 @@ done
 TARGET="$(cd "$TARGET" && pwd -P)"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 if [ -z "$PORT" ] && command -v node >/dev/null 2>&1; then
-  PORT="$(APP_ROOT="$TARGET" CONFIG_PATH="$SCRIPT_DIR/bridge-runtime/lib/config.cjs" node -e "process.stdout.write(String(require(process.env.CONFIG_PATH).resolvePort()))")"
+  PORT="$(cd "$SCRIPT_DIR" && APP_ROOT="$TARGET" node -e "process.stdout.write(String(require('@farmslot/adapter-rn/bridge-runtime/lib/config.cjs').resolvePort()))")"
 fi
 PORT="${PORT:-8081}"
 # shellcheck disable=SC1091
 . "$SCRIPT_DIR/../shared/harness-path.sh"
 LOG_DIR="$TARGET/$(recipe_runtime_dir)" || exit 1
-FORWARDER="$SCRIPT_DIR/bridge-runtime/console-forwarder.cjs"
+command -v node >/dev/null 2>&1 || exit 0
+FORWARDER="$(cd "$SCRIPT_DIR" && node -p "require.resolve('@farmslot/adapter-rn/bridge-runtime/console-forwarder.cjs')")" || exit 1
 PID_FILE="$LOG_DIR/console-forwarder.pid"
 APP_LOG_FILE="$LOG_DIR/app-console.log"
 

package/adapters/mobile/start-metro.sh

@@ -54,18 +54,23 @@ fi
 # only ever inspect or signal a Metro listening on $PORT.
 # shellcheck disable=SC1091
 . "$SCRIPT_DIR/lib/metro-listener.sh"
-HARNESS_METRO_CONFIG="$SCRIPT_DIR/metro-config.cjs"
+# Metro config wrapper, launcher and log helpers ship in @farmslot/adapter-rn.
+ADAPTER_RN_METRO_DIR="$(cd "$SCRIPT_DIR" && node -p "require('node:path').dirname(require.resolve('@farmslot/adapter-rn/metro/metro-config.cjs'))")" || {
+  echo "start-metro: @farmslot/adapter-rn is not installed next to the runner; reinstall the runner." >&2
+  exit 1
+}
+HARNESS_METRO_CONFIG="$ADAPTER_RN_METRO_DIR/metro-config.cjs"
 if [ "${EXPO_OVERRIDE_METRO_CONFIG:-}" = "$HARNESS_METRO_CONFIG" ]; then
-  PRODUCT_METRO_CONFIG="${MM_HARNESS_METRO_BASE_CONFIG:-$TARGET/metro.config.js}"
+  PRODUCT_METRO_CONFIG="${RECIPE_RN_METRO_BASE_CONFIG:-$TARGET/metro.config.js}"
 else
   PRODUCT_METRO_CONFIG="${EXPO_OVERRIDE_METRO_CONFIG:-$TARGET/metro.config.js}"
 fi
-export MM_HARNESS_METRO_PROJECT_ROOT="$TARGET"
-export MM_HARNESS_METRO_BASE_CONFIG="$PRODUCT_METRO_CONFIG"
+export RECIPE_RN_METRO_PROJECT_ROOT="$TARGET"
+export RECIPE_RN_METRO_BASE_CONFIG="$PRODUCT_METRO_CONFIG"
 export EXPO_OVERRIDE_METRO_CONFIG="$HARNESS_METRO_CONFIG"
-MOBILE_METRO_REQUIRED_ENV="${MOBILE_METRO_REQUIRED_ENV:-MM_INFURA_PROJECT_ID METAMASK_BUILD_TYPE METAMASK_ENVIRONMENT} MM_HARNESS_METRO_PROJECT_ROOT MM_HARNESS_METRO_BASE_CONFIG EXPO_OVERRIDE_METRO_CONFIG"
-if [ -n "${MM_HARNESS_METRO_ENV_FINGERPRINT:-}" ]; then
-  MOBILE_METRO_REQUIRED_ENV="$MOBILE_METRO_REQUIRED_ENV MM_HARNESS_METRO_ENV_FINGERPRINT"
+MOBILE_METRO_REQUIRED_ENV="${MOBILE_METRO_REQUIRED_ENV:-MM_INFURA_PROJECT_ID METAMASK_BUILD_TYPE METAMASK_ENVIRONMENT} RECIPE_RN_METRO_PROJECT_ROOT RECIPE_RN_METRO_BASE_CONFIG EXPO_OVERRIDE_METRO_CONFIG"
+if [ -n "${RECIPE_RN_METRO_ENV_FINGERPRINT:-}" ]; then
+  MOBILE_METRO_REQUIRED_ENV="$MOBILE_METRO_REQUIRED_ENV RECIPE_RN_METRO_ENV_FINGERPRINT"
 fi
 
 # RECIPE_RUNTIME_DIR (relative, validated) makes runtime state per-run so jobs
@@ -75,8 +80,8 @@ mkdir -p "$LOG_DIR"
 LOG_FILE="$LOG_DIR/metro.log"
 PID_FILE="$LOG_DIR/metro.pid"
 METRO_BUILD_ENV_FILE="$LOG_DIR/metro-build-env.sh"
-METRO_LOG_GENERATION="$SCRIPT_DIR/metro-log-generation.cjs"
-METRO_LOG_COALESCER="$SCRIPT_DIR/coalesce-metro-log.cjs"
+METRO_LOG_GENERATION="$ADAPTER_RN_METRO_DIR/metro-log-generation.cjs"
+METRO_LOG_COALESCER="$ADAPTER_RN_METRO_DIR/coalesce-metro-log.cjs"
 
 # --- helpers ------------------------------------------------------------------
 
@@ -106,8 +111,8 @@ write_metro_build_env() {
     done
   )" || { rm -f "$temporary"; return 1; }
   eval "$product_values"
-  required_MM_HARNESS_METRO_PROJECT_ROOT="$MM_HARNESS_METRO_PROJECT_ROOT"
-  required_MM_HARNESS_METRO_BASE_CONFIG="$MM_HARNESS_METRO_BASE_CONFIG"
+  required_RECIPE_RN_METRO_PROJECT_ROOT="$RECIPE_RN_METRO_PROJECT_ROOT"
+  required_RECIPE_RN_METRO_BASE_CONFIG="$RECIPE_RN_METRO_BASE_CONFIG"
   required_EXPO_OVERRIDE_METRO_CONFIG="$EXPO_OVERRIDE_METRO_CONFIG"
   [ "$CLEAR" = true ] && clear_value=1
   {
@@ -322,7 +327,7 @@ else
     )
     [ -z "$METRO_WORKERS" ] || launcher_args+=(--workers "$METRO_WORKERS")
     [ "$CLEAR" = true ] && launcher_args+=(--clear)
-    node "$SCRIPT_DIR/launch-metro.cjs" "${launcher_args[@]}"
+    node "$ADAPTER_RN_METRO_DIR/launch-metro.cjs" "${launcher_args[@]}"
   ) || exit 1
   STARTED_METRO_PID="$(cat "$PID_FILE" 2>/dev/null || true)"
 

package/adapters/mobile/wait-for-bridge.cjs

@@ -14,10 +14,10 @@ const {
   describeRequested,
   describeTargets,
   hasMatchingRoute,
-} = require('./bridge-runtime/lib/match-bridge-target.cjs');
+} = require('@farmslot/adapter-rn/bridge-runtime/lib/match-bridge-target.cjs');
 const {
   rankRuntimeCandidates,
-} = require('./bridge-runtime/lib/target-discovery.cjs');
+} = require('@farmslot/adapter-rn/bridge-runtime/lib/target-discovery.cjs');
 
 const DEFAULT_MAX_POLLS = 90;
 const DEFAULT_POLL_INTERVAL_MS = 2_000;

package/adapters/shared/harness-source-fingerprint.mjs

@@ -8,7 +8,7 @@
 // the next launch refreshes every slot from it.
 //
 // Source files count by size + mtime, so it is cheap enough to run on every launch;
-// the only file read is @farmslot/adapter-web's package.json, for its version. No
+// the only files read are the vendored packages' package.json, for their versions. No
 // Date.now()/random is used (both would break determinism).
 import fs from 'node:fs';
 import path from 'node:path';
@@ -25,17 +25,22 @@ export function harnessSourceFingerprint(runnerDir, adapter = 'extension') {
   for (const rel of sourceDirs) {
     collect(path.join(runnerDir, rel), runnerDir, entries);
   }
-  // inject.mjs copies the browser helpers from @farmslot/adapter-web, so its sources
-  // are overlay inputs too; label them by package so the install location does not count.
-  if (adapter === 'extension') {
-    const packageJson = createRequire(path.join(runnerDir, 'package.json')).resolve('@farmslot/adapter-web/package.json');
+  // The injectors copy package files into the overlay (Extension: @farmslot/adapter-web's
+  // browser helpers; Mobile: the bridge libraries cdp-bridge.cjs requires), so those
+  // sources are overlay inputs too; label them by package so the install location
+  // does not count.
+  const vendored = adapter === 'extension'
+    ? [['@farmslot/adapter-web', ['src']]]
+    : [['@farmslot/adapter-rn', ['bridge-runtime']], ['@farmslot/recipe-runner', ['cdp-broker']]];
+  for (const [name, dirs] of vendored) {
+    const packageJson = createRequire(path.join(runnerDir, 'package.json')).resolve(`${name}/package.json`);
     const packageRoot = path.dirname(packageJson);
     const packageEntries = [];
-    collect(path.join(packageRoot, 'src'), packageRoot, packageEntries);
-    entries.push(...packageEntries.map((entry) => `@farmslot/adapter-web/${entry}`));
+    for (const dir of dirs) collect(path.join(packageRoot, dir), packageRoot, packageEntries);
+    entries.push(...packageEntries.map((entry) => `${name}/${entry}`));
     // npm tarballs carry fixed mtimes, so an upgrade can keep every size and mtime:
     // the version marks it.
-    entries.push(`@farmslot/adapter-web@${JSON.parse(fs.readFileSync(packageJson, 'utf8')).version}`);
+    entries.push(`${name}@${JSON.parse(fs.readFileSync(packageJson, 'utf8')).version}`);
   }
   entries.sort();
   return crypto.createHash('sha256').update(entries.join('\n')).digest('hex');

package/adapters/shared/open-debug.mjs

@@ -15,10 +15,10 @@ import path from 'node:path';
 const require = createRequire(import.meta.url);
 const {
   discoverTarget,
-} = require('../mobile/bridge-runtime/lib/target-discovery.cjs');
+} = require('@farmslot/adapter-rn/bridge-runtime/lib/target-discovery.cjs');
 const {
   deviceIdFromUrl,
-} = require('../mobile/bridge-runtime/lib/cdp-broker.cjs');
+} = require('@farmslot/recipe-runner/cdp-broker');
 
 function usage() {
   console.error(`Usage:

package/adapters/shared/sync-wallet-fixture.sh

@@ -60,12 +60,15 @@ fi
 
 # Farmslot slot sync (requires farmslot root and sync-fixtures.sh).
 if [ -n "$SLOT_ID" ]; then
+  # An explicit FARMSLOT_ROOT wins; otherwise the operator checkout's farm script.
   FARMSLOT_ROOT="${FARMSLOT_ROOT:-}"
-  for candidate in "$HOME/dev/farmslot" "$HOME/farmslot"; do
-    [ -d "$candidate/scripts" ] || continue
-    FARMSLOT_ROOT="$candidate"
-    break
-  done
+  if [ -z "$FARMSLOT_ROOT" ]; then
+    for candidate in "$HOME/dev/farmslot" "$HOME/farmslot"; do
+      [ -f "$candidate/scripts/sync-fixtures.sh" ] || continue
+      FARMSLOT_ROOT="$candidate"
+      break
+    done
+  fi
   if [ -n "$FARMSLOT_ROOT" ] && [ -f "$FARMSLOT_ROOT/scripts/sync-fixtures.sh" ]; then
     if bash "$FARMSLOT_ROOT/scripts/sync-fixtures.sh" --slot "$SLOT_ID" 2>/dev/null; then
       [ -f "$CANONICAL" ] && exit 0

package/adapters/terminal/cleanup.mjs

@@ -11,7 +11,8 @@ import { existsSync, readdirSync, rmSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { recipeHarnessPath, walletFixturePath } from '../../library/actions/harness-exports.mjs';
+import { recipeHarnessPath } from '@farmslot/recipe-cli/harness';
+import { walletFixturePath } from '../../library/actions/harness-exports.mjs';
 import { terminalRuntimeDir } from '../../library/actions/terminal/platform/runtime.mjs';
 import { stopConsoleCollector, stopTerminalBrowser } from './lib/processes.mjs';
 

package/adapters/terminal/inject.mjs

@@ -13,7 +13,8 @@ import { copyFileSync, chmodSync, existsSync, mkdirSync, readFileSync, writeFile
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { recipeHarnessPath, recipeRuntimeDir, walletFixturePath } from '../../library/actions/harness-exports.mjs';
+import { recipeHarnessPath, recipeRuntimeDir } from '@farmslot/recipe-cli/harness';
+import { walletFixturePath } from '../../library/actions/harness-exports.mjs';
 import { terminalRuntimeDir } from '../../library/actions/terminal/platform/runtime.mjs';
 import { isTerminalCheckout } from './lib/readiness.mjs';
 

package/bin/mm-harness

@@ -90,24 +90,6 @@ if [ -f "$ENSURE_DEPS" ]; then
   bash "$ENSURE_DEPS" "$RUNNER_DIR"
 fi
 
-find_protocol_root() {
-  local start="$1"
-  local dir
-  dir="$(cd "$start" && pwd -P)"
-  while [ "$dir" != "/" ]; do
-    if [ -f "$dir/packages/recipe-runner/package.json" ] && [ -f "$dir/packages/protocol/package.json" ]; then
-      printf '%s\n' "$dir"
-      return 0
-    fi
-    if [ -f "$dir/farmslot/packages/recipe-runner/package.json" ] && [ -f "$dir/farmslot/packages/protocol/package.json" ]; then
-      printf '%s\n' "$dir/farmslot"
-      return 0
-    fi
-    dir="$(dirname "$dir")"
-  done
-  return 1
-}
-
 node_can_run_source_typescript() {
   # Node refuses type-stripping for files under node_modules (ERR_UNSUPPORTED_NODE_
   # MODULES_TYPE_STRIPPING). When this runner is installed as a dependency, the
@@ -183,20 +165,19 @@ if [ ! -f "$ENTRY_TS" ]; then
   exit 1
 fi
 
-TSX_BIN="${TSX_BIN:-$RUNNER_DIR/node_modules/.bin/tsx}"
-if [ ! -x "$TSX_BIN" ] && [ -x "$RUNNER_DIR/../../.bin/tsx" ]; then
-  TSX_BIN="$RUNNER_DIR/../../.bin/tsx"
+# ENTRY_TSX, not TSX_BIN: TSX_BIN is the caller's choice of runner for live
+# adapter scripts too, so this fallback must not overwrite the exported value.
+ENTRY_TSX="${TSX_BIN:-$RUNNER_DIR/node_modules/.bin/tsx}"
+if [ ! -x "$ENTRY_TSX" ] && [ -x "$RUNNER_DIR/../../.bin/tsx" ]; then
+  ENTRY_TSX="$RUNNER_DIR/../../.bin/tsx"
 fi
-if [ ! -x "$TSX_BIN" ]; then
+if [ ! -x "$ENTRY_TSX" ]; then
   if [ -z "${FARMSLOT_ROOT:-}" ] && [ -f "$RUNNER_DIR/.farmslot-root" ]; then
     FARMSLOT_ROOT="$(cat "$RUNNER_DIR/.farmslot-root")"
   fi
-  if [ -z "${FARMSLOT_ROOT:-}" ]; then
-    FARMSLOT_ROOT="$(find_protocol_root "$RUNNER_DIR" || find_protocol_root "$PWD" || true)"
-  fi
   if [ -n "${FARMSLOT_ROOT:-}" ]; then
     FARMSLOT_ROOT="$(cd "$FARMSLOT_ROOT" && pwd -P)"
-    TSX_BIN="$FARMSLOT_ROOT/node_modules/.bin/tsx"
+    ENTRY_TSX="$FARMSLOT_ROOT/node_modules/.bin/tsx"
   fi
 fi
 
@@ -204,8 +185,8 @@ if node_can_run_source_typescript; then
   exec node --no-warnings "$ENTRY_TS" "$@"
 fi
 
-if [ -x "$TSX_BIN" ]; then
-  exec "$TSX_BIN" "$ENTRY_TS" "$@"
+if [ -x "$ENTRY_TSX" ]; then
+  exec "$ENTRY_TSX" "$ENTRY_TS" "$@"
 fi
 
 echo "mm-harness: source checkout requires dist/mm-harness-cli.js, Node.js TypeScript type stripping, or a local tsx binary." >&2

package/dist/adapters/checkout-files.js

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+function checkoutHas(target, relative) {
+  return fs.existsSync(path.join(target, relative));
+}
+function checkoutHasDir(target, relative) {
+  try {
+    return fs.statSync(path.join(target, relative)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+export {
+  checkoutHas,
+  checkoutHasDir
+};

package/dist/adapters/console-capture.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import {
   collectorMatches,
   collectorOwnerMarker,
+  collectorStatus,
   isLegacyCollector,
   isOwnedCollector,
   isPriorInstallCollector,
@@ -80,6 +81,17 @@ async function stopProcess(pid) {
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
 }
+async function verifyOwnedCollectorControl(capture, control) {
+  const status = collectorStatus({
+    pidFile: capture.pidFile,
+    extensionLog: capture.extensionLog,
+    marker: collectorOwnerMarker(path.dirname(capture.pidFile)),
+    cdpPort: capture.cdpPort
+  });
+  if (!status.ok) return { ok: false, detail: status.detail };
+  const result = await control();
+  return { ok: result.ok, detail: result.ok ? `${status.detail}; ${result.detail}` : result.detail };
+}
 const ROTATE_LOG_BYTES = 32 * 1024 * 1024;
 function rotateLargeLog(file) {
   if (fileSize(file) < ROTATE_LOG_BYTES) return;
@@ -118,5 +130,6 @@ function containsAttachment(from) {
 export {
   COLLECTOR_SCRIPT,
   ROTATE_LOG_BYTES,
-  ensureConsoleCollector
+  ensureConsoleCollector,
+  verifyOwnedCollectorControl
 };

package/dist/adapters/core/actions.js

@@ -5,10 +5,11 @@ const coreActions = {
     "metamask.perps.close_positions",
     "metamask.perps.start_state",
     "metamask.perps.read_snapshot",
-    "metamask.perps.read_account"
+    "metamask.perps.read_account",
+    "metamask.perps.quote_fees"
   ],
-  // read_account is Core's alone, and only its live adapter implements it.
-  liveOnly: ["metamask.perps.read_account"],
+  // read_account and quote_fees are Core's alone, and only its live adapter implements them.
+  liveOnly: ["metamask.perps.read_account", "metamask.perps.quote_fees"],
   tsxLiveScripts: {
     env: async (projectRoot, tempDir) => (await import("./live-script-env.js")).coreLiveScriptEnv(projectRoot, tempDir)
   },

package/dist/adapters/core/overlay.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { recipeHarnessPath } from "../../paths.js";
+import { recipeHarnessPath } from "@farmslot/recipe-cli/harness";
 function isExecutable(file) {
   try {
     const stat = fs.statSync(file);

package/dist/adapters/core/readiness.js

@@ -1,8 +1,35 @@
 import fs from "node:fs";
 import path from "node:path";
+import { coreDependencyBlock } from "../../commands/core-readiness.js";
+import { resolveLiveTsx } from "../../live-tsx.js";
 const coreReadiness = {
-  compatibilityMode: (target) => fs.existsSync(path.join(target, "packages/perps-controller/src/index.ts")) ? "headless controller (no bridge)" : "unsupported/no bridge"
+  compatibilityMode: (target) => fs.existsSync(path.join(target, "packages/perps-controller/src/index.ts")) ? "headless controller (no bridge)" : "unsupported/no bridge",
+  checks: (target) => [coreControllerActionsCheck(target)]
 };
+function coreControllerActionsCheck(target) {
+  const block = coreDependencyBlock(target);
+  if (block) {
+    return {
+      id: "core-controller-actions",
+      status: "fail",
+      // A checkout with no dependencies installed is reported, not failed: the
+      // runtime check already says it is not ready and how to install. Once
+      // dependencies are installed, an action that still cannot run fails doctor.
+      required: block.code !== "CORE_DEPS_MISSING",
+      message: `metamask.perps.* actions cannot run: ${block.message}`,
+      detail: block.code,
+      userAction: block.userAction
+    };
+  }
+  const runner = resolveLiveTsx(target);
+  return {
+    id: "core-controller-actions",
+    status: "pass",
+    required: true,
+    message: "metamask.perps.* actions can run.",
+    detail: runner ? `tsx (${runner.source}): ${runner.bin}` : void 0
+  };
+}
 export {
   coreReadiness
 };

package/dist/adapters/core/run.js

@@ -1,11 +1,11 @@
+import { isRecord } from "@farmslot/recipe-cli/harness";
 import { coreDependencyBlock } from "../../commands/core-readiness.js";
-import { isRecord } from "../../commands/parse-args.js";
 const coreRun = {
   async dependencyBlock(target, { recipe, librarySources, action }) {
     const usesController = action !== void 0 ? actionUsesCoreController(action) : await recipeUsesCoreController(recipe, librarySources);
     return usesController ? coreDependencyBlock(target) : null;
   },
-  violationUserAction: (violation) => violation.code === "WALLET_STATE_REQUIRED" ? "for signing, configure a reserved wallet-fixture.json account and pass its non-empty name; an explicit 0x address is supported only by read-only actions" : void 0
+  violationUserAction: (violation) => violation.code === "WALLET_STATE_REQUIRED" ? "for signing, select a wallet-fixture.json account by name or by its address; an address outside the fixture works only for read-only actions" : void 0
 };
 async function recipeUsesCoreController(recipe, librarySources) {
   if (objectUsesCoreController(recipe)) return true;

package/dist/adapters/core/surface.js

@@ -1,12 +1,14 @@
+import { shellQuote } from "@farmslot/recipe-cli/harness";
 import path from "node:path";
 import { depsCheck } from "@farmslot/recipe-runner/runtime/deps-readiness";
 import { defineAdapter } from "@farmslot/adapter-sdk";
-import { shellQuote } from "../../commands/parse-args.js";
 import { adapterRegistry } from "../registry.js";
 import { coreActions } from "./actions.js";
 import { coreHarness, corePrepare, coreRuntimeContext } from "./overlay.js";
 import { coreReadiness } from "./readiness.js";
 import { coreRun } from "./run.js";
+import { coreDependencyBlock } from "../../commands/core-readiness.js";
+import { checkoutHas, checkoutHasDir } from "../checkout-files.js";
 const coreSurface = defineAdapter({
   id: "core",
   sdkVersion: 1,
@@ -15,6 +17,16 @@ const coreSurface = defineAdapter({
   },
   async runtimeStatus(target) {
     const deps = depsCheck(path.resolve(target));
+    const block = deps.status === "current" ? coreDependencyBlock(target) : null;
+    if (block) {
+      return {
+        decision: "blocked",
+        reasonCode: block.code,
+        reasons: [`Core is headless; controller actions cannot run: ${block.message}`],
+        nextAction: block.userAction,
+        deps: deps.status
+      };
+    }
     const ready = deps.status === "current";
     return {
       decision: ready ? "ready" : "install",
@@ -56,6 +68,9 @@ const coreSurface = defineAdapter({
   appLogSource() {
     return null;
   },
+  detect: {
+    files: (target) => checkoutHasDir(target, "packages/perps-controller") && checkoutHas(target, "yarn.lock")
+  },
   hints: {
     launch: "mm-harness run <recipe>   # run recipes against the headless core",
     relaunch: "mm-harness verify",

package/dist/adapters/extension/browser-pid.js

@@ -0,0 +1,56 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+function resolveExtensionBrowserPid(projectRoot, artifactsDir, cdpPort) {
+  const explicit = parsePositivePid(process.env.METAMASK_RECIPE_EXTENSION_BROWSER_PID);
+  if (explicit) return explicit;
+  if (cdpPort) {
+    const lsof = spawnSync("lsof", ["-nP", `-iTCP:${cdpPort}`, "-sTCP:LISTEN", "-t"], {
+      cwd: projectRoot,
+      encoding: "utf8"
+    });
+    if (lsof.status === 0) {
+      const pid = parsePositivePid(String(lsof.stdout).split(/\s+/u).find(Boolean));
+      if (pid) return pid;
+    }
+  }
+  for (const file of [
+    path.join(artifactsDir, "extension-runtime/runtime.json"),
+    path.join(projectRoot, "temp/recipe/runtime/runtime.json")
+  ]) {
+    const pid = parsePositivePid(readJsonFile(file)?.pid);
+    if (pid) return pid;
+  }
+  for (const file of [
+    path.join(projectRoot, "temp/recipe/runtime/chromium.pid"),
+    path.join(projectRoot, "temp/recipe/runtime/browser.pid")
+  ]) {
+    const pid = parsePositivePid(readTextFile(file));
+    if (pid) return pid;
+  }
+  return null;
+}
+function parsePositivePid(value) {
+  const pid = Number(String(value ?? "").trim());
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function readJsonFile(file) {
+  if (!fs.existsSync(file)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readTextFile(file) {
+  if (!fs.existsSync(file)) return "";
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+export {
+  resolveExtensionBrowserPid
+};

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

@@ -1,6 +1,6 @@
 import fs from "node:fs";
+import { recipeRuntimePath } from "@farmslot/recipe-cli/harness";
 import { verifyCapture } from "../../../library/actions/shared/console-collector.mjs";
-import { recipeRuntimePath } from "../../paths.js";
 import { ensureConsoleCollector } from "../console-capture.js";
 function extensionCaptureFiles(target) {
   return {

package/dist/adapters/extension/doctor-checks.js

@@ -1,9 +1,9 @@
+import { recipeRuntimeDir } from "@farmslot/recipe-cli/harness";
 import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
-import { recipeRuntimeDir } from "../../paths.js";
 function extensionBrowserDoctorCheck(target) {
   const requireFromTarget = createRequire(path.join(path.resolve(target), "package.json"));
   for (const packageName of ["@playwright/test", "playwright"]) {