@deeeed/metamask-harness 0.18.0 → 0.19.0

package/dist/command-journal.js

@@ -18,11 +18,14 @@ const JOURNALED_COMMANDS = /* @__PURE__ */ new Set([
   "stop",
   "verify"
 ]);
-const SENSITIVE_KEY = /(?:auth|credential|mnemonic|pass(?:word)?|private[-_]?key|secret|seed|srp|token)/iu;
+const SENSITIVE_KEY = /(?:api[-_]?key|auth|credential|mnemonic|pass(?:word)?|private[-_]?key|secret|seed|srp|token|vault)/iu;
 const EVIDENCE_OPTIONS = /* @__PURE__ */ new Set(["--artifacts-dir", "--out", "--output"]);
+let activeCommandJournal;
 async function withCommandJournal(command, argv, execute) {
   if (!JOURNALED_COMMANDS.has(command)) return execute();
   const handle = tryBeginCommandJournal(command, argv);
+  const previous = activeCommandJournal;
+  activeCommandJournal = handle;
   try {
     const exitCode = await execute();
     tryFinishCommandJournal(handle, exitCode);
@@ -30,6 +33,23 @@ async function withCommandJournal(command, argv, execute) {
   } catch (error) {
     tryFinishCommandJournal(handle, 1);
     throw error;
+  } finally {
+    activeCommandJournal = previous;
+  }
+}
+function recordCommandEvidence(...evidence) {
+  const handle = activeCommandJournal;
+  if (!handle || evidence.length === 0) return;
+  try {
+    const paths = new Set(handle.record.evidencePaths);
+    for (const entry of evidence) paths.add(path.resolve(entry));
+    handle.record = { ...handle.record, evidencePaths: [...paths] };
+    writeAtomic(handle.file, handle.record);
+  } catch (error) {
+    process.stderr.write(
+      `mm-harness: resumability journal could not record evidence: ${errorMessage(error)}
+`
+    );
   }
 }
 function commandJournalPath(target, runtimeDir) {
@@ -48,7 +68,9 @@ function readCommandJournal(target, runtimeDir) {
     if (!descriptorStat.isFile() || !pathStat.isFile() || pathStat.isSymbolicLink() || pathStat.dev === 0n && pathStat.ino === 0n || descriptorStat.dev !== pathStat.dev || descriptorStat.ino !== pathStat.ino) {
       return { file, record: null };
     }
-    const parsed = JSON.parse(fs.readFileSync(descriptor, "utf8"));
+    const parsed = JSON.parse(
+      fs.readFileSync(descriptor, "utf8")
+    );
     return isCommandJournalRecord(parsed) ? { file, record: parsed } : { file, record: null };
   } catch {
     return { file, record: null };
@@ -64,7 +86,9 @@ function redactCommandArgs(argv) {
     if (token.startsWith("--") && equals !== -1) {
       const option = token.slice(0, equals);
       const value = token.slice(equals + 1);
-      redacted.push(`${option}=${option === "--arg" ? redactAssignment(value) : SENSITIVE_KEY.test(option) ? "<redacted>" : redactUrl(value)}`);
+      redacted.push(
+        `${option}=${option === "--arg" ? redactAssignment(value) : SENSITIVE_KEY.test(option) ? "<redacted>" : redactUrl(value)}`
+      );
       continue;
     }
     if (token.startsWith("--") && SENSITIVE_KEY.test(token)) {
@@ -110,8 +134,10 @@ function tryBeginCommandJournal(command, argv) {
     writeAtomic(file, record);
     return { file, record };
   } catch (error) {
-    process.stderr.write(`mm-harness: resumability journal unavailable: ${errorMessage(error)}
-`);
+    process.stderr.write(
+      `mm-harness: resumability journal unavailable: ${errorMessage(error)}
+`
+    );
     return void 0;
   }
 }
@@ -125,8 +151,10 @@ function tryFinishCommandJournal(handle, exitCode) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
   } catch (error) {
-    process.stderr.write(`mm-harness: resumability journal could not finalize: ${errorMessage(error)}
-`);
+    process.stderr.write(
+      `mm-harness: resumability journal could not finalize: ${errorMessage(error)}
+`
+    );
   }
 }
 function writeAtomic(file, record) {
@@ -147,7 +175,9 @@ function writeAtomic(file, record) {
   }
 }
 function invocationTarget(argv) {
-  return path.resolve(optionValue(argv, "--target") ?? optionValue(argv, "--project-root") ?? process.cwd());
+  return path.resolve(
+    optionValue(argv, "--target") ?? process.cwd()
+  );
 }
 function evidencePaths(argv) {
   const values = /* @__PURE__ */ new Set();
@@ -172,7 +202,7 @@ function optionValue(argv, option) {
 }
 function redactAssignment(token) {
   const equals = token.indexOf("=");
-  if (equals <= 0) return token;
+  if (equals <= 0) return redactValue(token);
   const key = token.slice(0, equals);
   const value = token.slice(equals + 1);
   return `${key}=${SENSITIVE_KEY.test(key) ? "<redacted>" : redactValue(value)}`;
@@ -185,18 +215,21 @@ function redactValue(value) {
     return JSON.stringify(redactStructuredValue(JSON.parse(value)));
   } catch {
     return value.replace(
-      /((?:auth|credential|mnemonic|pass(?:word)?|private[-_]?key|secret|seed|srp|token)=)[^\s]+/giu,
+      /((?:api[-_]?key|auth|credential|mnemonic|pass(?:word)?|private[-_]?key|secret|seed|srp|token|vault)=)[^\s]+/giu,
       "$1<redacted>"
     );
   }
 }
+function isSensitiveKey(key) {
+  return SENSITIVE_KEY.test(key);
+}
 function redactStructuredValue(value) {
   if (Array.isArray(value)) return value.map(redactStructuredValue);
   if (!value || typeof value !== "object") return value;
   return Object.fromEntries(
     Object.entries(value).map(([key, entry]) => [
       key,
-      SENSITIVE_KEY.test(key) ? "<redacted>" : redactStructuredValue(entry)
+      isSensitiveKey(key) ? "<redacted>" : redactStructuredValue(entry)
     ])
   );
 }
@@ -205,7 +238,9 @@ function assertRelativeRuntimeDir(value) {
     throw new Error(`--runtime-dir must be a safe relative path: ${value}`);
   }
   if (value.split("/").some((part) => !part || part === "." || part === "..")) {
-    throw new Error(`--runtime-dir contains an unsafe path component: ${value}`);
+    throw new Error(
+      `--runtime-dir contains an unsafe path component: ${value}`
+    );
   }
 }
 function isCommandJournalRecord(value) {
@@ -219,7 +254,10 @@ function errorMessage(error) {
 export {
   COMMAND_JOURNAL_FILE,
   commandJournalPath,
+  isSensitiveKey,
   readCommandJournal,
+  recordCommandEvidence,
   redactCommandArgs,
+  redactStructuredValue,
   withCommandJournal
 };

package/dist/commands/call.js

@@ -3,15 +3,16 @@ import { createHash } from "node:crypto";
 import path from "node:path";
 import { resolveActionManifest } from "../manifest.js";
 import { importRecipeProtocol } from "../paths.js";
-import { recipeRunning } from "../heal-bounds.js";
+import { conciseFailureForHuman, recipeRunning } from "../heal-bounds.js";
 import { color } from "../cli-color.js";
 import { checkoutBusyOut, EXIT, usageOut } from "./shared.js";
-import { describeManifestActions, fuzzyResolveActions } from "./manifest.js";
+import { actionExampleCommand, describeManifestActions, fuzzyResolveActions } from "./manifest.js";
 import {
   parseArgs,
   isRecord,
   optionFlag,
   optionString,
+  optionStrings,
   resolveAdapter,
   runtimeOptionsFromCli,
   shellQuote,
@@ -35,6 +36,8 @@ import {
 import { acquireCheckoutLock } from "../checkout-lock.js";
 import { formatRunDiagnosticsForHuman, readRunDiagnosticsDocument } from "../run-diagnostics.js";
 import { recipeTrustFailure } from "../recipe-security.js";
+import { isSensitiveKey, recordCommandEvidence, redactStructuredValue } from "../command-journal.js";
+import { closest } from "../command-contract.js";
 async function handleCall(argv) {
   if (argv.includes("--list")) {
     const { options: options2 } = parseArgs(argv, "call");
@@ -53,7 +56,7 @@ async function handleCall(argv) {
     let discovery = "mm-harness actions";
     try {
       const { adapter: adapter2 } = resolveAdapter(options);
-      const librarySources2 = await resolveMetaMaskLibrarySources(optionString(options, "library"));
+      const librarySources2 = await resolveMetaMaskLibrarySources(optionStrings(options, "library"));
       const { manifest: manifest2 } = await resolveActionManifest(adapter2, optionString(options, "actionManifest"), librarySources2);
       const { getRecipeActionManifestActionNames: getRecipeActionManifestActionNames2 } = await importRecipeProtocol();
       const exampleAction = pickCallExampleAction(getRecipeActionManifestActionNames2(manifest2));
@@ -103,8 +106,8 @@ async function handleCall(argv) {
     return EXIT.bounded;
   }
   const actionManifestOverride = optionString(options, "actionManifest");
-  const librarySources = await resolveMetaMaskLibrarySources(optionString(options, "library"));
-  const { manifest } = await resolveActionManifest(adapter, actionManifestOverride, librarySources);
+  const librarySources = await resolveMetaMaskLibrarySources(optionStrings(options, "library"));
+  const { manifest, actionSources } = await resolveActionManifest(adapter, actionManifestOverride, librarySources);
   const { getRecipeActionManifestActionNames } = await importRecipeProtocol();
   const names = getRecipeActionManifestActionNames(manifest);
   const resolution = resolveActionName(shortName, names);
@@ -125,6 +128,8 @@ async function handleCall(argv) {
     return EXIT.usage;
   }
   const resolvedAction = resolution.resolved;
+  const describedAction = describeManifestActions(manifest, actionSources).find((entry) => entry.name === resolvedAction);
+  const defaultsUsed = actionDefaultsUsed(describedAction, args);
   const depsBlock = adapter === "core" && resolvedAction.startsWith("metamask.perps.") ? coreDependencyBlock(target) : null;
   if (depsBlock) {
     if (json) {
@@ -136,24 +141,39 @@ async function handleCall(argv) {
     return EXIT.usage;
   }
   const recipe = synthesizeOneNodeRecipe(resolvedAction, args);
-  const validation = await validateRecipeAdapterAware(recipe, manifest);
+  const validation = await validateRecipeAdapterAware(adapter, recipe, manifest, librarySources);
   if (validation.status === "invalid") {
     const message = `call ${resolvedAction}: recipe validation failed`;
-    const userAction = `mm-harness actions --action ${resolvedAction} --adapter ${adapter} --json`;
-    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "call", adapter, action: shortName, resolvedAction, args: redactCallValue(args), findings: validation.findings, error: { code: "RECIPE_VALIDATION_FAILED", message, userAction } }, null, 2));
+    const parameterHelp = parameterValidationHelp(describedAction, validation.findings, args);
+    const userAction = describedAction ? actionExampleCommand(
+      describedAction,
+      adapter,
+      target,
+      process.env.MM_HARNESS_INVOKED_AS ?? process.env.MM_HARNESS_EXECUTABLE ?? "mm-harness"
+    ) ?? `mm-harness actions --action ${resolvedAction} --adapter ${adapter}` : `mm-harness actions --action ${resolvedAction} --adapter ${adapter}`;
+    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "call", adapter, action: shortName, resolvedAction, args: redactCallValue(args), findings: validation.findings, ...parameterHelp.length > 0 ? { parameterHelp } : {}, error: { code: "RECIPE_VALIDATION_FAILED", message, userAction } }, null, 2));
     else {
       console.error(`\u2717 ${message}`);
-      for (const finding of validation.findings) console.error(`  ${finding.code} ${finding.path} \u2014 ${finding.message}`);
+      const taught = new Set(parameterHelp.map((entry) => `${entry.issue}:${entry.name}`));
+      for (const entry of parameterHelp) console.error(renderParameterValidationHelp(entry));
+      for (const finding of validation.findings) {
+        const name = finding.path.split(".").at(-1);
+        const issue = parameterIssue(finding.code);
+        if (issue && name && taught.has(`${issue}:${name}`)) continue;
+        console.error(`  ${finding.code} ${finding.path} \u2014 ${finding.message}`);
+      }
       console.error(`  Next: ${userAction}`);
     }
     return EXIT.validation;
   }
   const artifactsDir = optionString(options, "artifactsDir") ?? defaultCallArtifactsDir(target, resolvedAction, args);
+  recordCommandEvidence(artifactsDir);
   const requestedRuntimeOptions = runtimeOptionsFromCli(options);
   const callRuntimeOptions = {
     ...requestedRuntimeOptions,
     ...librarySources ? { librarySources } : {},
     autoHud: false,
+    suppressLibraryResolutionLogs: true,
     stdoutIsMachineContract: json,
     source: requestedRuntimeOptions.source ?? {
       kind: "operator",
@@ -233,7 +253,17 @@ async function handleCall(argv) {
       state,
       () => recoverRunInfra(adapter, target, json)
     );
-    if (violation !== null) return emitHealViolation(json, "call", result, violation, state, adapter);
+    if (violation !== null) {
+      const conciseFailure = violation.originalError ? conciseFailureForHuman(violation.originalError) : "";
+      const example = describedAction ? actionExampleCommand(
+        describedAction,
+        adapter,
+        target,
+        process.env.MM_HARNESS_INVOKED_AS ?? process.env.MM_HARNESS_EXECUTABLE ?? "mm-harness"
+      ) : void 0;
+      const taughtViolation = violation.code === "APP_LOGIC_FAILURE" && conciseFailure.includes(" requires ") && example ? { ...violation, userAction: example } : violation;
+      return emitHealViolation(json, "call", result, taughtViolation, state, adapter);
+    }
     const callOutput = readCallOutput(result.tracePath);
     const safeArgs = redactCallValue(args);
     const safeCallOutput = redactCallValue(callOutput);
@@ -248,6 +278,7 @@ async function handleCall(argv) {
             action: shortName,
             resolvedAction,
             args: safeArgs,
+            ...Object.keys(defaultsUsed).length > 0 ? { defaultsUsed } : {},
             status: result.status,
             summaryPath: result.summaryPath,
             tracePath: result.tracePath,
@@ -277,7 +308,8 @@ ${diagnostics.map((line) => `  ${line}`).join("\n")}
       console.log(
         `${out("label", "call")} ${out("cmd", resolvedAction)}: ${out(result.status === "pass" ? "ok" : "err", result.status)}${renderedInputs ? `
 ${out("label", "Inputs:")}
-${renderedInputs}` : ""}${callOutput !== void 0 ? `
+${renderedInputs}` : ""}${Object.keys(defaultsUsed).length > 0 ? `
+${renderDefaultsUsed(defaultsUsed, process.stdout)}` : ""}${callOutput !== void 0 ? `
 ${out("label", "Result:")}
 ${formatCallOutput(safeCallOutput)}` : ""}
 ` + renderedDiagnostics + `${out("label", "Artifacts:")} ${out("path", result.artifactManifestPath)}` + (result.status === "fail" ? `
@@ -289,6 +321,54 @@ ${formatCallOutput(safeCallOutput)}` : ""}
     lock.release();
   }
 }
+function parameterValidationHelp(action, findings, args) {
+  const schema = isRecord(action?.schema) ? action.schema : {};
+  const properties = isRecord(schema.properties) ? schema.properties : {};
+  return findings.flatMap((finding) => {
+    const issue = parameterIssue(finding.code);
+    if (!issue) return [];
+    const name = finding.path.split(".").at(-1);
+    const property = name && isRecord(properties[name]) ? properties[name] : void 0;
+    if (!name || !property) return [];
+    const validValues = Array.isArray(property.enum) ? property.enum : void 0;
+    const received = Object.hasOwn(args, name) ? args[name] : void 0;
+    const suggestion = issue === "invalid" && received !== void 0 && validValues ? closest(String(received), validValues.map(String)) : void 0;
+    return [{
+      issue,
+      name,
+      ...typeof property.type === "string" ? { type: property.type } : {},
+      ...validValues ? { validValues } : {},
+      ...typeof property.description === "string" ? { description: property.description } : {},
+      ...issue === "invalid" && received !== void 0 ? { received } : {},
+      ...suggestion ? { suggestion } : {}
+    }];
+  });
+}
+function parameterIssue(code) {
+  if (code === "recipe.missing_param") return "missing";
+  if (code === "recipe.invalid_param_value_enum") return "invalid";
+  return void 0;
+}
+function renderParameterValidationHelp(parameter) {
+  const out = (style, text) => color(style, text, { stream: process.stderr });
+  const heading = parameter.issue === "missing" ? `${out("cmd", parameter.name)}${parameter.type ? ` (${parameter.type}, required)` : " (required)"}` : `${out("cmd", parameter.name)} received ${out("err", JSON.stringify(parameter.received) ?? String(parameter.received))}`;
+  const values = parameter.validValues?.length ? ` Valid values: ${parameter.validValues.map((value) => out("accent", String(value))).join(", ")}.` : "";
+  const suggestion = parameter.suggestion ? ` Did you mean ${out("accent", JSON.stringify(parameter.suggestion))}?` : "";
+  const description = parameter.description ? ` ${parameter.description}` : "";
+  return `  ${heading}.${values}${suggestion}${description}`;
+}
+function actionDefaultsUsed(action, args) {
+  const schema = isRecord(action?.schema) ? action.schema : {};
+  const properties = isRecord(schema.properties) ? schema.properties : {};
+  return Object.fromEntries(
+    Object.entries(properties).filter(([name, entry]) => !Object.hasOwn(args, name) && isRecord(entry) && Object.hasOwn(entry, "default")).map(([name, entry]) => [name, entry.default])
+  );
+}
+function renderDefaultsUsed(defaults, stream) {
+  const out = (style, text) => color(style, text, { stream });
+  const values = Object.entries(defaults).map(([name, value]) => `${out("cmd", name)}=${out("accent", JSON.stringify(value) ?? String(value))}`).join(", ");
+  return `${out("label", "Defaults used:")} ${values}`;
+}
 function defaultCallArtifactsDir(target, action, args) {
   const actionStem = action.replace(/[^a-zA-Z0-9._-]/gu, "_");
   const digest = createHash("sha256").update(JSON.stringify({ action, args })).digest("hex").slice(0, 12);
@@ -310,12 +390,7 @@ function formatCallOutput(value) {
   return JSON.stringify(value, null, 2);
 }
 function redactCallValue(value, key = "") {
-  if (/(?:password|secret|mnemonic|seed|srp|vault|private[_-]?key)/iu.test(key)) return "<redacted>";
-  if (Array.isArray(value)) return value.map((entry) => redactCallValue(entry));
-  if (isRecord(value)) {
-    return Object.fromEntries(Object.entries(value).map(([entryKey, entry]) => [entryKey, redactCallValue(entry, entryKey)]));
-  }
-  return value;
+  return key && isSensitiveKey(key) ? "<redacted>" : redactStructuredValue(value);
 }
 async function handleCallHelp(argv, genericHelp) {
   const { action: shortName, rest } = parseCallArgs(argv.filter((arg) => arg !== "--help" && arg !== "-h"));
@@ -325,7 +400,7 @@ async function handleCallHelp(argv, genericHelp) {
   let actionSources = /* @__PURE__ */ new Map();
   try {
     ({ adapter } = resolveAdapter(options));
-    const librarySources = await resolveMetaMaskLibrarySources(optionString(options, "library"));
+    const librarySources = await resolveMetaMaskLibrarySources(optionStrings(options, "library"));
     const resolution = await resolveActionManifest(adapter, optionString(options, "actionManifest"), librarySources);
     manifest = resolution.manifest;
     actionSources = resolution.actionSources;
@@ -375,7 +450,8 @@ function renderCallActionHelp(entry) {
       const req = required.has(name) ? " (required)" : "";
       const desc = typeof prop.description === "string" ? ` \u2014 ${prop.description}` : "";
       const enumVals = Array.isArray(prop.enum) ? ` [one of: ${prop.enum.join(", ")}]` : "";
-      lines.push(`    ${name.padEnd(width)}  ${type}${req}${desc}${enumVals}`);
+      const defaultValue = Object.hasOwn(prop, "default") ? ` [default: ${JSON.stringify(prop.default)}]` : "";
+      lines.push(`    ${name.padEnd(width)}  ${type}${req}${defaultValue}${desc}${enumVals}`);
     }
   }
   const examples = renderCallExamples(short, entry.examples);
@@ -462,7 +538,6 @@ const VALUE_TAKING_CALL_FLAGS = /* @__PURE__ */ new Set([
   "library",
   "metro-port",
   "platform",
-  "project-root",
   "slot",
   "source-digest",
   "source-kind",

package/dist/commands/check.js

@@ -18,7 +18,7 @@ async function handleCheck(argv) {
     const message = action ? `unknown action '${action}'` : "missing action";
     return usageOut(json, "check", message, USAGE);
   }
-  const target = path.resolve(optionString(options, "target") ?? optionString(options, "projectRoot") ?? process.cwd());
+  const target = path.resolve(optionString(options, "target") ?? process.cwd());
   const explicitAdapter = optionString(options, "adapter") ?? optionString(options, "platform");
   const detected = explicitAdapter ?? detectAdapter(target);
   if (detected && !["mobile", "extension", "core"].includes(detected)) {

package/dist/commands/completion-candidates.js

@@ -4,12 +4,13 @@ import {
   readFreshCandidates,
   writeCompletionCandidates
 } from "../completions-cache.js";
-import { importRecipeHarness, importRecipeProtocol } from "../paths.js";
+import { importRecipeProtocol } from "../paths.js";
 import { EXIT } from "./shared.js";
 import {
   parseArgs,
   optionFlag,
   optionString,
+  optionStrings,
   resolveAdapter,
   targetPath
 } from "./parse-args.js";
@@ -18,8 +19,8 @@ async function handleCompletionCandidates(argv) {
   const kind = argv[0];
   const { options } = parseArgs(argv.slice(1), "completion-candidates");
   const json = optionFlag(options, "json");
-  if (kind !== "actions" && kind !== "flows" && kind !== "recipes") {
-    console.error("completion-candidates requires <actions|flows|recipes>.");
+  if (kind !== "actions" && kind !== "recipes") {
+    console.error("completion-candidates requires <actions|recipes>.");
     return EXIT.usage;
   }
   const target = targetPath(options);
@@ -27,31 +28,18 @@ async function handleCompletionCandidates(argv) {
   let candidates;
   if (kind === "actions") {
     adapter = resolveAdapter(options).adapter;
-    const sources = await resolveMetaMaskLibrarySources(optionString(options, "library"));
+    const sources = await resolveMetaMaskLibrarySources(optionStrings(options, "library"));
     const { manifest } = await resolveActionManifest(adapter, optionString(options, "actionManifest"), sources);
     const { getRecipeActionManifestActionNames } = await importRecipeProtocol();
     candidates = getRecipeActionManifestActionNames(manifest);
     writeCompletionCandidates(target, "actions", candidates);
-  } else if (kind === "flows") {
-    candidates = readFreshCandidates(target, "flows");
-    if (!candidates) {
-      const sources = await resolveMetaMaskLibrarySources(optionString(options, "library")).catch(() => void 0);
-      if (!sources) {
-        candidates = [];
-      } else {
-        const harness = await importRecipeHarness();
-        const resolution = await harness.loadRecipeLibraries(sources);
-        candidates = [...resolution.flows.keys()].sort();
-        writeCompletionCandidates(target, "flows", candidates);
-      }
-    }
   } else {
     adapter = resolveAdapter(options).adapter;
     const cacheKey = `recipes:${adapter}`;
     candidates = readFreshCandidates(target, cacheKey);
     if (!candidates) {
-      const sources = await resolveMetaMaskLibrarySources(optionString(options, "library")).catch(() => void 0);
-      candidates = sources ? listRunnableRecipes(adapter, sources).map((recipe) => recipe.name) : [];
+      const sources = await resolveMetaMaskLibrarySources(optionStrings(options, "library")).catch(() => void 0);
+      candidates = sources ? (await listRunnableRecipes(adapter, sources)).map((recipe) => recipe.name) : [];
       writeCompletionCandidates(target, cacheKey, candidates);
     }
   }

package/dist/commands/fixtures.js

@@ -11,7 +11,8 @@ import { ADAPTER_DETECT_NEXT, checkoutBusyOut, EXIT, flag, parseFlags, resolveAd
 const FIXTURES_BOOLEANS = /* @__PURE__ */ new Set(["dev", "force", "json"]);
 const FIXTURE_STREAM_TIMEOUT_MS = 12e4;
 async function handleFixtures(argv) {
-  const { options } = parseFlags(argv, FIXTURES_BOOLEANS);
+  const { positional, options } = parseFlags(argv, FIXTURES_BOOLEANS);
+  if (!positional[0]) return fixturesStatus(options);
   const json = flag(options, "json");
   const target = targetOf(options);
   if (!fs.existsSync(target)) return handleFixturesLocked(argv);
@@ -25,6 +26,54 @@ async function handleFixtures(argv) {
     lock.release();
   }
 }
+function fixturesStatus(options) {
+  const json = flag(options, "json");
+  const statusOptions = /* @__PURE__ */ new Set(["json", "target", "adapter", "platform", "device"]);
+  const actionOption = Object.keys(options).find((key) => !statusOptions.has(key));
+  if (actionOption) {
+    return usageOut(
+      json,
+      "fixtures",
+      `--${actionOption.replace(/[A-Z]/gu, (letter) => `-${letter.toLowerCase()}`)} requires a fixture action.`,
+      "mm-harness fixtures --help"
+    );
+  }
+  const target = targetOf(options);
+  const adapter = resolveAdapter(options, target);
+  if (!adapter) {
+    return usageOut(json, "fixtures", `could not detect the MetaMask repo type for ${target}`, ADAPTER_DETECT_NEXT);
+  }
+  const canonical = walletFixturePath(target);
+  const summary = fixtureSummary(target, adapter);
+  const fixture = { ...summary, path: canonical };
+  const ready = summary.status === "ready";
+  const nextCommand = ready ? "mm-harness fixtures set" : "mm-harness fixtures init --from <path>   # or: mm-harness fixtures init --dev";
+  const operations = adapter === "extension" ? ["init", "sync", "set", "generate", "finalize"] : ["init", "sync", "set"];
+  if (json) {
+    console.log(JSON.stringify({
+      schemaVersion: 1,
+      command: "fixtures",
+      action: "status",
+      adapter,
+      target,
+      status: "pass",
+      fixture,
+      operations,
+      nextCommand,
+      exitCode: EXIT.ok
+    }, null, 2));
+    return EXIT.ok;
+  }
+  console.log(`wallet fixture (${adapter}): ${String(summary.status).toUpperCase()}`);
+  console.log(`path: ${canonical}`);
+  if (typeof summary.accountCount === "number") {
+    const password = summary.hasPassword === true ? "present" : "missing";
+    console.log(`accounts: ${summary.accountCount} \xB7 password: ${password}`);
+  }
+  console.log(`operations: ${operations.join(", ")}`);
+  console.log(`Next: ${nextCommand}`);
+  return EXIT.ok;
+}
 function ensureFixturePublicationParent(target) {
   const repoRoot = fs.realpathSync(target);
   const parent = path.dirname(walletFixturePath(repoRoot));

package/dist/commands/last.js

@@ -3,6 +3,7 @@ import { EXIT } from "./shared.js";
 import {
   optionFlag,
   optionString,
+  shellQuote,
   targetPath
 } from "./parse-args.js";
 async function handleLast({ options }) {
@@ -41,9 +42,16 @@ async function handleLast({ options }) {
   } else {
     const end = record.finishedAt ?? "still running or interrupted";
     console.log(`${record.verdict.toUpperCase()} ${record.command} (exit ${record.exitCode ?? "pending"})`);
+    console.log(`command: mm-harness ${record.command}${record.args.length > 0 ? ` ${record.args.map(shellQuote).join(" ")}` : ""}`);
     console.log(`started: ${record.startedAt}`);
     console.log(`finished: ${end}`);
-    if (record.evidencePaths.length > 0) console.log(`evidence: ${record.evidencePaths.join(", ")}`);
+    if (record.evidencePaths.length > 0) {
+      console.log("evidence:");
+      for (const evidence of record.evidencePaths) console.log(`  ${evidence}`);
+    } else {
+      console.log("evidence: none recorded");
+    }
+    console.log(`journal: ${file}`);
   }
   return EXIT.ok;
 }

package/dist/commands/launch/extension.js

@@ -9,7 +9,7 @@ import { extensionIdFromKey } from "../../adapters/extension/extension-id.js";
 import { extensionProductConfigBlock } from "../../adapters/extension/product-config.js";
 import { isExtensionDistStale } from "../../adapters/extension/runtime-decision.js";
 import { checkExtensionRuntimeHealth } from "../../adapters/extension/runtime.js";
-import { ensureExtensionHarnessFresh } from "../../adapters/extension/harness-freshness.js";
+import { ensureHarnessFresh } from "../../adapters/harness-freshness.js";
 import { stopExtensionWatcher } from "../../adapters/slot-ports.js";
 import { EXIT, spawnScriptStreaming } from "../shared.js";
 function extensionDepsBlock(target) {
@@ -46,7 +46,7 @@ Next: ${block.userAction}`
       };
     }
   }
-  await ensureExtensionHarnessFresh(target);
+  await ensureHarnessFresh(target, "extension");
   if (wantWatch) {
     const startWatchSh = path.join(runnerDir, "adapters/extension/start-watch.sh");
     const watchArgs = ["--target", target];

package/dist/commands/launch/mobile.js

@@ -1,5 +1,7 @@
 import { prepareMobile } from "../../adapters/mobile/prepare.js";
+import { ensureHarnessFresh } from "../../adapters/harness-freshness.js";
 async function launchMobile(target, mobileTarget, tier, json) {
+  await ensureHarnessFresh(target, "mobile");
   const platform = mobileTarget ?? "ios";
   const watcherPort = process.env.WATCHER_PORT ? parseInt(process.env.WATCHER_PORT, 10) : void 0;
   const preflightMode = tier === "build" ? "auto" : "fast";