@deeeed/metamask-harness 0.17.4 → 0.18.0

package/dist/commands/run-engine.js

@@ -9,8 +9,9 @@ import {
   recipeRunning,
   checkHealBounds
 } from "../heal-bounds.js";
-import { loadActionManifest, validateManifest } from "../manifest.js";
+import { resolveActionManifest, validateManifest } from "../manifest.js";
 import { getAdapterSurface } from "../adapters/surface.js";
+import { extensionProductConfigBlock } from "../adapters/extension/product-config.js";
 import {
   importRecipeHarness,
   importRecipeProtocol,
@@ -24,7 +25,7 @@ import {
   beginRunDiagnostics,
   finishRunDiagnostics
 } from "../run-diagnostics.js";
-import { EXIT } from "./shared.js";
+import { EXIT, spawnScriptStreaming } from "./shared.js";
 import {
   actionManifestPathOption,
   optionString,
@@ -33,50 +34,38 @@ import {
   targetPath,
   usageError
 } from "./parse-args.js";
-async function runRecipe(adapter, recipe, artifactsDir, projectRoot, actionManifestPath, runtimeOptions = {}) {
-  const previousCdpPort = process.env.CDP_PORT;
-  const previousRecipeCdpPort = process.env.RECIPE_CDP_PORT;
-  const previousWatcherPort = process.env.WATCHER_PORT;
-  const previousMetroPort = process.env.METRO_PORT;
-  const previousExtensionAutolaunch = process.env.METAMASK_RECIPE_EXTENSION_AUTOLAUNCH;
-  getAdapterSurface(adapter).resolveSlotPorts(projectRoot);
-  if (runtimeOptions.cdpPort) {
-    process.env.CDP_PORT = runtimeOptions.cdpPort;
-    process.env.RECIPE_CDP_PORT = runtimeOptions.cdpPort;
-  }
-  if (runtimeOptions.watcherPort) {
-    process.env.WATCHER_PORT = runtimeOptions.watcherPort;
-    process.env.METRO_PORT = runtimeOptions.watcherPort;
-  }
-  if (runtimeOptions.launchExistingDist) {
-    process.env.METAMASK_RECIPE_EXTENSION_AUTOLAUNCH = "1";
+function requireRecipeTrustResolver(harness) {
+  if (typeof harness.resolveRecipeTrustInput !== "function") {
+    throw usageError(
+      "Recipe trust enforcement requires a newer @farmslot/recipe-harness than the installed package. Next: mm-harness update"
+    );
   }
+  return harness.resolveRecipeTrustInput;
+}
+async function runRecipe(adapter, recipe, artifactsDir, projectRoot, actionManifestPath, runtimeOptions = {}, preflightedExecution) {
+  const restoreRuntimeEnvironment = activateRecipeRuntimeEnvironment(
+    adapter,
+    projectRoot,
+    runtimeOptions
+  );
   try {
+    const execution = preflightedExecution ?? await resolveRecipeExecution(
+      adapter,
+      recipe,
+      artifactsDir,
+      projectRoot,
+      actionManifestPath,
+      runtimeOptions
+    );
+    const { runner, runRequest, absoluteArtifactsDir, useFramedExtensionRecording } = execution;
+    await runner.preflight(runRequest);
     await prepareRuntimeIfNeeded(adapter, projectRoot, runtimeOptions);
-    const absoluteArtifactsDir = path.resolve(artifactsDir);
     const diagnosticBaseline = await beginRunDiagnostics(adapter, projectRoot);
-    const recordVideo = runtimeOptions.recordVideo ?? false;
-    const useFramedExtensionRecording = adapter === "extension" && recordVideo === "full-run" && captureHelperSupportsRecordSessionSnapshots(projectRoot);
     const recording = useFramedExtensionRecording ? await startRecipeRecording(adapter, projectRoot, absoluteArtifactsDir, {
       record: true,
       cdpPort: runtimeOptions.cdpPort
     }) : void 0;
     try {
-      const manifest = loadActionManifest(adapter, actionManifestPath);
-      await validateManifest(manifest);
-      const { createMetaMaskRunner } = await import("../runner.js");
-      const runner = await createMetaMaskRunner(adapter, manifest, {
-        quietStdout: runtimeOptions.stdoutIsMachineContract === true,
-        onActionEvent: runtimeOptions.onActionEvent
-      });
-      const runRequest = {
-        recipePath: path.resolve(recipe),
-        artifactsDir: absoluteArtifactsDir,
-        projectRoot,
-        env: recipeRunEnv(adapter, runtimeOptions),
-        recordVideo: useFramedExtensionRecording ? false : recordVideo,
-        ...runtimeOptions.librarySources ? { librarySources: runtimeOptions.librarySources } : {}
-      };
       let result;
       try {
         result = await runner.run(runRequest);
@@ -92,12 +81,136 @@ async function runRecipe(adapter, recipe, artifactsDir, projectRoot, actionManif
       await stopRecipeRecording(recording);
     }
   } finally {
+    restoreRuntimeEnvironment();
+  }
+}
+async function preflightRecipe(adapter, recipe, artifactsDir, projectRoot, actionManifestPath, runtimeOptions = {}) {
+  const restoreRuntimeEnvironment = activateRecipeRuntimeEnvironment(
+    adapter,
+    projectRoot,
+    runtimeOptions
+  );
+  try {
+    const execution = await resolveRecipeExecution(
+      adapter,
+      recipe,
+      artifactsDir,
+      projectRoot,
+      actionManifestPath,
+      runtimeOptions
+    );
+    await execution.runner.preflight(execution.runRequest);
+    return execution;
+  } finally {
+    restoreRuntimeEnvironment();
+  }
+}
+async function resolveRecipeExecution(adapter, recipe, artifactsDir, projectRoot, actionManifestPath, runtimeOptions) {
+  const absoluteArtifactsDir = path.resolve(artifactsDir);
+  const absoluteRecipePath = typeof recipe === "string" ? path.resolve(recipe) : void 0;
+  const recordVideo = runtimeOptions.recordVideo ?? false;
+  const resolveRecipeTrustInput = requireRecipeTrustResolver(await importRecipeHarness());
+  const trust = resolveRecipeTrustInput({
+    sourceTrust: runtimeOptions.source?.trust,
+    sourceKind: runtimeOptions.source?.kind,
+    sourceName: runtimeOptions.source?.name,
+    sourceDigest: runtimeOptions.source?.digest,
+    approvalDigest: runtimeOptions.approval?.planDigest
+  });
+  const librarySources = executionLibrarySources(
+    runtimeOptions.librarySources,
+    trust.source?.trust ?? "trusted"
+  );
+  const { manifest, actionSources } = await resolveActionManifest(
+    adapter,
+    actionManifestPath,
+    librarySources,
+    process.env.METAMASK_RECIPE_LIVE_ADAPTER_DIR
+  );
+  const { createMetaMaskRunner } = await import("../runner.js");
+  const runner = await createMetaMaskRunner(adapter, manifest, {
+    quietStdout: runtimeOptions.stdoutIsMachineContract === true,
+    autoHud: trust.source && trust.source.trust !== "trusted" ? false : runtimeOptions.autoHud,
+    onActionEvent: runtimeOptions.onActionEvent,
+    actionSources,
+    // A direct engineer invocation is the explicit trust boundary for a
+    // task-local adapter. Inherited gateway provenance remains authoritative,
+    // so an untrusted worker cannot promote itself with CLI flags.
+    trustTaskActions: (trust.source?.trust ?? "trusted") === "trusted"
+  });
+  const useFramedExtensionRecording = adapter === "extension" && recordVideo === "full-run" && trust.source?.trust !== "untrusted" && trust.source?.trust !== "unknown" && captureHelperSupportsRecordSessionSnapshots(projectRoot);
+  return {
+    runner,
+    absoluteArtifactsDir,
+    useFramedExtensionRecording,
+    runRequest: {
+      ...absoluteRecipePath ? { recipePath: absoluteRecipePath } : { recipeDocument: recipe },
+      artifactsDir: absoluteArtifactsDir,
+      projectRoot,
+      inheritProcessEnv: false,
+      env: {
+        ...recipeProcessEnvironment(),
+        ...recipeRunEnv(adapter, runtimeOptions),
+        METAMASK_RECIPE_ACTION_SOURCE_MAP: actionSourceMap(actionSources)
+      },
+      recordVideo: useFramedExtensionRecording ? false : recordVideo,
+      ...trust,
+      ...librarySources ? { librarySources } : {}
+    }
+  };
+}
+function recipeProcessEnvironment() {
+  const env = { ...process.env };
+  delete env.MM_HARNESS_CHECKOUT_LOCK_TOKEN;
+  return env;
+}
+function executionLibrarySources(sources, invocationTrust) {
+  return sources?.map((source) => {
+    if (source.name === "metamask" || source.provenance?.trust === "trusted") return source;
+    return {
+      ...source,
+      provenance: {
+        ...source.provenance,
+        kind: source.provenance?.kind ?? "library",
+        trust: invocationTrust === "trusted" ? "trusted" : "unknown",
+        name: source.provenance?.name ?? source.name ?? path.basename(source.root)
+      }
+    };
+  });
+}
+function activateRecipeRuntimeEnvironment(adapter, projectRoot, runtimeOptions) {
+  const previousCdpPort = process.env.CDP_PORT;
+  const previousRecipeCdpPort = process.env.RECIPE_CDP_PORT;
+  const previousWatcherPort = process.env.WATCHER_PORT;
+  const previousMetroPort = process.env.METRO_PORT;
+  const previousExtensionAutolaunch = process.env.METAMASK_RECIPE_EXTENSION_AUTOLAUNCH;
+  getAdapterSurface(adapter).resolveSlotPorts(projectRoot);
+  if (runtimeOptions.cdpPort) {
+    process.env.CDP_PORT = runtimeOptions.cdpPort;
+    process.env.RECIPE_CDP_PORT = runtimeOptions.cdpPort;
+  }
+  if (runtimeOptions.watcherPort) {
+    process.env.WATCHER_PORT = runtimeOptions.watcherPort;
+    process.env.METRO_PORT = runtimeOptions.watcherPort;
+  }
+  if (runtimeOptions.launchExistingDist) {
+    process.env.METAMASK_RECIPE_EXTENSION_AUTOLAUNCH = "1";
+  }
+  return () => {
     restoreEnv("CDP_PORT", previousCdpPort);
     restoreEnv("RECIPE_CDP_PORT", previousRecipeCdpPort);
     restoreEnv("WATCHER_PORT", previousWatcherPort);
     restoreEnv("METRO_PORT", previousMetroPort);
     restoreEnv("METAMASK_RECIPE_EXTENSION_AUTOLAUNCH", previousExtensionAutolaunch);
+  };
+}
+function actionSourceMap(sources) {
+  const roots = {};
+  for (const [action, source] of sources) {
+    if (source.tier === "official") continue;
+    roots[action] = source.implementationRoot ?? (source.tier === "task" ? path.join(path.dirname(source.manifestPath), "actions") : path.join(path.dirname(path.dirname(source.manifestPath)), "actions"));
   }
+  return JSON.stringify(roots);
 }
 function recipeRunEnv(adapter, runtimeOptions = {}) {
   const base = {
@@ -169,12 +282,16 @@ function resolveRunRecipeArg(recipeArg, adapter, librarySources) {
           const file = path.join(source.root, "recipes", candidate);
           if (isRecipeFile(file)) return { recipeFile: file };
         }
+        const listedFile = recipeFileByPublicName(path.join(source.root, "recipes"), recipeArg, adapter);
+        if (listedFile) return { recipeFile: listedFile };
       }
     } else {
       for (const candidate of candidates) {
         const file = recipePath(candidate);
         if (isRecipeFile(file)) return { recipeFile: file };
       }
+      const listedFile = recipeFileByPublicName(recipePath(""), recipeArg, adapter);
+      if (listedFile) return { recipeFile: listedFile };
     }
   }
   const packagedNames = libraryRecipeNames(adapter);
@@ -183,6 +300,155 @@ function resolveRunRecipeArg(recipeArg, adapter, librarySources) {
   const suffix = packagedNames.length > 0 ? ` Library recipes for ${adapter}: ${packagedNames.join(", ")} (mm-harness run <name>).` : ` The packaged library has no recipes for ${adapter}.`;
   return { notFound: notFoundCore + suffix };
 }
+function readRecipeMetadata(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return {
+      ...typeof parsed.title === "string" && parsed.title.trim() ? { title: parsed.title.trim() } : {},
+      ...typeof parsed.description === "string" && parsed.description.trim() ? { description: parsed.description.trim() } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+function recipeNameFromFile(file, adapter) {
+  if (!file.endsWith(".recipe.json")) return void 0;
+  let name = file.slice(0, -".recipe.json".length).replace(/[\\/]/gu, ".");
+  const scope = name.split(".").pop() ?? "";
+  if (["mobile", "extension", "core"].includes(scope) && scope !== adapter) return void 0;
+  const scoped = scope === adapter;
+  if (scoped) name = name.slice(0, -(adapter.length + 1));
+  return { name, scoped };
+}
+function recipeFileByPublicName(recipesRoot, recipeName, adapter) {
+  let match;
+  let files;
+  try {
+    files = listRecipeFiles(recipesRoot);
+  } catch {
+    return void 0;
+  }
+  for (const file of files) {
+    const candidate = recipeNameFromFile(file, adapter);
+    if (!candidate || candidate.name !== recipeName) continue;
+    if (!match || candidate.scoped && !match.scoped) match = { file, scoped: candidate.scoped };
+  }
+  return match ? path.join(recipesRoot, match.file) : void 0;
+}
+function listRunnableRecipes(adapter, librarySources) {
+  const sources = librarySources && librarySources.length > 0 ? librarySources : [{ name: "metamask", root: recipePath("") }];
+  const resolved = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const recipesRoot = librarySources && librarySources.length > 0 ? path.join(source.root, "recipes") : source.root;
+    let files;
+    try {
+      files = listRecipeFiles(recipesRoot);
+    } catch {
+      continue;
+    }
+    const sourceName = source.name ?? path.basename(source.root);
+    const withinSource = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const candidate = recipeNameFromFile(file, adapter);
+      if (!candidate) continue;
+      const existing = withinSource.get(candidate.name);
+      if (!existing || candidate.scoped && !existing.scoped) {
+        withinSource.set(candidate.name, { file, scoped: candidate.scoped });
+      }
+    }
+    for (const [name, candidate] of withinSource) {
+      const winner = resolved.get(name);
+      if (winner) winner.shadows.push(sourceName);
+      else resolved.set(name, {
+        name,
+        source: sourceName,
+        file: path.join("recipes", candidate.file),
+        shadows: [],
+        ...readRecipeMetadata(path.join(recipesRoot, candidate.file))
+      });
+    }
+  }
+  return [...resolved.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+function describeRunnableRecipe(recipeArg, adapter, librarySources) {
+  const resolved = resolveRunRecipeArg(recipeArg, adapter, librarySources);
+  if ("notFound" in resolved) return resolved;
+  let document;
+  try {
+    document = JSON.parse(fs.readFileSync(resolved.recipeFile, "utf8"));
+  } catch (error) {
+    return {
+      unreadable: `could not read recipe ${resolved.recipeFile}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (!isRecord(document)) {
+    return { unreadable: `recipe ${resolved.recipeFile} must contain a JSON object.` };
+  }
+  const listed = listRunnableRecipes(adapter, librarySources).find((candidate) => candidate.name === recipeArg);
+  const composition = recipeComposition(document);
+  return {
+    recipe: {
+      name: listed?.name ?? recipeArg,
+      source: listed?.source ?? "file",
+      file: listed?.file ?? resolved.recipeFile,
+      shadows: listed?.shadows ?? [],
+      ...typeof document.title === "string" && document.title.trim() ? { title: document.title.trim() } : {},
+      ...typeof document.description === "string" && document.description.trim() ? { description: document.description.trim() } : {},
+      adapter,
+      path: resolved.recipeFile,
+      ...Object.prototype.hasOwnProperty.call(document, "schema_version") ? { schemaVersion: document.schema_version } : {},
+      inputs: isRecord(document.inputs) ? redactRecipeInputs(document.inputs) : {},
+      inputOverridesSupported: false,
+      actions: composition.actions,
+      actionsComplete: composition.actionsComplete,
+      flows: composition.flows
+    }
+  };
+}
+function recipeComposition(recipe) {
+  const actions = /* @__PURE__ */ new Set();
+  const flows = /* @__PURE__ */ new Set();
+  const visitNode = (value) => {
+    if (!isRecord(value) || typeof value.action !== "string") return;
+    actions.add(value.action);
+    if (value.action === "call" && typeof value.ref === "string") flows.add(value.ref);
+  };
+  const visitWorkflow = (value) => {
+    if (!isRecord(value)) return;
+    for (const phase of ["setup", "teardown"]) {
+      if (Array.isArray(value[phase])) value[phase].forEach(visitNode);
+    }
+    if (isRecord(value.nodes)) Object.values(value.nodes).forEach(visitNode);
+  };
+  visitNode(recipe.startState);
+  if (isRecord(recipe.validate)) visitWorkflow(recipe.validate.workflow);
+  const inlineFlows = isRecord(recipe.flows) ? recipe.flows : {};
+  const visitedFlows = /* @__PURE__ */ new Set();
+  let actionsComplete = true;
+  for (const ref of flows) {
+    if (visitedFlows.has(ref)) continue;
+    visitedFlows.add(ref);
+    const flow = inlineFlows[ref];
+    if (flow !== void 0) {
+      visitWorkflow(isRecord(flow) && isRecord(flow.workflow) ? flow.workflow : flow);
+    } else {
+      actionsComplete = false;
+    }
+  }
+  return {
+    actions: [...actions].sort(),
+    actionsComplete,
+    flows: [...flows].sort()
+  };
+}
+function redactRecipeInputs(inputs) {
+  return Object.fromEntries(
+    Object.entries(inputs).map(([key, value]) => [
+      key,
+      /(?:password|passphrase|secret|token|credential|mnemonic|seed|srp|vault|api[_-]?key|private[_-]?key)/iu.test(key) ? "<redacted>" : isRecord(value) ? redactRecipeInputs(value) : Array.isArray(value) ? value.map((entry) => isRecord(entry) ? redactRecipeInputs(entry) : entry) : value
+    ])
+  );
+}
 function libraryRecipeNames(adapter) {
   let entries;
   try {
@@ -190,11 +456,7 @@ function libraryRecipeNames(adapter) {
   } catch {
     return [];
   }
-  const scopes = ["mobile", "extension", "core"];
-  const names = entries.filter((f) => f.endsWith(".recipe.json")).map((f) => f.slice(0, -".recipe.json".length).replace(/[\\/]/gu, ".")).filter((n) => {
-    const scope = n.split(".").pop() ?? "";
-    return !scopes.includes(scope) || scope === adapter;
-  }).map((n) => n.endsWith(`.${adapter}`) ? n.slice(0, -(adapter.length + 1)) : n);
+  const names = entries.map((file) => recipeNameFromFile(file, adapter)?.name).filter((name) => Boolean(name));
   return [...new Set(names)].sort();
 }
 function recipeNameCandidates(recipeArg, adapter) {
@@ -259,7 +521,11 @@ async function validateRunRecipeStatic(recipeArg, adapter, options) {
     };
   }
   const findings = [];
-  const manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
+  const { manifest } = await resolveActionManifest(
+    adapter,
+    optionString(options, "actionManifest"),
+    librarySources
+  );
   let manifestOk = true;
   try {
     await validateManifest(manifest);
@@ -309,7 +575,12 @@ async function validateRunRecipeStatic(recipeArg, adapter, options) {
 async function actionInsteadOfRecipeHint(recipeArg, adapter, options) {
   if (recipeArg.includes("/") || recipeArg.includes(path.sep)) return "";
   try {
-    const manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
+    const librarySources = await resolveMetaMaskLibrarySources(optionString(options, "library"));
+    const { manifest } = await resolveActionManifest(
+      adapter,
+      optionString(options, "actionManifest"),
+      librarySources
+    );
     const { getRecipeActionManifestActionNames } = await importRecipeProtocol();
     const actions = getRecipeActionManifestActionNames(manifest);
     const matches = actions.includes(recipeArg) ? [recipeArg] : actions.filter((name) => name.split(".").pop() === recipeArg);
@@ -330,16 +601,33 @@ async function resolveMetaMaskLibrarySources(libraryEntry) {
   if (typeof harness.resolveRecipeLibrarySources !== "function") {
     if (libraryEntry) {
       throw usageError(
-        "--library requires @farmslot/recipe-harness >= 0.3.3 (recipe-library support / resolveRecipeLibrarySources). The pinned 0.3.0 lacks it, and npm 0.3.2 still does not export it \u2014 recipe-library support is PENDING PUBLISH from farmslot."
+        "--library requires a current @farmslot/recipe-harness installation that exports recipe-library support. Next: mm-harness update"
       );
     }
     return void 0;
   }
+  const cliEntries = typeof libraryEntry === "string" ? [libraryEntry] : libraryEntry ? [...libraryEntry] : [];
   const sources = await harness.resolveRecipeLibrarySources(
-    libraryEntry ? { cliEntries: [libraryEntry] } : void 0
+    cliEntries.length > 0 ? { cliEntries } : void 0
   );
-  sources.push({ name: "metamask", root: path.join(runnerDir, "library") });
-  return sources;
+  const canonicalRoot = path.resolve(runnerDir, "library");
+  const configuredCanonical = sources.find((source) => source.name === "metamask");
+  if (configuredCanonical && path.resolve(configuredCanonical.root) !== canonicalRoot) {
+    throw usageError(
+      `Recipe library source metamask must resolve to ${canonicalRoot}; got ${path.resolve(configuredCanonical.root)}.`
+    );
+  }
+  if (!sources.some((source) => path.resolve(source.root) === canonicalRoot)) {
+    sources.push({ name: "metamask", root: canonicalRoot });
+  }
+  return sources.map((source) => ({
+    ...source,
+    provenance: source.provenance ?? {
+      kind: source.name === "metamask" ? "bundled" : "library",
+      trust: source.name === "metamask" ? "trusted" : "unknown",
+      name: source.name ?? path.basename(source.root)
+    }
+  }));
 }
 function synthesizeOneNodeRecipe(action, args) {
   return {
@@ -350,7 +638,12 @@ function synthesizeOneNodeRecipe(action, args) {
       workflow: {
         entry: "call",
         nodes: {
-          call: { action, ...args, next: "done", intent: `Call ${action} in isolation` },
+          call: {
+            ...args,
+            action,
+            next: "done",
+            intent: typeof args.intent === "string" ? args.intent : `Call ${action} in isolation`
+          },
           done: { action: "end", status: "pass" }
         }
       }
@@ -358,7 +651,8 @@ function synthesizeOneNodeRecipe(action, args) {
   };
 }
 async function runOneNode(adapter, action, args, target, actionManifest) {
-  const manifest = loadActionManifest(adapter, actionManifest);
+  const librarySources = await resolveMetaMaskLibrarySources(void 0);
+  const { manifest } = await resolveActionManifest(adapter, actionManifest, librarySources);
   const recipe = synthesizeOneNodeRecipe(action, args);
   const validation = await validateRecipeAdapterAware(recipe, manifest);
   if (validation.status === "invalid") return { status: "fail" };
@@ -367,7 +661,7 @@ async function runOneNode(adapter, action, args, target, actionManifest) {
   fs.writeFileSync(recipeFile, `${JSON.stringify(recipe, null, 2)}
 `);
   const result = await runRecipe(adapter, recipeFile, path.join(scratch, "artifacts"), target, actionManifest, {
-    librarySources: await resolveMetaMaskLibrarySources(void 0),
+    librarySources,
     stdoutIsMachineContract: true
   });
   return { status: result.status === "pass" ? "pass" : "fail" };
@@ -495,21 +789,27 @@ async function ensureMobileProofRuntime(target, heal, state, json, deps = {}) {
     return { status: result2.status === "pass" ? 0 : EXIT.runtime, output: result2.status };
   });
   const result = await restart();
-  const recorded = result.status === 0 && record(initial.fingerprint);
+  const platform = resolveRunMobilePlatform();
+  const bridge = result.status === 0 ? await (deps.waitForBridge ? deps.waitForBridge() : spawnScriptStreaming(
+    path.join(runnerDir, "adapters/mobile/wait-for-bridge.sh"),
+    ["--target", target, "--platform", platform],
+    target
+  )) : { status: result.status, output: result.output };
+  const recorded = result.status === 0 && bridge.status === 0 && record(initial.fingerprint);
   const verified = recorded ? check() : initial;
-  if (result.status !== 0 || !recorded || verified.status !== "current") {
-    const message = "Mobile source restart did not produce a current loaded-source baseline.";
+  if (result.status !== 0 || bridge.status !== 0 || !recorded || verified.status !== "current") {
+    const message = bridge.status !== 0 ? "Mobile source restart completed but the platform-matched bridge did not become ready." : "Mobile source restart did not produce a current loaded-source baseline.";
     if (json) {
       console.log(JSON.stringify({
         schemaVersion: 1,
         status: "fail",
         recoverable: false,
         attemptedRecoveries: state.attemptedRecoveries,
-        error: { code: "MOBILE_SOURCE_RELOAD_FAILED", message, userAction, originalError: result.output }
+        error: { code: bridge.status !== 0 ? "MOBILE_BRIDGE_NOT_READY" : "MOBILE_SOURCE_RELOAD_FAILED", message, userAction, originalError: bridge.output || result.output }
       }, null, 2));
     } else {
       console.error(`\u2717 ${message}`);
-      console.error(`  Next: ${userAction}`);
+      console.error(`  Next: ${bridge.status !== 0 ? "inspect the bridge-status log and rerun mm-harness launch <platform>" : userAction}`);
     }
     return EXIT.infra;
   }
@@ -517,6 +817,12 @@ async function ensureMobileProofRuntime(target, heal, state, json, deps = {}) {
   state.mutations.push({ type: "runtime", action: "restarted", reasonCode: `source-${initial.status}` });
   return null;
 }
+function resolveRunMobilePlatform() {
+  if (process.env.PLATFORM === "android" || process.env.PLATFORM === "ios") {
+    return process.env.PLATFORM;
+  }
+  return process.env.ADB_SERIAL || process.env.ANDROID_SERIAL ? "android" : "ios";
+}
 async function ensureExtensionProofRuntime(target, heal, state, json, deps = {}) {
   const decide = deps.decide ?? (async () => {
     const { decideExtensionReadiness } = await import("../adapters/extension/runtime-decision.js");
@@ -568,6 +874,24 @@ async function ensureExtensionProofRuntime(target, heal, state, json, deps = {})
     return EXIT.infra;
   }
   const recoveryCode = tier === "build" ? "extension.runtime_rebuilt" : "extension.runtime_reloaded";
+  const productConfigBlock = tier === "build" ? extensionProductConfigBlock(target) : null;
+  if (productConfigBlock) {
+    const message = productConfigBlock.message;
+    const userAction2 = productConfigBlock.userAction;
+    if (json) {
+      console.log(JSON.stringify({
+        schemaVersion: 1,
+        status: "fail",
+        recoverable: false,
+        mutations: state.mutations,
+        error: { code: "EXTENSION_PRODUCT_CONFIG_REQUIRED", message, userAction: userAction2 }
+      }, null, 2));
+    } else {
+      console.error(`\u2717 ${message}`);
+      console.error(`  Next: ${userAction2}`);
+    }
+    return EXIT.infra;
+  }
   state.attemptedRecoveries.push(recoveryCode);
   deps.onRecovery?.(recoveryCode);
   if (!json) console.error(`\u2192 Extension proof preflight: ${initial.reasonCode}; ${tier === "build" ? "rebuilding" : "reloading"} before execution`);
@@ -690,12 +1014,16 @@ function countRecipeNodes(recipe) {
 }
 export {
   countRecipeNodes,
+  describeRunnableRecipe,
   emitHealViolation,
   ensureExtensionProofRuntime,
   ensureMobileProofRuntime,
   executeWithHealBounds,
+  listRunnableRecipes,
+  preflightRecipe,
   prepareHeal,
   recoverRunInfra,
+  requireRecipeTrustResolver,
   resolveMetaMaskLibrarySources,
   resolveRunRecipeArg,
   runOneNode,