@deeeed/metamask-harness 0.79.0 → 0.80.0

package/dist/commands/status.js

@@ -1,18 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
 import { featureFlagReport } from "../feature-flags.js";
-import { color } from "../cli-color.js";
+import { color, detectAdapter, adapterDetectNext, EXIT, usageOut, optionFlag, optionString, targetPath } from "@farmslot/recipe-cli/harness";
 import { collectCheckoutView, renderCheckoutView } from "../checkout-view.js";
-import { detectAdapter } from "../harness.js";
 import { assertAdapter } from "../paths.js";
 import { getAdapterSurface } from "../adapters/surface.js";
 import {
   applyDeviceTargeting
 } from "./device-target.js";
-import { ADAPTER_DETECT_NEXT, EXIT, usageOut } from "./shared.js";
 import { handleStatusTaskView, renderAcceptanceLines } from "./status-watch.js";
 import { collectTaskView, findTaskDir } from "../task-view.js";
-import { optionFlag, optionString, targetPath } from "./parse-args.js";
 async function handleStatus({ options }) {
   const target = targetPath(options);
   const json = optionFlag(options, "json");
@@ -29,7 +26,7 @@ async function handleStatus({ options }) {
   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);
+    return usageOut(json, "status", `could not detect the MetaMask repo type for ${target}`, adapterDetectNext());
   }
   assertAdapter(adapter);
   const view = collectCheckoutView(target, adapter);

package/dist/commands/task-init.js

@@ -1,8 +1,7 @@
+import { harnessExecutable, detectAdapter, EXIT } from "@farmslot/recipe-cli/harness";
 import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
