@deeeed/metamask-harness 0.79.0 → 0.80.0

package/dist/commands/launch/mobile.js

@@ -1,3 +1,4 @@
+import { EXIT } from "@farmslot/recipe-cli/harness";
 import { prepareMobile } from "../../adapters/mobile/prepare.js";
 import {
   mobileSourceCheck,
@@ -7,7 +8,6 @@ import { ensureHarnessFresh } from "../../adapters/harness-freshness.js";
 import { pinMobileFeatureFlags } from "../../adapters/mobile/feature-flags.js";
 import { toRemoteFlagSpec } from "../../feature-flags.js";
 import { clearMobileReleaseArtifactState } from "../../adapters/mobile/release-artifact-state.js";
-import { EXIT } from "../shared.js";
 async function launchMobile(target, mobileTarget, tier, json, restartApp = false, clearMetro = false, remoteFlags) {
   clearMobileReleaseArtifactState(target);
   await ensureHarnessFresh(target, "mobile");

package/dist/commands/list-executables.js

@@ -2,9 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { resolveActionManifest } from "../manifest.js";
 import { importRecipeProtocol } from "../paths.js";
-import { color } from "../cli-color.js";
-import { EXIT } from "./shared.js";
-import { optionFlag, optionString, optionStrings, resolveAdapter, shellQuoteArg } from "./parse-args.js";
+import { color, EXIT, optionFlag, optionString, optionStrings, resolveAdapter, shellQuoteArg } from "@farmslot/recipe-cli/harness";
 import { actionDomain, describeManifestActions, renderHumanActionCatalog } from "./manifest.js";
 import { shortActionNames } from "@farmslot/recipe-cli";
 import {

package/dist/commands/logs.js

@@ -1,16 +1,16 @@
+import { adapterDetectNext, EXIT, flag, parseFlags, resolveFlagsAdapter, spawnInherit, spawnScript, str, targetOf, usageOut } from "@farmslot/recipe-cli/harness";
 import fs from "node:fs";
 import path from "node:path";
 import { runnerDir } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
-import { ADAPTER_DETECT_NEXT, EXIT, flag, parseFlags, resolveAdapter, spawnInherit, spawnScript, str, targetOf, usageOut } from "./shared.js";
 const LOGS_BOOLEANS = /* @__PURE__ */ new Set(["full", "json", "window"]);
 async function handleLogs(argv) {
   const { options } = parseFlags(argv, LOGS_BOOLEANS);
   const json = flag(options, "json");
   const target = targetOf(options);
-  const adapter = resolveAdapter(options, target);
+  const adapter = resolveFlagsAdapter(options, target);
   if (!adapter) {
-    return usageOut(json, "logs", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
+    return usageOut(json, "logs", `could not detect the MetaMask repo type for ${target}`, adapterDetectNext());
   }
   const surface = getAdapterSurface(adapter);
   if (surface.headless) {

package/dist/commands/manifest.js

@@ -1,22 +1,11 @@
 import { resolveActionManifest } from "../manifest.js";
-import { color } from "../cli-color.js";
-import { EXIT } from "./shared.js";
-import {
-  isRecord,
-  optionFlag,
-  optionString,
-  optionStrings,
-  resolveAdapter,
-  shellQuoteArg
-} from "./parse-args.js";
+import { closest, color, isSensitiveKey, redactStructuredValue, EXIT, isRecord, optionFlag, optionString, optionStrings, resolveAdapter, shellQuoteArg } from "@farmslot/recipe-cli/harness";
 import { resolveMetaMaskLibrarySources } from "./run-engine.js";
-import { isSensitiveKey, redactStructuredValue } from "../command-journal.js";
 import {
   OFFICIAL_RECIPE_ACTIONS,
   officialRecipeActionCapabilities
 } from "@farmslot/protocol";
 import { metaMaskActionExecutionCapabilities } from "../recipe-security.js";
-import { closest } from "../command-contract.js";
 import {
   actionCapabilityMatrix,
   actionCategory,

package/dist/commands/mobile-device-view.js

@@ -1,6 +1,8 @@
 import { execFileSync } from "node:child_process";
-import { resolveMobileToolPath } from "../../library/actions/mobile/platform/tool-paths.mjs";
-import { listConnectedDevices } from "../devices.js";
+import {
+  listConnectedDevices,
+  resolveMobileToolPath
+} from "@farmslot/adapter-rn";
 import { renderDeviceList, scopedDevices } from "./device-target.js";
 import { probeMobileLiveState } from "./status-probe.js";
 function mobileDeviceView(allDevices) {

package/dist/commands/overlay.js

@@ -0,0 +1,110 @@
+import {
+  argValue,
+  hasArg,
+  shellQuoteArg
+} from "@farmslot/recipe-cli/harness";
+import { getAdapterSurface } from "../adapters/surface.js";
+const USAGE = `mm-harness \u2014 install and validate the MetaMask recipe runtime in a checkout.
+
+Run it from inside a MetaMask checkout; the platform (mobile | extension | core | terminal)
+is auto-detected from the repo. Pass --platform only to override.
+
+Commands (one copy-pasteable example each):
+  install   Install the recipe harness runtime overlay into the checkout.
+              mm-harness install
+  verify    Check the harness/runtime is present and healthy (no app launch).
+              mm-harness verify
+  cleanup   Remove the installed harness overlay and restore the checkout.
+              mm-harness cleanup
+
+Options:
+  --platform <mobile|extension|core|terminal>   Override auto-detection (alias: --adapter).
+  --target <repo>                      Checkout to operate on (default: current dir).
+  --json                               Machine-readable summary for agents/scripts.
+  -- <args>                            Forward the rest verbatim to the underlying
+                                       script, e.g. -- --platform ios --preflight-mode fast
+                                       (mobile) or -- --cdp-port 6665 (extension).
+
+Examples:
+  mm-harness install                          # inside a checkout, auto-detected
+  mm-harness verify --platform extension
+  mm-harness cleanup --target ../metamask-mobile
+
+core supports install, verify, and cleanup (headless; no live).`;
+const overlayCommandOptions = {
+  usage: USAGE,
+  install: ({ adapter, target, forward, json }) => hasArg(forward, "--runway") ? handleRunwayInstall(adapter, target, forward, json) : void 0
+};
+async function handleRunwayInstall(adapter, target, forward, json) {
+  const rerunCommand = runwayInstallRerunCommand(adapter, target, forward, json);
+  const surface = getAdapterSurface(adapter);
+  const runtimeDir = argValue(forward, "--runtime-dir");
+  const watcherPort = argValue(forward, "--watcher-port");
+  const result = await surface.runwayProvision.run(target, {
+    json,
+    platform: argValue(forward, "--platform") ?? "ios",
+    branch: argValue(forward, "--branch"),
+    defaultBranch: argValue(forward, "--default-branch"),
+    run: argValue(forward, "--run"),
+    cacheRoot: argValue(forward, "--cache-root"),
+    simulator: argValue(forward, "--simulator") ?? argValue(forward, "--device"),
+    runtime: argValue(forward, "--runtime"),
+    deviceType: argValue(forward, "--device-type"),
+    slot: argValue(forward, "--slot"),
+    watcherPort,
+    runtimeDir,
+    force: hasArg(forward, "--force"),
+    resolveOnly: hasArg(forward, "--resolve-only"),
+    rerunCommand
+  });
+  const provisionedSimulator = typeof result.simulator === "object" && result.simulator ? result.simulator : void 0;
+  const provisionedDevice = typeof provisionedSimulator?.udid === "string" ? provisionedSimulator.udid : typeof provisionedSimulator?.name === "string" ? provisionedSimulator.name : void 0;
+  const next = result.status === "pass" && surface.runwayProvision.launchNext && result.resolveOnly !== true ? `mm-harness launch ${String(result.platform ?? "ios")} --adapter ${adapter} --target ${shellQuoteArg(target)}` + (provisionedDevice ? ` --device ${shellQuoteArg(provisionedDevice)}` : "") : void 0;
+  const output = next ? { ...result, next } : result;
+  if (json) {
+    console.log(JSON.stringify(output, null, 2));
+  } else if (result.status === "pass") {
+    const cache = typeof result.cache === "object" && result.cache ? result.cache : void 0;
+    const simulator = provisionedSimulator;
+    const artifact = typeof result.artifact === "object" && result.artifact ? result.artifact : void 0;
+    if (result.resolveOnly) {
+      console.error(`\u2713 resolved Runway app for ${adapter} ${result.platform ?? ""} run=${artifact?.runId ?? "unknown"} revision=${artifact?.revision ?? "unknown"} artifact=${artifact?.artifactName ?? "unknown"}`);
+    } else {
+      const action = result.skipped ? "already provisioned" : "installed Runway app";
+      console.error(`\u2713 ${action} for ${adapter} ${result.platform ?? ""} simulator=${simulator?.name ?? "unknown"} udid=${simulator?.udid ?? "unknown"} cache=${cache?.status ?? "skip"}`);
+    }
+    if (next) console.error(`  Next: ${next}`);
+  } else {
+    console.error(`\u2717 mm-harness install --runway: ${result.error?.message ?? "runway install failed"}
+  Next: ${result.error?.userAction ?? rerunCommand}`);
+  }
+  return result.exitCode;
+}
+function runwayInstallRerunCommand(adapter, target, forward, json) {
+  const parts = ["mm-harness", "install", "--runway", "--adapter", adapter, "--target", shellQuoteArg(target)];
+  const valueFlags = [
+    "--platform",
+    "--branch",
+    "--default-branch",
+    "--run",
+    "--cache-root",
+    "--simulator",
+    "--device",
+    "--slot",
+    "--watcher-port",
+    "--runtime-dir",
+    "--runtime",
+    "--device-type"
+  ];
+  for (const flag of valueFlags) {
+    const value = argValue(forward, flag);
+    if (value) parts.push(flag, shellQuoteArg(value));
+  }
+  if (hasArg(forward, "--force")) parts.push("--force");
+  if (hasArg(forward, "--resolve-only")) parts.push("--resolve-only");
+  if (json) parts.push("--json");
+  return parts.join(" ");
+}
+export {
+  overlayCommandOptions
+};

package/dist/commands/pin.js

@@ -1,3 +1,4 @@
+import { EXIT } from "@farmslot/recipe-cli/harness";
 import { spawnSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
@@ -6,7 +7,6 @@ import os from "node:os";
 import path from "node:path";
 import { isPin, PIN_MARKER } from "../harness-pin.js";
 import { runnerDir } from "../paths.js";
-import { EXIT } from "./shared.js";
 const PACKAGE_NAME = "@deeeed/metamask-harness";
 const STALE_STAGING_MS = 30 * 60 * 1e3;
 const RUNNER_STATE = /* @__PURE__ */ new Set([".omc", ".omx"]);

package/dist/commands/pr-body.js

@@ -1,10 +1,10 @@
+import { optionFlag, optionString, parseArgs, usageError } from "@farmslot/recipe-cli/harness";
 import fs from "node:fs";
 import path from "node:path";
 import { BODY_FILE, renderPrBody } from "../pr-body/render.js";
-import { optionFlag, optionString, parseArgs, usageError } from "./parse-args.js";
 const USAGE = "Usage: mm-harness pr-body render <task-dir> [--command <text>] [--out <file>] [--json]";
 async function handlePrBody(argv) {
-  const parsed = parseArgs(argv, "pr-body");
+  const parsed = parseArgs(argv);
   const [action, taskArg] = parsed.positional;
   if (action !== "render" || !taskArg) throw usageError(USAGE);
   const taskDir = path.resolve(taskArg);

package/dist/commands/prepare.js

@@ -1,5 +1,4 @@
-import { acquireCheckoutLock, trackCheckoutChild } from "../checkout-lock.js";
-import { recordCommandStage } from "../command-journal.js";
+import { acquireCheckoutLock, trackCheckoutChild, recordCommandStage, color, stripAnsi, harnessExecutable, recipeRuntimeDir, detectAdapter, optionFlag, optionString, parseArgs, targetPath, usageError, EXIT } from "@farmslot/recipe-cli/harness";
 import { spawn } from "node:child_process";
 import { OperationOutputTail } from "@farmslot/recipe-runner/runtime/operation";
 import fs from "node:fs";
@@ -7,14 +6,10 @@ import path from "node:path";
 import {
   READINESS_RECORD
 } from "@farmslot/protocol";
-import { color, stripAnsi } from "../cli-color.js";
 import { runnerProvenance } from "../doctor.js";
-import { detectAdapter } from "../harness.js";
 import { adapterRegistry } from "../adapters/registry.js";
 import { getAdapterSurface } from "../adapters/surface.js";
-import { harnessExecutable, PREPARE_PROGRESS_ARTIFACT, recipeRuntimeDir } from "../paths.js";
-import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
-import { EXIT } from "./shared.js";
+import { PREPARE_PROGRESS_ARTIFACT } from "../paths.js";
 import { formatDuration } from "./status-watch.js";
 import { FeatureFlagSpecError, parseRemoteFlagSpec } from "../feature-flags.js";
 const USAGE = "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--clear-metro] [--artifacts-dir <dir>] [--json]";
@@ -282,7 +277,7 @@ function resolvePlatform(requested, target) {
   );
 }
 async function handlePrepare(argv) {
-  const { options } = parseArgs(argv, "prepare");
+  const { options } = parseArgs(argv);
   const target = targetPath(options);
   if (!fs.existsSync(target)) return handlePrepareLocked(argv);
   const lock = acquireCheckoutLock(target, "prepare");
@@ -298,7 +293,7 @@ async function handlePrepare(argv) {
   }
 }
 async function handlePrepareLocked(argv) {
-  const { options } = parseArgs(argv, "prepare");
+  const { options } = parseArgs(argv);
   const json = optionFlag(options, "json");
   const target = targetPath(options);
   const surface = resolvePlatform(optionString(options, "platform"), target);

package/dist/commands/provision.js

@@ -1,27 +1,18 @@
-import { detectAdapter } from "../harness.js";
+import { detectAdapter, adapterDetectNext, usageOut, applyWatcherPortOption, optionFlag, optionString, shellQuote, shellQuoteArg, targetPath } from "@farmslot/recipe-cli/harness";
 import { assertAdapter } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
-import { ADAPTER_DETECT_NEXT, usageOut } from "./shared.js";
-import {
-  applyWatcherPortOption,
-  optionFlag,
-  optionString,
-  shellQuote,
-  shellQuoteArg,
-  targetPath
-} from "./parse-args.js";
 async function handleProvision({ positional, options, rawArgv }) {
   applyWatcherPortOption(options);
   const json = optionFlag(options, "json");
   const target = targetPath(options);
   const adapter = optionString(options, "adapter") ?? detectAdapter(target);
   if (!adapter) {
-    return usageOut(json, "provision", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
+    return usageOut(json, "provision", `could not detect the MetaMask repo type for ${target}`, adapterDetectNext());
   }
   try {
     assertAdapter(adapter);
   } catch (error) {
-    return usageOut(json, "provision", error instanceof Error ? error.message : String(error), ADAPTER_DETECT_NEXT);
+    return usageOut(json, "provision", error instanceof Error ? error.message : String(error), adapterDetectNext());
   }
   const surface = getAdapterSurface(adapter);
   const rerunCommand = provisionRerunCommand(rawArgv, options, adapter, target);

package/dist/commands/recipe-advice.js

@@ -1,10 +1,9 @@
+import { CliError, isRecord, optionFlag, optionString, usageError, EXIT } from "@farmslot/recipe-cli/harness";
 import fs from "node:fs";
 import path from "node:path";
 import { adviseRecipe } from "../recipe-assistance.js";
 import { resolveAdvisorPolicy } from "../advisor-policy.js";
 import { RECIPE_ADVICE_RUBRIC, RECIPE_PLANNING_RUBRIC } from "../recipe-assistance-rubric.js";
-import { CliError, isRecord, optionFlag, optionString, usageError } from "./parse-args.js";
-import { EXIT } from "./shared.js";
 async function handleRecipeAdvice(options, mode = "review") {
   try {
     return await runRecipeAdvice(options, mode);

package/dist/commands/recipe-quality.js

@@ -1,10 +1,9 @@
+import { EXIT, usageOut, optionFlag, optionString, parseArgs } from "@farmslot/recipe-cli/harness";
 import fs from "node:fs";
 import path from "node:path";
 import {
   buildRecipeQualityArtifact
 } from "@farmslot/agent-runtime";
-import { EXIT, usageOut } from "./shared.js";
-import { optionFlag, optionString, parseArgs } from "./parse-args.js";
 const BUILD_USAGE = "mm-harness recipe-quality build --input <compact.json> --output <path> [--json]";
 const SHORTHAND_USAGE = "mm-harness recipe-quality build --input <compact.json> --output <path> [--json]\n  Shorthand: mm-harness recipe-quality --input <compact.json> --output <path> [--json]\n  Note: apply the quality bar from mm-harness help, then build its compact verdict here.";
 function errorMessage(error) {
@@ -34,7 +33,7 @@ function invalidOut(json, message, source) {
   return EXIT.validation;
 }
 async function handleRecipeQuality(argv) {
-  const { positional, options } = parseArgs(argv, "recipe-quality");
+  const { positional, options } = parseArgs(argv);
   const json = optionFlag(options, "json");
   const action = positional[0];
   if (action === "advise" || action === "plan" || action === "advisor-status") {

package/dist/commands/resolve-extension.js

@@ -1,11 +1,5 @@
+import { adapterOption, optionFlag, optionString, parsePort, targetPath } from "@farmslot/recipe-cli/harness";
 import { resolveExtensionId } from "../adapters/extension/extension-id.js";
-import {
-  adapterOption,
-  optionFlag,
-  optionString,
-  parsePort,
-  targetPath
-} from "./parse-args.js";
 async function handleResolveExtension({ options }) {
   const adapter = adapterOption(options);
   if (adapter !== "extension") throw new Error("resolve-extension currently applies to the extension adapter.");

package/dist/commands/review.js

@@ -1,6 +1,6 @@
+import { detectAdapter, optionFlag, optionString, parseArgs, targetPath, usageError } from "@farmslot/recipe-cli/harness";
 import fs from "node:fs";
 import path from "node:path";
-import { detectAdapter } from "../harness.js";
 import { runnerDir } from "../paths.js";
 import {
   configPath,
@@ -15,7 +15,7 @@ import {
   resolveReference,
   defaultBaseRef
 } from "../review/knowledge.js";
-import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
+import "../adapters/surface.js";
 const EXIT_OK = 0;
 let cachedHarnessVersion;
 function harnessVersion() {
@@ -54,7 +54,7 @@ function resolveReviewContext(options, { fetch = true } = {}) {
   return context;
 }
 function handleHelpReview(argv, harnessVersion2) {
-  const parsed = parseArgs(argv, "help");
+  const parsed = parseArgs(argv);
   const context = resolveReviewContext(parsed.options, { fetch: false });
   const input = {
     adapter: context.adapter,
@@ -73,7 +73,7 @@ function handleHelpReview(argv, harnessVersion2) {
   return EXIT_OK;
 }
 async function handleReview(argv, version = harnessVersion()) {
-  const parsed = parseArgs(argv, "review");
+  const parsed = parseArgs(argv);
   const subcommand = parsed.positional[0];
   if (subcommand !== "checklist") {
     throw usageError("Usage: mm-harness review checklist [--domain <name>] [--since <sha>] [--base <ref>] [--out <file>] [--json]");

package/dist/commands/run-engine.js

@@ -2,59 +2,23 @@ import fs from "node:fs";
 import { mkdtemp } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { validateRuntimeProofPlan } from "../runtime-proof.js";
-import {
-  ensureOverlay,
-  newHealState,
-  parseHeal,
-  recipeRunning,
-  checkHealBounds,
-  conciseFailureForHuman
-} from "../heal-bounds.js";
 import { resolveActionManifest, validateManifest } from "../manifest.js";
 import { getAdapterSurface } from "../adapters/surface.js";
 import { extensionProductConfigBlock } from "../adapters/extension/product-config.js";
-import {
-  importRecipeHarness,
-  importRecipeProtocol,
-  runnerDir,
-  recipeRuntimePath
-} from "../paths.js";
-import { captureHelperSupportsRecordSessionSnapshots } from "../recording-target.js";
-import { startRecipeRecording, stopRecipeRecording } from "../run-recording.js";
+import { importRecipeHarness, importRecipeProtocol, runnerDir } from "../paths.js";
 import {
   resolveMetaMaskParameterValue,
   validateMetaMaskActionInputs
 } from "../metamask-action-validation.js";
-import { gitLibraryProvenance } from "../library-provenance.js";
+import { beginRunDiagnostics, captureExecutionProvenance, captureHelperSupportsRecordSessionSnapshots, executedBrowser, executionProvenanceDrift, finishRunDiagnostics, ProvenanceDriftError, recipeCdpPorts, recipeEnvName, startRecipeRecording, stopRecipeRecording, validateRuntimeProofPlan, writeExecutionProvenance, gitLibraryProvenance, recipeRuntimePath, ensureOverlay, newHealState, parseHeal, recipeRunning, checkHealBounds, conciseFailureForHuman, EXIT, actionManifestPathOption, optionString, optionFlag, optionStrings, isRecord, shellQuoteArg, targetPath, usageError } from "@farmslot/recipe-cli/harness";
 import { runnableLibraryRecipes } from "../discovery.js";
 import { recipeComposition } from "@farmslot/recipe-cli";
-import {
-  captureExecutionProvenance,
-  executionProvenanceDrift,
-  ProvenanceDriftError,
-  writeExecutionProvenance
-} from "../execution-provenance.js";
+import { consoleClassifier } from "../console-classifier.js";
 import {
   authorizeTrustedMutationPlan,
   loadTrustedMutationBase
 } from "../funding-execution-context.js";
-import {
-  beginRunDiagnostics,
-  finishRunDiagnostics
-} from "../run-diagnostics.js";
-import { executedBrowser, recipeCdpPorts } from "./run-report.js";
-import { EXIT } from "./shared.js";
-import {
-  actionManifestPathOption,
-  optionString,
-  optionFlag,
-  optionStrings,
-  isRecord,
-  shellQuoteArg,
-  targetPath,
-  usageError
-} from "./parse-args.js";
+const RUNNER_INCLUDES = ["src", "adapters", "library", "bin", "dist", "package.json"];
 async function runRecipe(adapter, recipe, artifactsDir, projectRoot, actionManifestPath, runtimeOptions = {}, preflightedExecution, effectsState = newHealState()) {
   const restoreRuntimeEnvironment = activateRecipeRuntimeEnvironment(
     adapter,
@@ -144,7 +108,7 @@ async function runRecipe(adapter, recipe, artifactsDir, projectRoot, actionManif
     if (executionError !== void 0) throw executionError;
     if (recordingError !== void 0) throw recordingError;
     if (!result) throw new Error("Recipe execution returned no result.");
-    const finalized = await finishRunDiagnostics(diagnosticBaseline, result);
+    const finalized = await finishRunDiagnostics(diagnosticBaseline, result, consoleClassifier);
     persistRunEffects(
       finalized.summaryPath,
       finalized.artifactManifestPath,
@@ -219,7 +183,7 @@ async function resolveRecipeExecution(adapter, recipe, artifactsDir, projectRoot
     adapter,
     actionManifestPath,
     librarySources,
-    process.env.METAMASK_RECIPE_LIVE_ADAPTER_DIR
+    process.env[recipeEnvName("LIVE_ADAPTER_DIR")]
   );
   const { createMetaMaskRunner } = await import("../runner.js");
   const recipeDocument = runtimeRecipeDocument(recipe, absoluteRecipePath);
@@ -258,7 +222,7 @@ async function resolveRecipeExecution(adapter, recipe, artifactsDir, projectRoot
     env: {
       ...recipeProcessEnvironment(),
       ...recipeRunEnv(adapter, runtimeOptions),
-      METAMASK_RECIPE_ACTION_SOURCE_MAP: actionSourceMap(actionSources)
+      [recipeEnvName("ACTION_SOURCE_MAP")]: actionSourceMap(actionSources)
     },
     recordVideo: useFramedExtensionRecording ? false : recordVideo,
     ...trust,
@@ -285,7 +249,8 @@ async function resolveRecipeExecution(adapter, recipe, artifactsDir, projectRoot
       recipeRuntimePath(projectRoot, "operations"),
       recipeRuntimePath(projectRoot, "lock-members")
     ],
-    helperPaths: commandHelperPaths(recipeDocument ?? recipe, projectRoot)
+    helperPaths: commandHelperPaths(recipeDocument ?? recipe, projectRoot),
+    runnerIncludes: RUNNER_INCLUDES
   };
   const startProvenance = await captureExecutionProvenance(
     provenanceInput,
@@ -444,8 +409,7 @@ const RUN_ENV_KEYS = [
   "CDP_PORT",
   "RECIPE_CDP_PORT",
   "WATCHER_PORT",
-  "METRO_PORT",
-  "METAMASK_RECIPE_EXTENSION_AUTOLAUNCH"
+  "METRO_PORT"
 ];
 function activateRecipeRuntimeEnvironment(adapter, projectRoot, runtimeOptions) {
   const surface = getAdapterSurface(adapter);
@@ -467,10 +431,7 @@ function activateRecipeRuntimeEnvironment(adapter, projectRoot, runtimeOptions)
     process.env.WATCHER_PORT = runtimeOptions.watcherPort;
     process.env.METRO_PORT = runtimeOptions.watcherPort;
   }
-  if (runtimeOptions.launchExistingDist) {
-    process.env.METAMASK_RECIPE_EXTENSION_AUTOLAUNCH = "1";
-  }
-  surface.run?.activateEnv?.(projectRoot);
+  surface.run?.activateEnv?.(projectRoot, runtimeOptions);
   return () => {
     for (const [key, value] of Object.entries(previousEnv)) restoreEnv(key, value);
   };
@@ -493,7 +454,7 @@ function recipeRunEnv(adapter, runtimeOptions = {}) {
     FARMSLOT_SLOT_ID: runtimeOptions.slot ?? process.env.FARMSLOT_SLOT_ID,
     SLOT_ID: runtimeOptions.slot ?? process.env.SLOT_ID,
     PLATFORM: process.env.PLATFORM,
-    MM_HARNESS_EXPLICIT_PLATFORM: process.env.MM_HARNESS_EXPLICIT_PLATFORM
+    RECIPE_RN_EXPLICIT_PLATFORM: process.env.RECIPE_RN_EXPLICIT_PLATFORM
   };
   const childEnv = getAdapterSurface(adapter).run?.childEnv;
   return childEnv ? childEnv(base) : base;

package/dist/commands/run.js

@@ -1,20 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { importRecipeHarness, walletFixturePath } from "../paths.js";
-import { color } from "../cli-color.js";
-import { recipeRunning } from "../heal-bounds.js";
-import { checkoutBusyOut, EXIT, usageOut, writeInteractiveProgress } from "./shared.js";
-import {
-  optionFlag,
-  optionString,
-  resolveAdapter,
-  runtimeOptionsFromCli,
-  isRecord,
-  parseRecipeParamAssignments,
-  shellQuote,
-  targetPath,
-  usageError
-} from "./parse-args.js";
+import { formatRunDiagnosticsForHuman, indexProductProvenanceArtifact, ProvenanceDriftError, readRunDiagnosticsDocument, recipeRunOptionsFromCli, recipeTrustFailure, writeRunReport, color, acquireCheckoutLock, JsonStreamWriter, recordCommandEvidence, recipeRunning, checkoutBusyOut, EXIT, usageOut, writeInteractiveProgress, optionFlag, optionString, resolveAdapter, isRecord, parseRecipeParamAssignments, shellQuote, targetPath, usageError } from "@farmslot/recipe-cli/harness";
 import {
   countRecipeNodes,
   emitHealViolation,
@@ -28,16 +15,7 @@ import {
 import { handleDescribeRecipe, handleListExecutables } from "./list-executables.js";
 import { applyDeviceTargeting } from "./device-target.js";
 import { getAdapterSurface } from "../adapters/surface.js";
-import {
-  indexProductProvenanceArtifact,
-  writeRunReport
-} from "./run-report.js";
-import { acquireCheckoutLock } from "../checkout-lock.js";
-import { JsonStreamWriter } from "../json-stream.js";
-import { formatRunDiagnosticsForHuman, readRunDiagnosticsDocument } from "../run-diagnostics.js";
-import { recipeTrustFailure } from "../recipe-security.js";
-import { ProvenanceDriftError } from "../execution-provenance.js";
-import { recordCommandEvidence } from "../command-journal.js";
+import { fundingOptionsFromCli } from "../funding-execution-context.js";
 import { actionLibraryContextArgs, resolveActionCapabilityMatrix } from "./manifest.js";
 import { missingActionCapabilities } from "@farmslot/recipe-cli";
 import {
@@ -266,7 +244,8 @@ async function handleRunInner({ positional, options }, stream) {
   let networkObservation;
   let performanceObservation;
   const runtimeOptions = {
-    ...runtimeOptionsFromCli(options),
+    ...recipeRunOptionsFromCli(adapter, options),
+    ...fundingOptionsFromCli(options),
     params,
     ...librarySources ? { librarySources } : {},
     stdoutIsMachineContract: machine,

package/dist/commands/runtime-decision.js

@@ -1,10 +1,5 @@
+import { adapterOption, applyRuntimeDirOption, optionFlag, targetPath } from "@farmslot/recipe-cli/harness";
 import { getAdapterSurface } from "../adapters/surface.js";
-import {
-  adapterOption,
-  applyRuntimeDirOption,
-  optionFlag,
-  targetPath
-} from "./parse-args.js";
 async function handleRuntimeDecision({ options }) {
   applyRuntimeDirOption(options);
   const adapter = adapterOption(options);

package/dist/commands/runtime-health.js

@@ -1,10 +1,4 @@
-import {
-  adapterOption,
-  optionFlag,
-  optionString,
-  parsePort,
-  targetPath
-} from "./parse-args.js";
+import { adapterOption, optionFlag, optionString, parsePort, targetPath } from "@farmslot/recipe-cli/harness";
 async function handleRuntimeHealth({ options }) {
   const adapter = adapterOption(options);
   if (adapter !== "extension") throw new Error("runtime-health currently applies to the extension adapter.");

package/dist/commands/runtime-launch.js

@@ -1,5 +1,4 @@
-import { checkoutBusyOut, spawnScriptStreaming } from "./shared.js";
-import { acquireCheckoutLock } from "../checkout-lock.js";
+import { acquireCheckoutLock, recipeHarnessPath, checkoutBusyOut, spawnScriptStreaming, adapterOption, isRecord, optionFlag, optionString, parsePort, shellQuote, targetPath, usageError } from "@farmslot/recipe-cli/harness";
 import fs from "node:fs";
 import path from "node:path";
 import {
@@ -10,19 +9,8 @@ import {
   clearMobileReleaseArtifactState,
   writeMobileReleaseArtifactState
 } from "../adapters/mobile/release-artifact-state.js";
-import { recipeHarnessPath } from "../paths.js";
 import { extensionDepsBlock } from "./launch/extension.js";
 import { isExtensionDistStale } from "../adapters/extension/runtime-decision.js";
-import {
-  adapterOption,
-  isRecord,
-  optionFlag,
-  optionString,
-  parsePort,
-  shellQuote,
-  targetPath,
-  usageError
-} from "./parse-args.js";
 import { FeatureFlagSpecError, parseRemoteFlagSpec } from "../feature-flags.js";
 async function handleRuntimeLaunch(args) {
   const target = targetPath(args.options);

package/dist/commands/self-test.js

@@ -1,13 +1,9 @@
+import { optionFlag, optionString, requiredOption } from "@farmslot/recipe-cli/harness";
 import { mkdtemp } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { loadActionManifest, validateManifest } from "../manifest.js";
 import { recipePath, runnerDir } from "../paths.js";
-import {
-  optionFlag,
-  optionString,
-  requiredOption
-} from "./parse-args.js";
 import { runRecipe } from "./run-engine.js";
 async function handleSelfTest({ options }) {
   const result = await runSelfTest(options);
@@ -28,7 +24,7 @@ async function runSelfTest(options) {
       const smokeRecipe = recipePath(`${adapter}/runner/smoke.recipe.json`);
       const artifactsDir = path.join(root, adapter);
       const result = await runRecipe(adapter, smokeRecipe, artifactsDir, runnerDir, void 0, {
-        skipExtensionRuntimePrepare: true
+        platform: { skipExtensionRuntimePrepare: true }
       });
       runs.push({ adapter, manifestValidation: manifestValidation.summary, artifactsDir, result });
     }

package/dist/commands/status-watch.js

@@ -1,14 +1,13 @@
 import os from "node:os";
 import path from "node:path";
 import { isTerminalWorkerSignalStatus } from "@farmslot/protocol";
-import { color } from "../cli-color.js";
+import { color, EXIT } from "@farmslot/recipe-cli/harness";
 import {
   CHECKLIST_LABEL_LIMIT,
   collectTaskView,
   findTaskDir,
   TASK_SILENT_AFTER_MS
 } from "../task-view.js";
-import { EXIT } from "./shared.js";
 const REFRESH_MS = 2e3;
 const CLEAR_SCREEN = "\x1B[2J\x1B[H";
 const HIDE_CURSOR = "\x1B[?25l";