@deeeed/metamask-harness 0.17.4 → 0.18.0

package/dist/adapters.js

@@ -1,6 +1,8 @@
 import http from "node:http";
 import { compatibilityMode, fixtureSummary, repoShape } from "./doctor.js";
-import { runLiveAdapterScript } from "./live-adapter-contract.js";
+import {
+  runLiveAdapterScript
+} from "./live-adapter-contract.js";
 import { withExtensionPage } from "../library/actions/extension/platform/cdp.mjs";
 import { bridgeCommand, evalSync, MOBILE_BRIDGE_ERROR_CODES, selectBridgeStatusEntry, simulatorScreenshot } from "../library/actions/mobile/platform/bridge.mjs";
 function sleep(ms) {
@@ -32,6 +34,7 @@ const LIVE_ONLY_WALLET_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.wallet.setup",
   "metamask.wallet.ensure_unlocked",
   "metamask.wallet.select_account",
+  "metamask.wallet.list_accounts",
   "metamask.wallet.read_state"
 ]);
 const LIVE_ONLY_APP_ACTIONS = /* @__PURE__ */ new Set(["ui.navigate"]);
@@ -42,14 +45,20 @@ function liveRuntimeConfigured(platform, node) {
   if (platform === "mobile" || platform === "core") return true;
   return Boolean(node.cdp_port ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT);
 }