-import { detectAdapter } from "../harness.js";
-import { harnessExecutable } from "../paths.js";
-import { EXIT } from "./shared.js";
+import "../adapters/surface.js";
 const require2 = createRequire(import.meta.url);
 const USAGE = "mm-harness task init <task-dir> --flow f --template id --title t [options]";
 function hasOption(argv, name) {

package/dist/commands/tutorial.js

@@ -1,5 +1,5 @@
+import { parseArgs } from "@farmslot/recipe-cli/harness";
 import { spawnSync } from "node:child_process";
-import { parseArgs } from "./parse-args.js";
 const PROTECTED_TUTORIAL_URL = "https://glowing-chainsaw-gwzrn8k.pages.github.io/recipes.html#agent-method";
 function recipeTutorialUrl(runMode = process.env.MM_HARNESS_RUN_MODE) {
   if (runMode === "src") {
@@ -13,7 +13,7 @@ function openUrl(url) {
   return result.status === 0;
 }
 function handleTutorial(argv, context) {
-  const parsed = parseArgs(argv, "tutorial");
+  const parsed = parseArgs(argv);
   const url = recipeTutorialUrl();
   const noOpen = parsed.options.noOpen === true;
   const opened = noOpen ? false : (context.open ?? openUrl)(url);

package/dist/commands/update.js

@@ -1,9 +1,9 @@
+import { EXIT, flag, parseFlags } from "@farmslot/recipe-cli/harness";
 import { spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { runnerDir } from "../paths.js";
-import { EXIT, flag, parseFlags } from "./shared.js";
 const PACKAGE_NAME = "@deeeed/metamask-harness";
 const NUDGE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 const NUDGE_FETCH_TIMEOUT_MS = 2e3;

package/dist/completions-cache.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { recipeRuntimePath } from "./paths.js";
+import { recipeRuntimePath } from "@farmslot/recipe-cli/harness";
 const COMPLETION_CACHE_VERSION = 2;
 const COMPLETION_CACHE_TTL_MS = 6e4;
 function completionCachePath(projectRoot) {

package/dist/console-classifier.js

@@ -0,0 +1,19 @@
+import {
+  allowlistMatch,
+  classifyConsoleRecord,
+  consoleRecords,
+  libraryRootsFromEnv,
+  loadConsoleAllowlist,
+  messageSignature
+} from "../library/actions/shared/console-findings.mjs";
+const consoleClassifier = {
+  records: (text) => consoleRecords(text),
+  classify: (record) => classifyConsoleRecord(record),
+  signature: (message) => messageSignature(message),
+  loadAllowlist: (libraryRoots) => loadConsoleAllowlist([...libraryRoots]),
+  match: (event, allowlist) => allowlistMatch(event, allowlist),
+  libraryRoots: () => libraryRootsFromEnv()
+};
+export {
+  consoleClassifier
+};

package/dist/doctor.js

@@ -1,11 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { color } from "./cli-color.js";
+import { color, harnessExecutable, recipeHarnessRoot, recipeRuntimeDir, readRuntimeContextField, resolveRuntimeContextPath } from "@farmslot/recipe-cli/harness";
 import { normalizeFeatureFlagRecord } from "./feature-flags.js";
 import { getAdapterSurface } from "./adapters/surface.js";
-import { readRuntimeContextField, resolveRuntimeContextPath } from "./harness.js";
 import { isPin } from "./harness-pin.js";
-import { harnessExecutable, readJson, recipeHarnessRoot, recipeRuntimeDir, runnerDir } from "./paths.js";
+import { readJson, runnerDir } from "./paths.js";
 function requiredDoctorCheckSummary(checks) {
   const required = checks.filter((check) => check.required);
   const failed = required.filter((check) => check.status === "fail").map((check) => check.id);

package/dist/funding-execution-context.js

@@ -1,10 +1,10 @@
+import { optionString, recipeRuntimeDir } from "@farmslot/recipe-cli/harness";
 import { createHash } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { chmod, lstat, mkdir, open, readFile, readdir, realpath } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { digestRecipeDocument } from "@farmslot/protocol";
-import { recipeRuntimeDir } from "./paths.js";
 const SHA256 = /^[a-f0-9]{64}$/u;
 const INTEGER = /^(0|[1-9][0-9]{0,39})$/u;
 const IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
@@ -255,6 +255,18 @@ async function trustedMutationForAction(base, recipe, selectedIdentitySha256) {
   trustedActionContexts.add(trusted);
   return trusted;
 }
+function fundingOptionsFromCli(options) {
+  return {
+    fundingRequest: optionString(options, "fundingRequest"),
+    fundingPreflight: optionString(options, "fundingPreflight"),
+    fundingReleaseProof: optionString(options, "fundingReleaseProof"),
+    fundingBalanceProof: optionString(options, "fundingBalanceProof")
+  };
+}
+function trustedMutationContextExtras(context) {
+  const trusted = context.trustedMutation;
+  return trusted ? { trustedMutation: serializeTrustedMutationContext(trusted) } : void 0;
+}
 function serializeTrustedMutationContext(value) {
   if (!isRecord(value) || !trustedActionContexts.has(value)) {
     throw new Error("Live adapter refused an untrusted mutation context.");
@@ -1431,8 +1443,10 @@ function deepFreeze(value) {
 }
 export {
   authorizeTrustedMutationPlan,
+  fundingOptionsFromCli,
   loadTrustedMutationBase,
   selectedIdentityFromWalletImport,
   serializeTrustedMutationContext,
+  trustedMutationContextExtras,
   trustedMutationForAction
 };

package/dist/host.js

@@ -0,0 +1,32 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { configureHarnessAdapters, configureHarnessHost } from "@farmslot/recipe-cli/harness";
+import { adapterRegistry } from "./adapters/registry.js";
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+configureHarnessHost({
+  name: "mm-harness",
+  product: "MetaMask",
+  envPrefix: "MM_HARNESS",
+  recipeEnvPrefix: "METAMASK_RECIPE",
+  packageName: "@deeeed/metamask-harness",
+  packageRoot,
+  bin: "bin/mm-harness",
+  journaledCommands: [
+    "prepare",
+    "call",
+    "check",
+    "checklist",
+    "cleanup",
+    "doctor",
+    "fixtures",
+    "install",
+    "launch",
+    "runtime-launch",
+    "provision",
+    "recipe-quality",
+    "run",
+    "stop",
+    "verify"
+  ]
+});
+configureHarnessAdapters(adapterRegistry);

package/dist/index.js

@@ -1,3 +1,4 @@
+import "./host.js";
 import { createDoctorReport } from "./doctor.js";
 import { loadActionManifest, validateManifest } from "./manifest.js";
 import { createMetaMaskExtensionRunner, createMetaMaskMobileRunner, createMetaMaskRunner } from "./runner.js";
@@ -5,13 +6,9 @@ import {
   extensionIdPath,
   importRecipeHarnessRuntimeBrowserExtension,
   importRecipeHarnessRuntimeCdp,
-  recipeHarnessPath,
   walletFixturePath
 } from "./paths.js";
-import { captureActiveRecipeRecordingSnapshot } from "./run-recording.js";
-import { validateRuntimeProof } from "./runtime-proof.js";
 export {
-  captureActiveRecipeRecordingSnapshot,
   createDoctorReport,
   createMetaMaskExtensionRunner,
   createMetaMaskMobileRunner,
@@ -20,8 +17,6 @@ export {
   importRecipeHarnessRuntimeBrowserExtension,
   importRecipeHarnessRuntimeCdp,
   loadActionManifest,
-  recipeHarnessPath,
   validateManifest,
-  validateRuntimeProof,
   walletFixturePath
 };

package/dist/live-tsx.js

@@ -0,0 +1,49 @@
+import { accessSync, constants, existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+const requireFromHarness = createRequire(import.meta.url);
+function harnessTsxBin() {
+  try {
+    const manifest = requireFromHarness.resolve("tsx/package.json");
+    const { bin } = JSON.parse(readFileSync(manifest, "utf8"));
+    const relative = typeof bin === "string" ? bin : bin?.tsx;
+    return relative ? path.join(path.dirname(manifest), relative) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function liveTsxCandidates() {
+  const bin = harnessTsxBin();
+  return bin ? [bin] : [];
+}
+function isExecutable(file) {
+  try {
+    accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveOverride(override, projectRoot) {
+  if (!override.includes("/")) {
+    return (process.env.PATH ?? "").split(path.delimiter).map((dir) => path.join(path.resolve(projectRoot, dir || "."), override)).find(isExecutable);
+  }
+  const bin = path.resolve(projectRoot, override);
+  return isExecutable(bin) ? bin : void 0;
+}
+function resolveLiveTsx(projectRoot) {
+  const override = process.env.TSX_BIN;
+  if (override) {
+    const bin = resolveOverride(override, path.resolve(projectRoot));
+    return bin ? { bin, source: "TSX_BIN" } : null;
+  }
+  const target = path.join(path.resolve(projectRoot), "node_modules/.bin/tsx");
+  if (existsSync(target)) return { bin: target, source: "target" };
+  const harness = harnessTsxBin();
+  return harness && existsSync(harness) ? { bin: harness, source: "harness" } : null;
+}
+export {
+  harnessTsxBin,
+  liveTsxCandidates,
+  resolveLiveTsx
+};

package/dist/mm-harness-cli.js

@@ -1,11 +1,10 @@
+import "./host.js";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
-import { color } from "./cli-color.js";
-import { withCommandJournal } from "./command-journal.js";
-import { JsonStreamWriter } from "./json-stream.js";
+import { color, withCommandJournal, JsonStreamWriter, detectAdapter } from "@farmslot/recipe-cli/harness";
 import { handleUpdate, maybeNudge } from "./commands/update.js";
 import { handlePin } from "./commands/pin.js";
 import { handleCallHelp } from "./commands/call.js";
@@ -13,7 +12,6 @@ import { handleHelp } from "./commands/help.js";
 import { handleTutorial } from "./commands/tutorial.js";
 import { handleSetupBase } from "./commands/setup-base.js";
 import { getAdapterSurface } from "./adapters/surface.js";
-import { detectAdapter } from "./harness.js";
 import { configPath, hydrateLibraryPathEnv, readConfig } from "./review/knowledge.js";
 import {
   PUBLIC_COMMAND_CONTRACTS,

package/dist/network-observation.js

@@ -1,6 +1,6 @@
 import path from "node:path";
-import brokerModule from "../adapters/mobile/bridge-runtime/lib/cdp-broker.cjs";
-import configModule from "../adapters/mobile/bridge-runtime/lib/config.cjs";
+import brokerModule from "@farmslot/recipe-runner/cdp-broker";
+import configModule from "@farmslot/adapter-rn/bridge-runtime/lib/config.cjs";
 import {
   createExtensionNetworkObserver
 } from "./adapters/extension/network-observer.js";
@@ -8,7 +8,7 @@ import { getAdapterSurface } from "./adapters/surface.js";
 import {
   indexArtifactManifest,
   writeContainedArtifact
-} from "./artifact-files.js";
+} from "@farmslot/recipe-cli/harness";
 const AUTO_CAPTURE_ID = "run-network";
 const AUTO_ARTIFACT_PATH = "network/run-summary.json";
 const { brokerSocketPath, createBrokerClient } = brokerModule;
@@ -179,7 +179,7 @@ function selectMobileBrokerTarget(value, env) {
 }
 function mobileTargetPin(env) {
   const platform = String(
-    env.MM_HARNESS_EXPLICIT_PLATFORM ?? env.RECIPE_HARNESS_PLATFORM ?? ""
+    env.RECIPE_RN_EXPLICIT_PLATFORM ?? env.RECIPE_HARNESS_PLATFORM ?? ""
   ).toLowerCase();
   return String(
     platform === "android" ? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? "" : platform === "ios" ? env.IOS_SIMULATOR ?? "" : env.IOS_SIMULATOR ?? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? ""

package/dist/paths.js

@@ -1,43 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { recipeRuntimeDir, recipeRuntimePath } from "@farmslot/recipe-cli/harness";
 import { adapterRegistry } from "./adapters/registry.js";
 const runnerDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const pathDefaults = readPathDefaults();
-const DEFAULT_RECIPE_RUNTIME_DIR = pathDefaults.recipeRuntimeDir;
-const DEFAULT_RECIPE_HARNESS_ROOT = pathDefaults.recipeHarnessRoot;
 const PREPARE_PROGRESS_ARTIFACT = "prepare/progress.json";
-function recipeRuntimeDir() {
-  return validateRelativeRecipePath("RECIPE_RUNTIME_DIR", process.env.RECIPE_RUNTIME_DIR || DEFAULT_RECIPE_RUNTIME_DIR);
-}
-function recipeHarnessRoot() {
-  return validateRelativeRecipePath("RECIPE_HARNESS_ROOT", process.env.RECIPE_HARNESS_ROOT || DEFAULT_RECIPE_HARNESS_ROOT);
-}
-function harnessExecutable() {
-  return path.resolve(process.env.MM_HARNESS_EXECUTABLE ?? path.join(runnerDir, "bin/mm-harness"));
-}
-function readPathDefaults() {
-  const defaultsPath = path.join(runnerDir, "adapters/shared/path-defaults.json");
-  const parsed = JSON.parse(fs.readFileSync(defaultsPath, "utf8"));
-  return {
-    recipeRuntimeDir: validateRelativeRecipePath("recipeRuntimeDir", parsed.recipeRuntimeDir || ""),
-    recipeHarnessRoot: validateRelativeRecipePath("recipeHarnessRoot", parsed.recipeHarnessRoot || "")
-  };
-}
-function validateRelativeRecipePath(name, value) {
-  if (!value || path.isAbsolute(value)) throw new Error(`${name} must be a non-empty relative path: ${value}`);
-  if (!/^[A-Za-z0-9._/-]+$/u.test(value)) throw new Error(`${name} contains unsupported characters: ${value}`);
-  for (const part of value.split("/")) {
-    if (!part || part === "." || part === "..") throw new Error(`${name} contains unsafe path component: ${value}`);
-  }
-  return value;
-}
-function recipeRuntimePath(projectRoot, ...segments) {
-  return path.join(projectRoot, recipeRuntimeDir(), ...segments);
-}
-function recipeHarnessPath(projectRoot, ...segments) {
-  return path.join(projectRoot, recipeHarnessRoot(), ...segments);
-}
 function walletFixturePath(projectRoot) {
   return recipeRuntimePath(projectRoot, "wallet-fixture.json");
 }
@@ -51,42 +18,51 @@ function recipeWatchLogCandidates() {
   ];
 }
 function resolveLocalProtocolRoot() {
-  const candidates = [
-    process.env.METAMASK_RUNNER_PROTOCOL_ROOT,
-    readConfiguredProtocolRoot(),
-    findProtocolRoot(runnerDir),
-    findProtocolRoot(process.cwd())
-  ].filter(Boolean);
-  const root = candidates[0];
+  const root = process.env.METAMASK_RUNNER_PROTOCOL_ROOT || readConfiguredProtocolRoot();
   return root ? path.resolve(root) : void 0;
 }
-function resolveRequiredLocalProtocolRoot(reason) {
-  const root = resolveLocalProtocolRoot();
-  if (!root) {
-    throw new Error(
-      `${reason} requires a local protocol/runtime checkout. Set METAMASK_RUNNER_PROTOCOL_ROOT or create .farmslot-root for this dev-only path.`
-    );
+function resolveFarmslotPoolDir(starts = [runnerDir, process.cwd()]) {
+  const configured = resolveLocalProtocolRoot();
+  if (configured) return path.join(configured, "pool");
+  for (const start of starts) {
+    const pool = findPoolDir(start);
+    if (pool) return pool;
   }
-  return root;
+  return void 0;
 }
+const LIBRARY_ACTION_NAMESPACE = "metamask";
 function readConfiguredProtocolRoot() {
   const configPath = path.join(runnerDir, ".farmslot-root");
   if (!fs.existsSync(configPath)) return void 0;
   const value = fs.readFileSync(configPath, "utf8").trim();
   return value || void 0;
 }
-function findProtocolRoot(start) {
+function findPoolDir(start) {
   let dir = path.resolve(start);
   while (dir !== path.dirname(dir)) {
-    if (isProtocolRoot(dir)) return dir;
-    const sibling = path.join(dir, "farmslot");
-    if (isProtocolRoot(sibling)) return sibling;
+    for (const root of [dir, path.join(dir, "farmslot")]) {
+      const pool = path.join(root, "pool");
+      if (holdsSlotPool(pool)) return pool;
+    }
     dir = path.dirname(dir);
   }
   return void 0;
 }
-function isProtocolRoot(candidate) {
-  return fs.existsSync(path.join(candidate, "packages/recipe-runner/package.json")) && fs.existsSync(path.join(candidate, "packages/protocol/package.json"));
+function holdsSlotPool(candidate) {
+  let names;
+  try {
+    names = fs.readdirSync(candidate);
+  } catch {
+    return false;
+  }
+  return names.some((name) => {
+    if (!name.endsWith(".json") || name.includes(".bak")) return false;
+    try {
+      return Array.isArray(JSON.parse(fs.readFileSync(path.join(candidate, name), "utf8"))?.slots);
+    } catch {
+      return false;
+    }
+  });
 }
 function assertAdapter(adapter) {
   const ids = adapterRegistry.list();
@@ -140,8 +116,8 @@ async function importRecipeHarnessRuntimeReactNativeBridge() {
 }
 async function importMetaMaskNativeUiProvider() {
   return importProtocolPackage(
-    "@farmslot/expo-recipe",
-    "packages/expo-recipe/src/index.ts"
+    "@farmslot/adapter-rn",
+    "packages/adapter-rn/src/index.ts"
   );
 }
 async function importRecipeRunnerCli() {
@@ -176,12 +152,10 @@ function isMissingPackageError(error, packageName) {
   return (code === "ERR_MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED") && error.message.includes(packageName);
 }
 export {
-  DEFAULT_RECIPE_HARNESS_ROOT,
-  DEFAULT_RECIPE_RUNTIME_DIR,
+  LIBRARY_ACTION_NAMESPACE,
   PREPARE_PROGRESS_ARTIFACT,
   assertAdapter,
   extensionIdPath,
-  harnessExecutable,
   importMetaMaskNativeUiProvider,
   importRecipeHarness,
   importRecipeHarnessAppLifecycle,
@@ -192,14 +166,10 @@ export {
   importRecipeRunnerCli,
   manifestPath,
   readJson,
-  recipeHarnessPath,
-  recipeHarnessRoot,
   recipePath,
-  recipeRuntimeDir,
-  recipeRuntimePath,
   recipeWatchLogCandidates,
+  resolveFarmslotPoolDir,
   resolveLocalProtocolRoot,
-  resolveRequiredLocalProtocolRoot,
   runnerDir,
   walletFixturePath
 };

package/dist/performance-observation.js

@@ -4,13 +4,13 @@ import { gzip } from "node:zlib";
 import { getAdapterSurface } from "./adapters/surface.js";
 import { createExtensionPerformanceBackend } from "./adapters/extension/performance-observer.js";
 import { TRACE_KINDS } from "./adapters/performance/cdp-trace.js";
-import { summarizeFrames } from "./adapters/mobile/frame-metrics.js";
+import { summarizeFrames } from "@farmslot/adapter-rn";
 import { summarizeJavaScriptTasks } from "./adapters/performance/js-task-metrics.js";
 import {
   indexArtifactManifest,
   readContainedJsonArtifact,
   writeContainedArtifact
-} from "./artifact-files.js";
+} from "@farmslot/recipe-cli/harness";
 const sessions = /* @__PURE__ */ new Map();
 const DEFAULT_MAX_DURATION_MS = 5 * 60 * 1e3;
 const MAX_DURATION_MS = 60 * 60 * 1e3;

package/dist/progress.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { parseArgs } from "node:util";
-import { color } from "./cli-color.js";
+import { color } from "@farmslot/recipe-cli/harness";
 function shouldEmitJson(explicit) {
   if (explicit) return true;
   const env = process.env.RECIPE_PROGRESS_JSON;

package/dist/recipe-assistance-context.js

@@ -1,13 +1,11 @@
 import fs from "node:fs";
 import { createHash } from "node:crypto";
 import { loadRecipeLibraries, resolveRecipeDependencies, rootResolutionRef } from "@farmslot/recipe-runner";
-import { isSensitiveKey } from "./command-journal.js";
+import { isSensitiveKey, CliError, isRecord, optionStrings, EXIT } from "@farmslot/recipe-cli/harness";
 import { resolveActionManifest } from "./manifest.js";
 import { describeManifestActions } from "./commands/manifest.js";
 import { recipeComposition } from "@farmslot/recipe-cli";
 import { resolveMetaMaskLibrarySources, validateRunRecipeStatic } from "./commands/run-engine.js";
-import { CliError, isRecord, optionStrings } from "./commands/parse-args.js";
-import { EXIT } from "./commands/shared.js";
 import { MAX_ADVICE_STATE_BYTES } from "./recipe-assistance-rubric.js";
 function digest(value) {
   return createHash("sha256").update(value).digest("hex");

package/dist/recipe-security.js

@@ -18,6 +18,7 @@ const READ_ONLY_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.perps.read_positions",
   "metamask.perps.read_orders",
   "metamask.perps.read_account",
+  "metamask.perps.quote_fees",
   "metamask.perps.read_snapshot",
   "metamask.perps.assert_visible_consistency",
   "metamask.perps.assert_positions",
@@ -175,65 +176,7 @@ function isPathWithin(root, candidate) {
 function isMissing(error) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
 }
-function explicitRecipeTrustOptions(values) {
-  const { sourceTrust, sourceKind, sourceName, sourceDigest, approvalDigest } = values;
-  const source = sourceTrust || sourceKind || sourceName || sourceDigest ? {
-    trust: sourceTrust ?? "unknown",
-    kind: sourceKind ?? "recipe-file",
-    ...sourceName ? { name: sourceName } : {},
-    ...sourceDigest ? { digest: sourceDigest } : {}
-  } : void 0;
-  return {
-    ...source ? { source } : {},
-    ...approvalDigest ? { approval: { planDigest: approvalDigest } } : {}
-  };
-}
-function recipeTrustFailure(error) {
-  if (!error || typeof error !== "object") return void 0;
-  const value = error;
-  if (typeof value.code !== "string" || !value.code.startsWith("RECIPE_") || typeof value.message !== "string" || typeof value.userAction !== "string") return void 0;
-  const failure = value.failure && typeof value.failure === "object" ? value.failure : void 0;
-  const blocked = Array.isArray(failure?.blocked) ? failure.blocked.flatMap((entry) => {
-    if (!entry || typeof entry !== "object") return [];
-    const node = entry;
-    if (typeof node.nodeId !== "string" || typeof node.action !== "string" || !Array.isArray(node.capabilities)) return [];
-    const origin = node.origin && typeof node.origin === "object" ? node.origin : void 0;
-    const adapterOrigin = node.adapterOrigin && typeof node.adapterOrigin === "object" ? node.adapterOrigin : void 0;
-    const implementation = adapterOrigin ? {
-      ...typeof adapterOrigin.kind === "string" ? { kind: adapterOrigin.kind } : {},
-      ...typeof adapterOrigin.trust === "string" ? { trust: adapterOrigin.trust } : {},
-      ...typeof adapterOrigin.digest === "string" ? { digest: adapterOrigin.digest } : {}
-    } : void 0;
-    return [{
-      nodeId: node.nodeId,
-      action: node.action,
-      capabilities: node.capabilities.filter(
-        (item) => typeof item === "string"
-      ),
-      source: typeof origin?.kind === "string" ? origin.kind : "unknown",
-      ...implementation && Object.keys(implementation).length > 0 ? { implementation } : {}
-    }];
-  }) : void 0;
-  const recipeDigest = typeof failure?.recipeDigest === "string" ? failure.recipeDigest : void 0;
-  const userAction = recipeDigest && (value.code === "RECIPE_TRUST_REQUIRED" || value.code === "RECIPE_APPROVAL_MISMATCH") && !value.userAction.includes("execution environment") ? `${value.userAction}; rerun with the same project root, artifact directory, and execution environment` : value.userAction;
-  return {
-    code: value.code,
-    message: value.message,
-    userAction,
-    ...failure ? {
-      details: {
-        // Farmslot reports the approved execution plan digest as
-        // recipeDigest in failures; approval input names it planDigest.
-        ...recipeDigest ? { recipeDigest } : {},
-        ...typeof failure.trust === "string" ? { trust: failure.trust } : {},
-        ...blocked?.length ? { blocked } : {}
-      }
-    } : {}
-  };
-}
 export {
   actionSourceIntegrity,
-  explicitRecipeTrustOptions,
-  metaMaskActionExecutionCapabilities,
-  recipeTrustFailure
+  metaMaskActionExecutionCapabilities
 };

package/dist/review/knowledge.js

@@ -1,9 +1,9 @@
+import { detectAdapter, usageError } from "@farmslot/recipe-cli/harness";
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { detectAdapter } from "../harness.js";
-import { usageError } from "../commands/parse-args.js";
+import "../adapters/surface.js";
 const REVIEW_ADAPTERS = ["mobile", "extension", "core", "terminal"];
 const ADVISOR_STAGES = ["plan", "draft", "evidence"];
 function parseAdvisorSettings(value) {

package/dist/runner.js

@@ -10,10 +10,11 @@ import {
 import { loadMetaMaskExtensionActionManifest, loadMetaMaskMobileActionManifest } from "./manifest.js";
 import { actionSourceIntegrity, metaMaskActionExecutionCapabilities } from "./recipe-security.js";
 import {
+  createRecordingTargetProvider,
   prepareLiveAdapterScript
-} from "./live-adapter-contract.js";
-import { createMetaMaskRecordingTargetProvider } from "./recording-target.js";
+} from "@farmslot/recipe-cli/harness";
 import {
+  LIBRARY_ACTION_NAMESPACE,
   importMetaMaskNativeUiProvider,
   importRecipeHarness,
   importRecipeHarnessAppLifecycle,
@@ -109,7 +110,7 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
     ),
     logger,
     recording: {
-      targetProvider: createMetaMaskRecordingTargetProvider(adapter),
+      targetProvider: createRecordingTargetProvider(adapter),
       ...videoRecorder ? { videoRecorder } : {}
     },
     runner: runnerProvenance(),
@@ -204,6 +205,7 @@ async function prepareLiveAdapterImplementations(platform, actions, sources, tru
     const executable = await prepareLiveAdapterScript({
       platform,
       action,
+      namespace: LIBRARY_ACTION_NAMESPACE,
       implementationRoot: source.implementationRoot,
       allowRuntimeImports: source.tier === "canonical" || source.trust === "trusted" || source.tier === "task" && trustTaskActions
     });

package/dist/runtime-context.js

@@ -1,10 +1,10 @@
+import { recipeRuntimeDir } from "@farmslot/recipe-cli/harness";
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { getAdapterSurface } from "./adapters/surface.js";
-import { recipeRuntimeDir } from "./paths.js";
 function ensureRuntimeContext(target, adapter) {
   const repoRoot = fs.realpathSync(target);
   const runtimeDir = recipeRuntimeDir();