@deeeed/metamask-harness 0.13.0 → 0.14.1

package/dist/commands/run.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { walletFixturePath } from "../paths.js";
+import { color } from "../cli-color.js";
+import { recipeRunning } from "../heal-bounds.js";
 import { EXIT } from "./shared.js";
 import {
   optionFlag,
@@ -8,6 +10,7 @@ import {
   requiredOption,
   resolveAdapter,
   runtimeOptionsFromCli,
+  isRecord,
   usageError
 } from "./parse-args.js";
 import {
@@ -20,6 +23,9 @@ import {
 } from "./run-engine.js";
 import { handleListExecutables } from "./list-executables.js";
 import { applyDeviceTargeting } from "./device-target.js";
+import { getAdapterSurface } from "../adapters/surface.js";
+import { coreDependencyBlock } from "./core-readiness.js";
+import { writeRunReport } from "./run-report.js";
 async function handleRun({ positional, options }) {
   if (optionFlag(options, "list")) return handleListExecutables("run", options);
   const targetRecipe = positional[0];
@@ -27,14 +33,15 @@ async function handleRun({ positional, options }) {
   if (optionFlag(options, "plan")) return handleRunPlan(targetRecipe, options);
   const { adapter, target } = resolveAdapter(options);
   const json = optionFlag(options, "json");
+  getAdapterSurface(adapter).resolveSlotPorts(target);
   const dtResult = applyDeviceTargeting("run", adapter, options, { gate: true, rerun: "" });
   if ("code" in dtResult) {
     return emitRunUsageError(json, adapter, targetRecipe, dtResult.code, dtResult.message);
   }
-  const artifactsDir = requiredOption(options, "artifactsDir", "run requires --artifacts-dir <dir>.");
-  const prepared = await prepareHeal(adapter, target, options, json);
-  if (typeof prepared === "number") return prepared;
-  const { state, heal } = prepared;
+  if (recipeRunning(target)) return emitRunRecipeRunning(json);
+  if (optionString(options, "artifactsDir") === void 0 && runArgLooksLikeRecipeFile(targetRecipe)) {
+    requiredOption(options, "artifactsDir", "run requires --artifacts-dir <dir>.");
+  }
   const validated = await validateRunRecipeStatic(targetRecipe, adapter, options);
   if (validated.usageError) {
     return emitRunUsageError(json, adapter, validated.recipeFile, validated.usageError.code, validated.usageError.message);
@@ -42,6 +49,14 @@ async function handleRun({ positional, options }) {
   if (validated.errorCount > 0) {
     return emitRunValidationError(json, adapter, validated.recipeFile, validated.findings, validated.errorCount);
   }
+  const depsBlock = adapter === "core" && recipeUsesCoreController(validated.recipe, validated.librarySources) ? coreDependencyBlock(target) : null;
+  if (depsBlock) {
+    return emitRunUsageError(json, adapter, validated.recipeFile, depsBlock.code, depsBlock.message, depsBlock.userAction);
+  }
+  const artifactsDir = requiredOption(options, "artifactsDir", "run requires --artifacts-dir <dir>.");
+  const prepared = await prepareHeal(adapter, target, options, json);
+  if (typeof prepared === "number") return prepared;
+  const { state, heal } = prepared;
   const librarySources = validated.librarySources;
   const runtimeOptions = {
     ...runtimeOptionsFromCli(options),
@@ -58,6 +73,7 @@ async function handleRun({ positional, options }) {
     state
   );
   if (violation !== null) return emitHealViolation(json, "run", result, violation, state, adapter);
+  const report = writeRunReport(result);
   const exitCode = result.status === "pass" ? EXIT.ok : EXIT.runtime;
   if (json) {
     console.log(
@@ -70,6 +86,7 @@ async function handleRun({ positional, options }) {
           exitCode,
           recovered: state.recovered,
           mutations: state.mutations,
+          reportPath: report.path,
           result
         },
         null,
@@ -77,11 +94,88 @@ async function handleRun({ positional, options }) {
       )
     );
   } else {
-    console.log(`MetaMask recipe run: ${result.status}
-Artifacts: ${result.artifactManifestPath}`);
+    const out = (style, text) => color(style, text, { stream: process.stdout });
+    console.log(`${out(result.status === "pass" ? "ok" : "err", result.status.toUpperCase())} ${out("bold", "recipe run")} ${out("dim", `[${adapter}]`)}`);
+    if (report.preview.length > 0) {
+      console.log(out("label", "summary:"));
+      for (const line of report.preview) console.log(`  ${formatPreviewLine(line, out)}`);
+    }
+    console.log(`${out("label", "report:")} ${out("path", report.path)}`);
+    console.log(`${out("label", "artifacts:")} ${out("path", result.artifactManifestPath)}`);
   }
   return exitCode;
 }
+function formatPreviewLine(line, out) {
+  const match = /^(PASS|FAIL)\s+(.+)$/u.exec(line);
+  if (!match) return line;
+  const status = match[1];
+  const rest = match[2];
+  return `${out(status === "PASS" ? "ok" : "err", status)} ${rest}`;
+}
+function recipeUsesCoreController(recipe, librarySources) {
+  if (objectUsesCoreController(recipe)) return true;
+  const refs = collectCallRefs(recipe);
+  if (refs.length === 0) return false;
+  const flows = loadFlowCatalogs(librarySources ?? []);
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (ref) => {
+    if (visited.has(ref)) return false;
+    visited.add(ref);
+    const flow = flows.get(ref);
+    if (!flow) return false;
+    if (objectUsesCoreController(flow)) return true;
+    return collectCallRefs(flow).some(visit);
+  };
+  return refs.some(visit);
+}
+function objectUsesCoreController(value) {
+  if (Array.isArray(value)) return value.some(objectUsesCoreController);
+  if (!isRecord(value)) return false;
+  if (actionUsesCoreController(value.action)) return true;
+  return Object.values(value).some(objectUsesCoreController);
+}
+function collectCallRefs(value) {
+  const refs = [];
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    if (!isRecord(node)) return;
+    if (node.action === "call" && typeof node.ref === "string" && node.ref) refs.push(node.ref);
+    for (const child of Object.values(node)) visit(child);
+  };
+  visit(value);
+  return [...new Set(refs)];
+}
+function loadFlowCatalogs(librarySources) {
+  const flows = /* @__PURE__ */ new Map();
+  for (const source of librarySources) {
+    const flowsDir = path.join(source.root, "flows");
+    let entries;
+    try {
+      entries = fs.readdirSync(flowsDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(flowsDir, entry), "utf8"));
+        if (!isRecord(parsed) || !isRecord(parsed.flows)) continue;
+        for (const [id, flow] of Object.entries(parsed.flows)) {
+          if (!flows.has(id)) flows.set(id, flow);
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return flows;
+}
+function actionUsesCoreController(action) {
+  return typeof action === "string" && action.startsWith("metamask.perps.");
+}
 async function handleRunPlan(recipeArg, options) {
   const json = optionFlag(options, "json");
   const { adapter, target } = resolveAdapter(options);
@@ -174,17 +268,30 @@ function emitPlanUsageError(json, adapter, recipeFile, code, message) {
   }
   return EXIT.usage;
 }
-function emitRunUsageError(json, adapter, recipeFile, code, message) {
+function runArgLooksLikeRecipeFile(value) {
+  return path.isAbsolute(value) || value.includes("/") || value.includes(path.sep) || value.endsWith(".json") || fs.existsSync(path.resolve(value));
+}
+function emitRunRecipeRunning(json) {
+  const message = "a recipe is currently running \u2014 refusing to start while another recipe executes.";
+  if (json) {
+    console.log(JSON.stringify({ schemaVersion: 1, status: "fail", recoverable: false, error: { code: "RECIPE_RUNNING", message } }, null, 2));
+  } else {
+    console.error(`\u2717 mm-harness: ${message}`);
+  }
+  return EXIT.bounded;
+}
+function emitRunUsageError(json, adapter, recipeFile, code, message, userAction) {
   if (json) {
     console.log(
       JSON.stringify(
-        { schemaVersion: 1, command: "run", adapter, status: "fail", exitCode: EXIT.usage, recipe: recipeFile, error: { code, message } },
+        { schemaVersion: 1, command: "run", adapter, status: "fail", exitCode: EXIT.usage, recipe: recipeFile, error: { code, message, ...userAction ? { userAction } : {} } },
         null,
         2
       )
     );
   } else {
     console.error(`\u2717 run: ${message}`);
+    if (userAction) console.error(`  Next: ${userAction}`);
   }
   return EXIT.usage;
 }

package/dist/commands/self-test.js

@@ -26,7 +26,7 @@ async function runSelfTest(options) {
       const manifest = loadActionManifest(adapter);
       const manifestValidation = await validateManifest(manifest);
       const smokeRecipe = recipePath(
-        adapter === "mobile" ? "smoke.mobile.recipe.json" : "smoke.extension.recipe.json"
+        adapter === "mobile" ? "runner/smoke.mobile.recipe.json" : "runner/smoke.extension.recipe.json"
       );
       const artifactsDir = path.join(root, adapter);
       const result = await runRecipe(adapter, smokeRecipe, artifactsDir, runnerDir, void 0, {

package/dist/commands/shared.js

@@ -47,7 +47,8 @@ function targetOf(options) {
 }
 const ADAPTER_TOKENS = ["mobile", "extension", "core"];
 function resolveAdapter(options, target, hint) {
-  const explicit = str(options, "adapter") ?? str(options, "platform");
+  const platform = str(options, "platform");
+  const explicit = str(options, "adapter") ?? (platform === "ios" || platform === "android" ? "mobile" : platform);
   if (explicit && ADAPTER_TOKENS.includes(explicit)) return explicit;
   if (hint) return hint;
   return detectAdapter(target);

package/dist/commands/status-probe.js

@@ -38,15 +38,21 @@ function parseBridgeEntries(raw) {
     ...typeof e.agenticPresent === "boolean" ? { agenticPresent: e.agenticPresent } : {}
   }));
 }
-function matchBridgeEntry(device, entries) {
+function matchBridgeEntry(device, entries, devices) {
   const byId = entries.find((e) => e.deviceName === device.id);
   if (byId) return byId;
   if (device.name) {
     const byName = entries.find((e) => e.deviceName === device.name);
     if (byName) return byName;
+    if (device.platform === "android") {
+      const model = device.name.replace(/_/gu, " ");
+      const byModel = entries.find((e) => e.deviceName === model || e.deviceName.startsWith(`${model} -`));
+      if (byModel) return byModel;
+    }
   }
   const platformEntries = entries.filter((e) => e.platform === device.platform);
-  if (platformEntries.length === 1) return platformEntries[0];
+  const platformDevices = devices.filter((d) => d.platform === device.platform);
+  if (!device.name && platformEntries.length === 1 && platformDevices.length === 1) return platformEntries[0];
   return null;
 }
 function probeMobileBridge(target) {
@@ -123,7 +129,7 @@ async function probeMobileLiveState(target, devices) {
   const matched = /* @__PURE__ */ new Map();
   const usedEntries = /* @__PURE__ */ new Set();
   for (const device of devices) {
-    const entry = matchBridgeEntry(device, entries.filter((e) => !usedEntries.has(e)));
+    const entry = matchBridgeEntry(device, entries.filter((e) => !usedEntries.has(e)), devices);
     if (entry) {
       matched.set(device.id, entry);
       usedEntries.add(entry);

package/dist/commands/status.js

@@ -2,30 +2,57 @@ import { color } from "../cli-color.js";
 import { detectAdapter } from "../harness.js";
 import { assertAdapter } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
-import { listConnectedDevices } from "../devices.js";
-import { deviceSelected, renderDeviceList } from "./device-target.js";
-import { probeMobileLiveState } from "./status-probe.js";
+import {
+  applyDeviceTargeting
+} from "./device-target.js";
+import {
+  mobileDeviceView,
+  mobileDeviceLiveView,
+  nextForLive,
+  renderAndroidPortHints,
+  renderMobileDeviceList,
+  renderAdditionalReachableDevices,
+  renderMobileLiveBlock
+} from "./mobile-device-view.js";
 import { ADAPTER_DETECT_NEXT, EXIT, usageOut } from "./shared.js";
 import { optionFlag, targetPath } from "./parse-args.js";
 async function handleStatus({ options }) {
   const target = targetPath(options);
   const json = optionFlag(options, "json");
   const fast = optionFlag(options, "fast");
+  const allDevices = optionFlag(options, "allDevices");
   const adapter = detectAdapter(target);
   if (!adapter) {
     return usageOut(json, "status", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
   }
   assertAdapter(adapter);
-  const devices = adapter === "mobile" ? listConnectedDevices().map((device) => ({ ...device, selected: deviceSelected(device) })) : [];
-  const next = getAdapterSurface(adapter).hints.relaunch;
+  const surface = getAdapterSurface(adapter);
+  surface.resolveSlotPorts(target);
+  if (adapter === "mobile") {
+    const dtResult = applyDeviceTargeting("status", adapter, options, { gate: false, rerun: "" });
+    if ("code" in dtResult) {
+      return usageOut(json, "status", dtResult.message, "mm-harness status --device <id> or --all-devices");
+    }
+  }
+  const next = surface.hints.relaunch;
+  const deviceView = adapter === "mobile" ? mobileDeviceView(allDevices) : null;
+  const devices = deviceView?.devices ?? [];
   if (json) {
-    const doProbe = !fast && adapter === "mobile" && devices.length > 0;
+    const doProbe = !fast && adapter === "mobile" && deviceView !== null && deviceView.allConnectedDevices.length > 0;
     if (doProbe) {
-      const liveMap = await probeMobileLiveState(target, devices);
-      const devicesWithLive = devices.map((d) => mergeDeviceLive(d, liveMap.get(d.id)));
+      const liveView = await mobileDeviceLiveView(target, deviceView);
       console.log(
         JSON.stringify(
-          { schemaVersion: 1, command: "status", adapter, target, devices: devicesWithLive, next },
+          {
+            schemaVersion: 1,
+            command: "status",
+            adapter,
+            target,
+            devices: liveView.devicesWithLive,
+            ...liveView.additionalReachableDevices.length > 0 ? { additionalReachableDevices: liveView.additionalReachableDevices } : {},
+            ...liveView.androidPortHints.length > 0 ? { androidPortHints: liveView.androidPortHints } : {},
+            next: nextForLive(next, liveView.liveMap)
+          },
           null,
           2
         )
@@ -39,50 +66,18 @@ async function handleStatus({ options }) {
   }
   const out = (style, text) => color(style, text, { stream: process.stdout });
   console.log(`${out("label", "status")} ${out("bold", adapter)} ${out("dim", target)}`);
-  if (adapter === "mobile") renderDeviceList(devices, out);
-  console.log(`${out("label", "Next:")} ${out("cmd", next)}`);
-  if (!fast && adapter === "mobile" && devices.length > 0) {
-    const liveMap = await probeMobileLiveState(target, devices);
-    renderLiveBlock(devices, liveMap, out);
+  if (deviceView) renderMobileDeviceList(deviceView, out);
+  if (!fast && adapter === "mobile" && deviceView !== null && deviceView.allConnectedDevices.length > 0) {
+    const liveView = await mobileDeviceLiveView(target, deviceView);
+    if (liveView.additionalReachableDevices.length > 0) renderAdditionalReachableDevices(liveView.additionalReachableDevices, out);
+    renderMobileLiveBlock(devices, liveView.liveMap, out);
+    renderAndroidPortHints(liveView.androidPortHints, out);
+    console.log(`${out("label", "Next:")} ${out("cmd", nextForLive(next, liveView.liveMap))}`);
+  } else {
+    console.log(`${out("label", "Next:")} ${out("cmd", next)}`);
   }
   return EXIT.ok;
 }
-function mergeDeviceLive(device, live) {
-  if (!live) return device;
-  return {
-    ...device,
-    fixtureStatus: live.fixtureStatus,
-    ...live.liveState !== void 0 ? { liveState: live.liveState } : {},
-    ...live.currentScreen !== void 0 ? { currentScreen: live.currentScreen } : {},
-    ...live.walletState !== void 0 ? { walletState: live.walletState } : {},
-    ...live.selectedAccount !== void 0 ? { selectedAccount: live.selectedAccount } : {}
-  };
-}
-function renderLiveBlock(devices, liveMap, out) {
-  console.log(`${out("label", "live:")}`);
-  for (const device of devices) {
-    const live = liveMap.get(device.id);
-    const prefix = `  ${device.platform} ${out("dim", device.id)}${device.name ? ` (${device.name})` : ""}`;
-    if (!live || live.liveState === "no-bridge") {
-      console.log(`${prefix}: ${out("dim", "(no-bridge)")}`);
-      continue;
-    }
-    if (live.liveState === "bridge-absent") {
-      console.log(`${prefix}: ${out("warn", "(bridge-absent \u2014 app attached, build lacks __AGENTIC__; rebuild/reinstall a dev build)")}`);
-      continue;
-    }
-    const parts = [];
-    if (live.currentScreen !== void 0) parts.push(`screen=${out("cmd", live.currentScreen)}`);
-    if (live.walletState !== void 0) parts.push(`wallet=${out(live.walletState === "unlocked" ? "ok" : "warn", live.walletState)}`);
-    if (live.selectedAccount !== void 0) {
-      parts.push(`account=${live.selectedAccount.label} ${out("dim", `(${live.selectedAccount.address})`)}`);
-    }
-    if (live.fixtureStatus !== void 0) {
-      parts.push(`fixture=${out(live.fixtureStatus === "READY" ? "ok" : "warn", live.fixtureStatus)}`);
-    }
-    console.log(`${prefix}: ${parts.join("  ")}`);
-  }
-}
 export {
   handleStatus
 };

package/dist/live-adapter-contract.js

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { resolveRequiredLocalProtocolRoot, runnerDir } from "./paths.js";
+import { corePnpNodeOptions } from "./commands/core-readiness.js";
 function actionFileStem(action) {
   return String(action).replace(/[^a-zA-Z0-9._-]/g, "_");
 }
@@ -199,7 +200,10 @@ async function platformAdapterEnv(platform, projectRoot, tempDir) {
     `${JSON.stringify({ compilerOptions: { baseUrl: projectRoot, paths } }, null, 2)}
 `
   );
-  return { TSX_TSCONFIG_PATH: tsconfigPath };
+  return {
+    TSX_TSCONFIG_PATH: tsconfigPath,
+    NODE_OPTIONS: corePnpNodeOptions(projectRoot, process.env.NODE_OPTIONS)
+  };
 }
 async function runLiveAdapterScript({ platform, action, node, context }) {
   const script = await resolveLiveAdapter(platform, action);

package/dist/mm-harness-cli.js

@@ -6,6 +6,8 @@ import { Command } from "commander";
 import { color } from "./cli-color.js";
 import { handleUpdate, maybeNudge } from "./commands/update.js";
 import { handleCallHelp } from "./commands/call.js";
+import { getAdapterSurface } from "./adapters/surface.js";
+import { detectAdapter } from "./harness.js";
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 globalThis.__MM_HARNESS_WRAPPER__ = true;
 const { main: recipeMain } = await import("./cli.js");
@@ -24,9 +26,13 @@ const REAL = [
   --target <path>                    Checkout path (default: cwd)
   --json                             Machine-readable envelope { adapter, target, devices[], next }
   --fast                             Skip all live-state probes (instant output, safe for scripts)
+  --all-devices                      Mobile only: show every connected device instead of the slot-scoped target
 
   Human output: static device list prints immediately; live-state lines append
   after the ~2s probe window (screen, wallet, account, fixture per device).
+  By default mobile status shows the configured target only; --device <id>
+  switches the active target for that command. Other devices that answer on the
+  same Metro are reported as additional reachable targets.
 
   The devices[] section carries per device:
     { platform, id, name, state, selected }   always present
@@ -90,15 +96,16 @@ Example:
     name: "call",
     summary: "Run one action in isolation as a one-node recipe through the real engine path (fuzzy short names; --arg k=v; same trace/evidence as run).",
     example: "mm-harness call ensure_unlocked",
-    helpText: `mm-harness call <action> [--arg k=v ...] [flags]
+    helpText: `mm-harness call <action> [key=value ...] [--arg k=v ...] [flags]
 
   Run one action in isolation as a one-node recipe through the real engine path.
   Fuzzy short-name: 'ensure_unlocked' resolves to 'metamask.wallet.ensure_unlocked'
-  if unique; ambiguous = exit 2. Actions differ per adapter \u2014 list this checkout's
-  with: mm-harness actions.
+  if unique; ambiguous = exit 2. Pass action fields as key=value shorthand or
+  with --arg k=v. Actions differ per adapter \u2014 list this checkout's with:
+  mm-harness actions.
 
   --list                             List everything invocable for the adapter (actions + flows); no <action> needed
-  --arg k=v                          Action field value (repeatable)
+  --arg k=v                          Action field value (repeatable; equivalent to key=value shorthand)
   --device <udid|serial|name>        Mobile only: target this device (env: IOS_SIMULATOR / ADB_SERIAL). Without it, >1 connected mobile device fails fast and lists them.
   --adapter <mobile|extension|core>  Target adapter (auto-detected inside a checkout)
   --target <path>                    Checkout path (default: cwd)
@@ -110,7 +117,8 @@ Example:
 
 Example (real actions; run mm-harness actions for this checkout's full set):
   mm-harness call ensure_unlocked --adapter extension   # a wallet action (extension/mobile)
-  mm-harness call command --arg cmd="echo hi" --adapter core   # the universal action (all adapters)`
+  mm-harness call navigate page=perps --adapter mobile
+  mm-harness call command cmd="echo hi" --adapter core   # the universal action (all adapters)`
   },
   {
     name: "flows",
@@ -166,6 +174,7 @@ Example:
   --expect-live                      Exit 0 iff the runtime is live (extension: watcher+CDP; mobile: Metro+bridge; core: deps), non-zero + teaching escape otherwise
   --cdp-port <port>                  Extension CDP port for the liveness probe (env: CDP_PORT / RECIPE_CDP_PORT)
   --device <udid|serial|name>        Mobile only: target this device (env: IOS_SIMULATOR / ADB_SERIAL). doctor reports the connected devices; it never gates on ambiguity.
+  --all-devices                      Mobile only: show every connected device instead of the slot-scoped target
   --adapter <mobile|extension|core>  Target adapter (auto-detected inside a checkout)
   --target <path>                    Checkout path (default: cwd)
   --runtime-dir <dir>                Runtime dir containing agentic-runtime.json (relative to target)
@@ -177,6 +186,27 @@ Example:
   mm-harness doctor --adapter extension --target /path/to/checkout --cdp-port 6662 --expect-live
   mm-harness doctor --adapter mobile --target /path/to/checkout`
   },
+  {
+    name: "check",
+    summary: "Run bounded repo-local checks for an active git diff and write validation artifacts.",
+    example: "mm-harness check diff --profile fast",
+    helpText: `mm-harness check diff [flags]
+
+  Run bounded repo-local checks for the active git diff. Fast profile runs changed-file
+  ESLint, Prettier, and changed test files. Full profile also runs repo typecheck
+  when available. Does not launch an app or run a recipe.
+
+  --target <path>                    Checkout path (default: cwd)
+  --adapter <mobile|extension|core>  Adapter label (auto-detected when possible)
+  --base <ref>                       Diff base (default: PR base, then remote HEAD, then repo fallback)
+  --profile <fast|full>              Validation depth (default: fast)
+  --artifacts-dir <dir>              Write validation-summary.json/.md and per-check logs
+  --json                             Machine-readable envelope
+
+Example:
+  mm-harness check diff --profile fast --artifacts-dir artifacts/validation
+  mm-harness check diff --profile full --json`
+  },
   {
     name: "recipe-quality",
     summary: "Build the recipe-quality artifact from a compact verdict JSON (validates before writing).",
@@ -186,7 +216,12 @@ Example:
   Build artifacts/recipe-quality.json from the compact fields a recipe-quality pass
   produces (verdict + reasons + optional guidance/dimensions/findings/delta/training).
   The artifact is validated against the RecipeQualityArtifact schema before it is
-  written \u2014 an invalid input never reaches disk.
+  written \u2014 an invalid input never reaches disk. Shorthand without "build" is
+  also accepted when --input/--output are present.
+
+  This CLI does not run the recipe critique itself; use the fs-recipe-quality
+  skill to judge recipe/evidence quality, then use this command to build the
+  canonical artifact from that compact verdict.
 
   --input <compact.json>   Compact verdict JSON: { "verdict": "pass|warn|fail", "reasons": [..],
                              "betterVersionGuidance"?: [..], "dimensions"?: {..}, "trainingFields"?: {..}, \u2026 }
@@ -197,6 +232,7 @@ Example:
 
 Example:
   mm-harness recipe-quality build --input compact.json --output artifacts/recipe-quality.json
+  mm-harness recipe-quality --input compact.json --output artifacts/recipe-quality.json
   mm-harness recipe-quality build --input compact.json --output artifacts/recipe-quality.json --json`
   },
   {
@@ -295,7 +331,7 @@ Example:
   },
   {
     name: "launch",
-    summary: "Launch the app (Metro/build + boot), auto-ensuring the runtime overlay first. Mobile: ios|android required.",
+    summary: "Launch the app and adapter dev server, auto-ensuring the runtime overlay first. Mobile: ios|android required.",
     example: "mm-harness launch ios",
     helpText: `mm-harness launch [ios|android] [flags]
 
@@ -310,7 +346,7 @@ Example:
   --runway                           Post-launch runway check (mobile only; teaching error elsewhere)
   --watch                            Persistent webpack watcher then relaunch (extension only)
   --sidepanel | --fullscreen         Extension display mode (default --fullscreen)
-  --url <dapp-url>                    Open a dapp in the main tab beside the sidepanel (extension only)
+  --url <dapp-url>                    Open a dapp beside the sidepanel (default: MetaMask test dapp)
   --heal <off|infra-only|auto>       Healing policy (default auto); bounds always enforced
   --device <udid|name>               Target simulator/device (env: IOS_SIMULATOR / ADB_SERIAL)
   --cdp-port <port>                  Extension CDP port (env: CDP_PORT / RECIPE_CDP_PORT)
@@ -422,14 +458,6 @@ Example:
   mm-harness fixtures finalize --fixture wallet-fixture.json --state fixture-state.json --cdp-port 6661 --extension-dir dist/chrome`
   }
 ];
-const RETIRED_INTERNAL = [
-  "runtime-health",
-  "runtime-decision",
-  "runtime-launch",
-  "resolve-extension",
-  "ensure-ready",
-  "self-test"
-];
 const RETIRED = [
   {
     name: "live",
@@ -443,14 +471,7 @@ Replacement: mm-harness launch --verify (install overlay \u2192 launch \u2192 CD
 
 Replacement: mm-harness actions --raw   (works now \u2014 dumps the raw action registry JSON,
 identical to the old \`manifest --json\`). Manifest validation moved into doctor / run --plan.`
-  },
-  ...RETIRED_INTERNAL.map((name) => ({
-    name,
-    message: `mm-harness ${name} is retired (exit 2).
-
-It is internal now \u2014 its logic lives inside doctor / launch / verify self-healing.
-Use: mm-harness doctor`
-  }))
+  }
 ];
 const HELP_GROUPS = [
   {
@@ -466,7 +487,7 @@ const HELP_GROUPS = [
   {
     title: "PROVE",
     blurb: "run recipes and inspect readiness",
-    commands: ["run", "doctor", "recipe-quality"]
+    commands: ["run", "doctor", "check", "recipe-quality"]
   },
   {
     title: "RUNTIME OVERLAY",
@@ -484,6 +505,14 @@ function commandMeta(name) {
   if (real) return { summary: real.summary, example: real.example, planned: false };
   return { summary: "", example: "", planned: false };
 }
+function adapterFromRuntimeContext(ctx) {
+  const raw = typeof ctx.platform === "string" ? ctx.platform : void 0;
+  if (!raw) return void 0;
+  if (raw === "mobile" || raw === "ios" || raw === "android") return "mobile";
+  if (raw === "extension" || raw === "chrome-extension") return "extension";
+  if (raw === "core") return "core";
+  return void 0;
+}
 function detectedSlotLine(out) {
   const ctxPath = path.join(
     process.cwd(),
@@ -492,10 +521,14 @@ function detectedSlotLine(out) {
   );
   try {
     const ctx = JSON.parse(fs.readFileSync(ctxPath, "utf8"));
+    const adapter = adapterFromRuntimeContext(ctx) ?? detectAdapter(process.cwd());
     const parts = [];
     if (ctx.slotId) parts.push(`slot ${out("ok", String(ctx.slotId))}`);
     if (ctx.simulator) parts.push(`device ${out("ok", String(ctx.simulator))}`);
-    if (ctx.metroPort) parts.push(`metro :${out("ok", String(ctx.metroPort))}`);
+    const devServerPort = ctx.watcherPort ?? ctx.devServerPort ?? ctx.metroPort;
+    if (adapter && adapter !== "core" && devServerPort) {
+      parts.push(`${getAdapterSurface(adapter).devServer.label} :${out("ok", String(devServerPort))}`);
+    }
     if (ctx.gitBranch) parts.push(`branch ${out("info", String(ctx.gitBranch))}`);
     if (parts.length === 0) return null;
     return `${out("label", "SLOT")} \u2014 this checkout is a prepared slot: ${parts.join(" \xB7 ")}`;
@@ -580,7 +613,15 @@ for (const command of REAL) {
     process.exit(await delegate(argv));
   });
 }
-const HIDDEN = ["completion-candidates"];
+const HIDDEN = [
+  "completion-candidates",
+  "runtime-health",
+  "runtime-decision",
+  "runtime-launch",
+  "resolve-extension",
+  "ensure-ready",
+  "self-test"
+];
 for (const name of HIDDEN) {
   program.command(name, { hidden: true }).allowUnknownOption().helpOption(false).argument("[args...]").action(async () => {
     process.exit(await delegate(rawArgv));

package/dist/recipe-files.js

@@ -0,0 +1,14 @@
+import fs from "node:fs";
+import path from "node:path";
+function listRecipeFiles(root, base = "") {
+  const out = [];
+  for (const entry of fs.readdirSync(path.join(root, base), { withFileTypes: true })) {
+    const rel = path.join(base, entry.name);
+    if (entry.isDirectory()) out.push(...listRecipeFiles(root, rel));
+    else if (entry.isFile() && entry.name.endsWith(".recipe.json")) out.push(rel);
+  }
+  return out;
+}
+export {
+  listRecipeFiles
+};