-async function runLiveFirst(platform, action, node, context) {
+async function runLiveFirst(platform, action, node, context, forceLive = false, preparedLiveAdapters) {
   if (node.allow_static_placeholder === true) {
     throw new Error(
       `${action} refused allow_static_placeholder. MetaMask runner proof runs must use live adapters and real artifacts.`
     );
   }
-  if (!requiresLiveAdapter(platform, action) && !liveRuntimeConfigured(platform, node)) return null;
-  const live = await runLiveAdapterScript({ platform, action, node, context });
+  if (!forceLive && !requiresLiveAdapter(platform, action) && !liveRuntimeConfigured(platform, node)) return null;
+  const live = await runLiveAdapterScript({
+    platform,
+    action,
+    node,
+    context,
+    prepared: preparedLiveAdapters?.get(action)
+  });
   if (!live) return null;
   const liveResult = isRecord(live.result) ? live.result : { result: live.result };
   const output = { ...liveResult, liveAdapter: live.script };
@@ -64,10 +73,17 @@ function liveAdapterPathHint(platform, action) {
   }
   return `library/actions/${platform}/${action.replaceAll(".", "/")}.mjs`;
 }
-async function semanticResult(platform, action, node, context) {
-  const live = await runLiveFirst(platform, action, node, context);
+async function semanticResult(platform, action, node, context, forceLive = false, preparedLiveAdapters) {
+  const live = await runLiveFirst(
+    platform,
+    action,
+    node,
+    context,
+    forceLive,
+    preparedLiveAdapters
+  );
   if (live) return live;
-  if (requiresLiveAdapter(platform, action)) {
+  if (forceLive || requiresLiveAdapter(platform, action)) {
     const expected = liveAdapterPathHint(platform, action);
     throw new Error(
       `${action} requires a live ${platform} adapter that drives a real supported app/API path; no adapter script was found or no live runtime is configured (for example ${expected}). Static placeholders are refused to avoid fabricated proof. Set METAMASK_RECIPE_LIVE_ADAPTER_DIR or add a runner library/actions script.`
@@ -145,15 +161,16 @@ function probeHttpJson(url, timeoutMs = 1e3) {
     });
   });
 }
-function createMetaMaskSemanticAdapters(platform) {
+function createMetaMaskSemanticAdapters(platform, declaredCustomActions = [], preparedLiveAdapters) {
   const walletActions = [
     "metamask.wallet.fixture_status",
     "metamask.wallet.setup",
     "metamask.wallet.ensure_unlocked",
     "metamask.wallet.select_account",
+    "metamask.wallet.list_accounts",
     "metamask.wallet.read_state"
   ];
-  const actions = [
+  const bundledActions = [
     ...walletActions,
     "metamask.perps.read_positions",
     "metamask.perps.ensure_positions",
@@ -169,10 +186,19 @@ function createMetaMaskSemanticAdapters(platform) {
     // read_account is core-only: only the headless core adapter implements it.
     ...platform === "core" ? ["metamask.perps.read_account"] : []
   ];
+  const bundled = new Set(bundledActions);
+  const actions = [.../* @__PURE__ */ new Set([...bundledActions, ...declaredCustomActions])];
   return actions.map(
     (action) => simpleAdapter(
       action,
-      async (node, context) => semanticResult(platform, action, node, context)
+      async (node, context) => semanticResult(
+        platform,
+        action,
+        node,
+        context,
+        !bundled.has(action),
+        preparedLiveAdapters
+      )
     )
   );
 }
@@ -439,7 +465,7 @@ function mobileHudStatusLabel(status) {
   if (status === "pass") return "pass";
   return "run";
 }
-function createMetaMaskUiTransport(platform, harness) {
+function createMetaMaskUiTransport(platform, harness, preparedLiveAdapters) {
   if (platform === "core") {
     return {
       async execute(action) {
@@ -468,19 +494,26 @@ function createMetaMaskUiTransport(platform, harness) {
   return {
     async execute(action, node, context) {
       if (action === "ui.navigate") {
-        const live = await runLiveFirst(platform, action, node, context);
+        const live = await runLiveFirst(
+          platform,
+          action,
+          node,
+          context,
+          false,
+          preparedLiveAdapters
+        );
         if (live) return live.output;
         throw new Error(`ui.navigate requires library/actions/${platform}/ui/navigate.mjs.`);
       }
-      return base.execute(action, action === "ui.wait_for" ? normalizeUiWaitNode(node, platform) : node, context);
+      return base.execute(action, action === "ui.wait_for" ? normalizeUiWaitNode(node) : node, context);
     }
   };
 }
-function normalizeUiWaitNode(node, adapter) {
-  if (adapter !== "extension" || node.expected !== void 0 || typeof node.visible !== "boolean") return node;
+function normalizeUiWaitNode(node) {
+  if (node.expected !== void 0 || typeof node.visible !== "boolean") return node;
   return { ...node, expected: node.visible ? "visible" : "absent" };
 }
-function createMetaMaskAdapters(adapter) {
+function createMetaMaskAdapters(adapter, declaredCustomActions = [], preparedLiveAdapters) {
   const platform = adapter;
   const adapters = [
     simpleAdapter("app.status", async (_node, context) => ({
@@ -532,7 +565,7 @@ function createMetaMaskAdapters(adapter) {
         }
       };
     }),
-    ...createMetaMaskSemanticAdapters(platform)
+    ...createMetaMaskSemanticAdapters(platform, declaredCustomActions, preparedLiveAdapters)
   ];
   return adapters;
 }

package/dist/checkout-lock.js

@@ -7,7 +7,7 @@ function acquireCheckoutLock(target, operation) {
   const lockPath = path.join(repoRoot, recipeRuntimeDir(), "sandbox.lock");
   fs.mkdirSync(path.dirname(lockPath), { recursive: true });
   const inheritedToken = process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN;
-  for (let attempt = 0; attempt < 2; attempt += 1) {
+  for (let attempt = 0; attempt < 4; attempt += 1) {
     try {
       const fd = fs.openSync(lockPath, "wx", 384);
       const token = inheritedToken || randomUUID();
@@ -46,11 +46,36 @@ function acquireCheckoutLock(target, operation) {
           message: `checkout sandbox is busy with ${String(owner.operation ?? "another operation")} (pid ${owner.pid}).`
         };
       }
-      fs.rmSync(lockPath, { force: true });
+      claimStaleLock(lockPath, owner);
     }
   }
   return { path: lockPath, owner: readOwner(lockPath), message: "checkout sandbox lock could not be acquired." };
 }
+function claimStaleLock(lockPath, expectedOwner) {
+  const claimedPath = `${lockPath}.stale-${process.pid}-${randomUUID()}`;
+  try {
+    fs.renameSync(lockPath, claimedPath);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  try {
+    const claimedOwner = readOwner(claimedPath);
+    if (!sameOwner(claimedOwner, expectedOwner) || claimedOwner && typeof claimedOwner.pid === "number" && processAlive(claimedOwner.pid)) {
+      try {
+        fs.linkSync(claimedPath, lockPath);
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+    }
+  } finally {
+    fs.rmSync(claimedPath, { force: true });
+  }
+}
+function sameOwner(left, right) {
+  if (!left || !right) return left === right;
+  return left.pid === right.pid && left.token === right.token && left.startedAt === right.startedAt && left.repoRoot === right.repoRoot;
+}
 function readOwner(lockPath) {
   try {
     const value = JSON.parse(fs.readFileSync(lockPath, "utf8"));

package/dist/cli-color.js

@@ -47,6 +47,24 @@ function colorStatusWord(word, { stream = process.stderr } = {}) {
   }
   return color("info", word, { stream });
 }
+function colorHumanMessage(message, { stream = process.stderr } = {}) {
+  return String(message).split("\n").map((line) => {
+    const marker = /^(\s*)(→|✓|✗)\s?(.*)$/u.exec(line);
+    if (marker) {
+      const style = marker[2] === "\u2713" ? "ok" : marker[2] === "\u2717" ? "err" : "accent";
+      return `${marker[1]}${color(style, marker[2], { stream })}${marker[3] ? ` ${marker[3]}` : ""}`;
+    }
+    const next = /^(\s*)Next:\s*(.*)$/u.exec(line);
+    if (next) {
+      return `${next[1]}${color("label", "Next:", { stream })}${next[2] ? ` ${color("cmd", next[2], { stream })}` : ""}`;
+    }
+    const warning = /^(\s*)(WARN(?:ING)?)(:?)[ \t]*(.*)$/iu.exec(line);
+    if (warning) {
+      return `${warning[1]}${color("warn", `${warning[2]}${warning[3]}`, { stream })}${warning[4] ? ` ${warning[4]}` : ""}`;
+    }
+    return line;
+  }).join("\n");
+}
 function classifyLogEvent(event) {
   const text = String(event || "");
   if (/Module build failed|^ERROR in |BUILD FAILED|compiled with [1-9][0-9]* error/iu.test(text)) {
@@ -72,6 +90,7 @@ export {
   classifyLogEvent,
   color,
   colorEnabled,
+  colorHumanMessage,
   colorKv,
   colorLogEvent,
   colorStatusWord,

package/dist/cli-commands.js

@@ -15,7 +15,7 @@ const SPEC = {
     { name: "logs", aliases: ["tail"], desc: "Compact build events or full log", flags: ["--full", "-f", "--window", "--events", "--source", "--json"] },
     { name: "debug", aliases: ["devtools", "inspect"], desc: "Open DevTools UI", flags: ["--json", "--no-open"] },
     { name: "fixtures", desc: "Manage the canonical wallet fixture (sync/set/generate)", args: ["sync", "set", "generate"], flags: ["--fixture", "--out", "--adapter", "--target", "--device", "--json"] },
-    { name: "actions", desc: "List runnable recipe actions", flags: ["--json", "--categories", "--category", "--action"] },
+    { name: "actions", desc: "List runnable recipe actions", flags: ["--json", "--categories", "--category", "--action", "--library"] },
     { name: "doctor", desc: "Check harness/orchestration health", flags: ["--json", "--target", "--adapter", "--runtime-dir", "--expect-live", "--print-ready", "--cdp-port", "--device"] },
     { name: "run", desc: "Execute a proof recipe (path or library name, e.g. run perps.smoke)", args: ["recipe.json|name"], flags: ["--list", "--device"] },
     { name: "recipe-quality", desc: "Build the recipe-quality artifact from compact JSON", args: ["build"], flags: ["--input", "--output", "--json"] },

package/dist/cli.js

@@ -23,7 +23,6 @@ import { handleCheck } from "./commands/check.js";
 import { handleChecklist } from "./commands/checklist.js";
 import { handleLast } from "./commands/last.js";
 import { parseArgs, targetPath } from "./commands/parse-args.js";
-import { runOneNode } from "./commands/run-engine.js";
 const COMMANDS = {
   actions: handleActions,
   doctor: handleDoctor,
@@ -81,7 +80,7 @@ ONE bin: mm-harness is the only command. No per-platform binaries \u2014 platfor
 auto-detected, the positional target forces it (mm-harness launch ios), and
 platform-specific needs are FLAGS on the same command (e.g. --sidebar, --full-build).
 Human happy path = the bare command; agents add depth via flags (--json, --target, ports).
-See README.md for the current workflow and docs/CHEATSHEET.md for examples.
+See README.md for the workflow and docs/RECIPES.md for proof authoring.
 `);
 }
 async function main(argv) {
@@ -122,7 +121,7 @@ async function main(argv) {
   if (command === "stop") return handleStop(argv.slice(1));
   if (command === "logs") return handleLogs(argv.slice(1));
   if (command === "debug") return handleDebug(argv.slice(1));
-  if (command === "fixtures") return handleFixtures(argv.slice(1), { runOneNode });
+  if (command === "fixtures") return handleFixtures(argv.slice(1));
   if (command === "recipe-quality") return handleRecipeQuality(argv.slice(1));
   if (command === "check") return handleCheck(argv.slice(1));
   if (command === "checklist") return handleChecklist(argv.slice(1));

package/dist/command-contract.js

@@ -25,7 +25,12 @@ const RECIPE_RUNTIME = {
   "--validation-runtime-dir": value(),
   "--launch-existing-dist": bool(),
   "--record-video": optionalValue(["full-run", "off"]),
-  "--record": bool()
+  "--record": bool(),
+  "--source-trust": value(["trusted", "untrusted", "unknown"]),
+  "--source-kind": value(["bundled", "operator", "task", "recipe-file", "uses-catalog", "library", "custom-adapter"]),
+  "--source-name": value(),
+  "--source-digest": value(),
+  "--approve-plan": value()
 };
 const RUNWAY = {
   "--branch": value(),
@@ -82,6 +87,7 @@ const PUBLIC_COMMAND_CONTRACTS = {
       "--categories": bool(),
       "--category": value(),
       "--action-manifest": value(),
+      "--library": value(),
       "--raw": bool()
     }),
     positionals: [{ label: "query" }],
@@ -115,12 +121,16 @@ const PUBLIC_COMMAND_CONTRACTS = {
       "--run": value(),
       "--force": bool()
     }),
-    positionals: [{ label: "action", choices: ["list", "promote"] }]
+    positionals: [
+      { label: "action", choices: ["list", "describe", "promote"] },
+      { label: "ref" }
+    ]
   },
   run: {
     options: options(HELP, JSON, JSON_STREAM, TARGET, ADAPTER, ADAPTER_OR_MOBILE_PLATFORM, DEVICE, RUNTIME_PORTS, RECIPE_RUNTIME, {
       "--list": bool(),
-      "--plan": bool()
+      "--plan": bool(),
+      "--describe": bool()
     }),
     positionals: [{ label: "recipe" }],
     minimumPositionals: 1,

package/dist/commands/call.js

@@ -1,8 +1,7 @@
 import fs from "node:fs";
-import { mkdtemp } from "node:fs/promises";
-import os from "node:os";
+import { createHash } from "node:crypto";
 import path from "node:path";
-import { loadActionManifest } from "../manifest.js";
+import { resolveActionManifest } from "../manifest.js";
 import { importRecipeProtocol } from "../paths.js";
 import { recipeRunning } from "../heal-bounds.js";
 import { color } from "../cli-color.js";
@@ -28,12 +27,14 @@ import {
   prepareHeal,
   recoverRunInfra,
   resolveMetaMaskLibrarySources,
+  preflightRecipe,
   runRecipe,
   synthesizeOneNodeRecipe,
   validateRecipeAdapterAware
 } from "./run-engine.js";
 import { acquireCheckoutLock } from "../checkout-lock.js";
 import { formatRunDiagnosticsForHuman, readRunDiagnosticsDocument } from "../run-diagnostics.js";
+import { recipeTrustFailure } from "../recipe-security.js";
 async function handleCall(argv) {
   if (argv.includes("--list")) {
     const { options: options2 } = parseArgs(argv, "call");
@@ -52,7 +53,8 @@ async function handleCall(argv) {
     let discovery = "mm-harness actions";
     try {
       const { adapter: adapter2 } = resolveAdapter(options);
-      const manifest2 = loadActionManifest(adapter2, optionString(options, "actionManifest"));
+      const librarySources2 = await resolveMetaMaskLibrarySources(optionString(options, "library"));
+      const { manifest: manifest2 } = await resolveActionManifest(adapter2, optionString(options, "actionManifest"), librarySources2);
       const { getRecipeActionManifestActionNames: getRecipeActionManifestActionNames2 } = await importRecipeProtocol();
       const exampleAction = pickCallExampleAction(getRecipeActionManifestActionNames2(manifest2));
       example = `mm-harness call ${exampleAction} --adapter ${adapter2}`;
@@ -101,7 +103,8 @@ async function handleCall(argv) {
     return EXIT.bounded;
   }
   const actionManifestOverride = optionString(options, "actionManifest");
-  const manifest = loadActionManifest(adapter, actionManifestOverride);
+  const librarySources = await resolveMetaMaskLibrarySources(optionString(options, "library"));
+  const { manifest } = await resolveActionManifest(adapter, actionManifestOverride, librarySources);
   const { getRecipeActionManifestActionNames } = await importRecipeProtocol();
   const names = getRecipeActionManifestActionNames(manifest);
   const resolution = resolveActionName(shortName, names);
@@ -137,7 +140,7 @@ async function handleCall(argv) {
   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, findings: validation.findings, error: { code: "RECIPE_VALIDATION_FAILED", message, userAction } }, null, 2));
+    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));
     else {
       console.error(`\u2717 ${message}`);
       for (const finding of validation.findings) console.error(`  ${finding.code} ${finding.path} \u2014 ${finding.message}`);
@@ -145,6 +148,61 @@ async function handleCall(argv) {
     }
     return EXIT.validation;
   }
+  const artifactsDir = optionString(options, "artifactsDir") ?? defaultCallArtifactsDir(target, resolvedAction, args);
+  const requestedRuntimeOptions = runtimeOptionsFromCli(options);
+  const callRuntimeOptions = {
+    ...requestedRuntimeOptions,
+    ...librarySources ? { librarySources } : {},
+    autoHud: false,
+    stdoutIsMachineContract: json,
+    source: requestedRuntimeOptions.source ?? {
+      kind: "operator",
+      trust: "trusted",
+      name: "mm-harness call"
+    }
+  };
+  let preflightedExecution;
+  try {
+    preflightedExecution = await preflightRecipe(
+      adapter,
+      recipe,
+      artifactsDir,
+      target,
+      actionManifestOverride,
+      callRuntimeOptions
+    );
+  } catch (error) {
+    const trustFailure = recipeTrustFailure(error);
+    if (!trustFailure) throw error;
+    const planDigest = trustFailure.details?.recipeDigest;
+    if (planDigest) {
+      trustFailure.userAction = `review the plan, then rerun this call with --artifacts-dir ${shellQuote(artifactsDir)} --approve-plan ${shellQuote(planDigest)}; managed callers must keep the same artifact directory and execution environment, then set FARMSLOT_RECIPE_APPROVE_PLAN=${shellQuote(planDigest)}`;
+    }
+    if (json) {
+      console.log(JSON.stringify({
+        schemaVersion: 1,
+        command: "call",
+        status: "fail",
+        error: trustFailure,
+        exitCode: EXIT.validation
+      }, null, 2));
+    } else {
+      console.error(`\u2717 mm-harness call: ${trustFailure.message}`);
+      const blocked = trustFailure.details?.blocked;
+      if (blocked?.length) {
+        console.error("  Restricted plan nodes:");
+        for (const node of blocked.slice(0, 10)) {
+          const implementation = node.implementation?.digest ? ` implementation=${node.implementation.kind ?? "custom"}@${node.implementation.digest}` : "";
+          console.error(
+            `  - ${node.nodeId}: ${node.action} [${node.capabilities.join(", ")}] source=${node.source}${implementation}`
+          );
+        }
+        if (blocked.length > 10) console.error(`  - \u2026 ${blocked.length - 10} more (use --json)`);
+      }
+      console.error(`  Next: ${trustFailure.userAction}`);
+    }
+    return EXIT.validation;
+  }
   const lock = acquireCheckoutLock(target, "call");
   if ("message" in lock) {
     return checkoutBusyOut(json, "call", lock.message, lock.path);
@@ -155,19 +213,20 @@ async function handleCall(argv) {
     });
     if (typeof prepared === "number") return prepared;
     const { state, heal } = prepared;
-    const scratch = await mkdtemp(path.join(os.tmpdir(), "mm-harness-call-"));
-    const recipeFile = path.join(scratch, "call.recipe.json");
-    fs.writeFileSync(recipeFile, `${JSON.stringify(recipe, null, 2)}
-`);
-    const artifactsDir = optionString(options, "artifactsDir") ?? path.join(scratch, "artifacts");
-    const librarySources = await resolveMetaMaskLibrarySources(optionString(options, "library"));
-    const callRuntimeOptions = {
-      ...runtimeOptionsFromCli(options),
-      ...librarySources ? { librarySources } : {},
-      stdoutIsMachineContract: json
-    };
     const { result, violation } = await executeWithHealBounds(
-      () => runRecipe(adapter, recipeFile, artifactsDir, target, actionManifestOverride, callRuntimeOptions),
+      () => {
+        const execution = preflightedExecution;
+        preflightedExecution = void 0;
+        return runRecipe(
+          adapter,
+          recipe,
+          artifactsDir,
+          target,
+          actionManifestOverride,
+          callRuntimeOptions,
+          execution
+        );
+      },
       adapter,
       target,
       heal,
@@ -176,6 +235,8 @@ async function handleCall(argv) {
     );
     if (violation !== null) return emitHealViolation(json, "call", result, violation, state, adapter);
     const callOutput = readCallOutput(result.tracePath);
+    const safeArgs = redactCallValue(args);
+    const safeCallOutput = redactCallValue(callOutput);
     const failureUserAction = `mm-harness last --target ${shellQuote(target)} --json`;
     if (json) {
       console.log(
@@ -186,14 +247,14 @@ async function handleCall(argv) {
             adapter,
             action: shortName,
             resolvedAction,
-            args,
+            args: safeArgs,
             status: result.status,
             summaryPath: result.summaryPath,
             tracePath: result.tracePath,
             artifactManifestPath: result.artifactManifestPath,
             ...result.diagnosticsPath ? { diagnosticsPath: result.diagnosticsPath } : {},
             ...result.sideFindings ? { sideFindings: result.sideFindings } : {},
-            ...callOutput !== void 0 ? { output: callOutput } : {},
+            ...callOutput !== void 0 ? { output: safeCallOutput } : {},
             recovered: state.recovered,
             mutations: state.mutations,
             exitCode: result.status === "pass" ? EXIT.ok : EXIT.runtime,
@@ -204,9 +265,7 @@ async function handleCall(argv) {
         )
       );
     } else {
-      const rendered = callOutput !== void 0 ? `
-Result:
-${formatCallOutput(callOutput)}` : "";
+      const renderedInputs = Object.keys(args).length > 0 ? formatCallOutput(safeArgs) : "";
       const out = (style, text) => color(style, text, { stream: process.stdout });
       const diagnostics = formatRunDiagnosticsForHuman(
         readRunDiagnosticsDocument(result.diagnosticsPath),
@@ -216,9 +275,11 @@ ${formatCallOutput(callOutput)}` : "";
 ${diagnostics.map((line) => `  ${line}`).join("\n")}
 `;
       console.log(
-        `${out("label", "call")} ${out("cmd", resolvedAction)}: ${out(result.status === "pass" ? "ok" : "err", result.status)}${rendered ? `
+        `${out("label", "call")} ${out("cmd", resolvedAction)}: ${out(result.status === "pass" ? "ok" : "err", result.status)}${renderedInputs ? `
+${out("label", "Inputs:")}
+${renderedInputs}` : ""}${callOutput !== void 0 ? `
 ${out("label", "Result:")}
-${formatCallOutput(callOutput)}` : ""}
+${formatCallOutput(safeCallOutput)}` : ""}
 ` + renderedDiagnostics + `${out("label", "Artifacts:")} ${out("path", result.artifactManifestPath)}` + (result.status === "fail" ? `
   Next: ${failureUserAction}` : "")
       );
@@ -228,6 +289,11 @@ ${formatCallOutput(callOutput)}` : ""}
     lock.release();
   }
 }
+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);
+  return path.join(target, "temp", "recipe", "calls", `${actionStem}-${digest}`);
+}
 function readCallOutput(tracePath) {
   try {
     const trace = JSON.parse(fs.readFileSync(tracePath, "utf8"));
@@ -243,20 +309,32 @@ function formatCallOutput(value) {
   if (typeof value === "number" || typeof value === "boolean" || value === null) return String(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;
+}
 async function handleCallHelp(argv, genericHelp) {
   const { action: shortName, rest } = parseCallArgs(argv.filter((arg) => arg !== "--help" && arg !== "-h"));
   const { options } = parseArgs(rest, "call");
   let adapter;
   let manifest;
+  let actionSources = /* @__PURE__ */ new Map();
   try {
     ({ adapter } = resolveAdapter(options));
-    manifest = loadActionManifest(adapter, optionString(options, "actionManifest"));
+    const librarySources = await resolveMetaMaskLibrarySources(optionString(options, "library"));
+    const resolution = await resolveActionManifest(adapter, optionString(options, "actionManifest"), librarySources);
+    manifest = resolution.manifest;
+    actionSources = resolution.actionSources;
   } catch {
     process.stdout.write(`${genericHelp}
 `);
     return EXIT.ok;
   }
-  const matches = shortName ? fuzzyResolveActions(describeManifestActions(manifest), shortName) : [];
+  const matches = shortName ? fuzzyResolveActions(describeManifestActions(manifest, actionSources), shortName) : [];
   if (matches.length === 0) {
     process.stdout.write(`${genericHelp}
 `);
@@ -284,7 +362,8 @@ function renderCallActionHelp(entry) {
   );
   const lines = [`mm-harness call ${entry.name} [key=value ...] [--arg k=v ...] [flags]`, ""];
   if (entry.description) lines.push(`  ${entry.description}`, "");
-  const names = Object.keys(properties).sort();
+  lines.push(`  Source: ${entry.source}${entry.sourceManifest ? ` (${entry.sourceManifest})` : ""}`, "");
+  const names = Object.keys(properties).filter((name) => name !== "action" && name !== "next").sort();
   if (names.length === 0) {
     lines.push("  Fields: (none)");
   } else {
@@ -374,6 +453,7 @@ function isForwardedOptionValue(argv, index) {
 }
 const VALUE_TAKING_CALL_FLAGS = /* @__PURE__ */ new Set([
   "action-manifest",
+  "approve-plan",
   "adapter",
   "artifacts-dir",
   "cdp-port",
@@ -384,6 +464,10 @@ const VALUE_TAKING_CALL_FLAGS = /* @__PURE__ */ new Set([
   "platform",
   "project-root",
   "slot",
+  "source-digest",
+  "source-kind",
+  "source-name",
+  "source-trust",
   "target",
   "validation-runtime-dir",
   "watcher-port"
@@ -407,6 +491,8 @@ function pickCallExampleAction(names) {
   return names[0] ?? "command";
 }
 export {
+  defaultCallArtifactsDir,
   handleCall,
-  handleCallHelp
+  handleCallHelp,
+  redactCallValue
 };

package/dist/commands/checklist.js

@@ -4,6 +4,9 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { EXIT } from "./shared.js";
 const require2 = createRequire(import.meta.url);
+const MARK_SCRIPT = require2.resolve(
+  "@farmslot/agent-runtime/scripts/mark-checklist-step.cjs"
+);
 const USAGE = "mm-harness checklist mark <task-dir> <step> [options]";
 function terminalSignalStatus(taskDir) {
   try {
@@ -122,7 +125,7 @@ async function handleChecklist(argv) {
   teachRecipeCompletion(resolvedTaskDir, markArgs);
   const result = spawnSync(
     process.execPath,
-    [require2.resolve("@farmslot/agent-runtime/scripts/mark-checklist-step.cjs"), resolvedTaskDir, ...markArgs],
+    [MARK_SCRIPT, resolvedTaskDir, ...markArgs],
     { stdio: "inherit" }
   );
   if (result.error) {