@deeeed/metamask-harness 0.80.0 → 0.82.0

package/dist/engine.js

@@ -0,0 +1,47 @@
+import path from "node:path";
+import { getAdapterSurface } from "./adapters/surface.js";
+import { consoleClassifier } from "./console-classifier.js";
+import {
+  authorizeTrustedMutationPlan,
+  fixturePolicyMutationBase,
+  fundingOptionsFromCli,
+  isFixturePolicyBase,
+  loadTrustedMutationBase
+} from "./funding-execution-context.js";
+import { resolveActionManifest, validateManifest } from "./manifest.js";
+import { LIBRARY_ACTION_NAMESPACE, runnerDir } from "./paths.js";
+import { metaMaskActionExecutionCapabilities } from "./recipe-security.js";
+const metaMaskEngine = {
+  bundledLibrary: {
+    name: "metamask",
+    root: path.resolve(runnerDir, "library"),
+    actionNamespace: LIBRARY_ACTION_NAMESPACE
+  },
+  resolveActionManifest,
+  validateManifest,
+  actionCapabilities: metaMaskActionExecutionCapabilities,
+  createRunner: async (adapter, manifest, options) => {
+    const { createMetaMaskRunner } = await import("./runner.js");
+    return createMetaMaskRunner(adapter, manifest, options);
+  },
+  // Funding files from the run's command line, bound to the run's plan. Without
+  // them, a platform whose actions take a trusted mutation (the Extension) runs a
+  // plan with external mutations in the fixture-policy lane, where each action
+  // applies the shared order policy; any other plan runs without one.
+  trustedMutation: {
+    load: async ({ cli, adapter, ...run }) => await loadTrustedMutationBase({ ...fundingOptionsFromCli(cli), ...run }) ?? (getAdapterSurface(adapter).actions.trustedMutation === true ? fixturePolicyMutationBase({ artifactsDir: run.artifactsDir, rootRecipe: run.rootRecipe }) : void 0),
+    // Nothing to bind (undefined): recipe-cli keeps the runner it planned with.
+    authorize: async (base, plan) => {
+      if (!base) return void 0;
+      if (isFixturePolicyBase(base) && !plan.nodes.some((node) => node.capabilities.includes("external-mutation"))) {
+        return void 0;
+      }
+      return authorizeTrustedMutationPlan(base, plan);
+    }
+  },
+  console: consoleClassifier,
+  runnerIncludes: ["src", "adapters", "library", "bin", "dist", "package.json"]
+};
+export {
+  metaMaskEngine
+};

package/dist/funding-execution-context.js

@@ -35,6 +35,7 @@ const CLAIM_DIFF_FIELDS = [
   "operationCounts"
 ];
 const trustedActionContexts = /* @__PURE__ */ new WeakSet();
+const fixturePolicySources = /* @__PURE__ */ new WeakMap();
 const fundingSources = /* @__PURE__ */ new WeakMap();
 const CURRENT_FUNDING_REGISTRY_SHA256 = "d4416e0e8a812a0e2f1798ae6f901a5820f7ee0b9783cfa5d515d0c7863ea80e";
 const PREVIOUS_FUNDING_REGISTRY_SHA256 = "7e79ee2a5f7bdde0a5548208cb2eab55881575cc7d826ee5f7acdbf15d49609c";
@@ -141,7 +142,70 @@ async function loadTrustedMutationBase(options) {
   });
   return trusted;
 }
+const FIXTURE_POLICY_LANE = "fixture-policy";
+const fixturePolicyMarker = (field) => sha256(`${FIXTURE_POLICY_LANE}:${field}`);
+function fixturePolicyMutationBase(options) {
+  if (!path.isAbsolute(options.artifactsDir)) {
+    throw new Error("Runner artifactsDir must be absolute before a mutation context is created.");
+  }
+  const rootRecipeSha256 = normalizeRecipeDigest(digestRecipeDocument(options.rootRecipe));
+  const base = deepFreeze({
+    runId: sha256(canonical({ lane: FIXTURE_POLICY_LANE, artifactsDir: options.artifactsDir, rootRecipeSha256 })),
+    rootRecipeSha256,
+    requestSha256: fixturePolicyMarker("request"),
+    preflightSha256: fixturePolicyMarker("preflight"),
+    releaseProofSha256: fixturePolicyMarker("release-proof"),
+    balanceProofSha256: fixturePolicyMarker("balance-proof"),
+    fundingRequirementsSha256: fixturePolicyMarker("requirements"),
+    runtimeArtifactSha256: fixturePolicyMarker("runtime-artifact"),
+    runtimeTreeSha256: fixturePolicyMarker("runtime-tree"),
+    registrySha256: fixturePolicyMarker("registry"),
+    profileId: FIXTURE_POLICY_LANE,
+    domain: "perps",
+    client: "extension",
+    proofLane: FIXTURE_POLICY_LANE,
+    targetId: FIXTURE_POLICY_LANE,
+    subjectDigest: fixturePolicyMarker("subject"),
+    selectedIdentitySha256: "",
+    runtimeSessionId: "",
+    cdpPort: 0,
+    cdpTargetId: "",
+    extensionOrigin: "",
+    operations: [],
+    budgets: [],
+    requirements: []
+  });
+  fixturePolicySources.set(base, { artifactsDir: options.artifactsDir });
+  return base;
+}
+function isFixturePolicyBase(base) {
+  return base?.proofLane === FIXTURE_POLICY_LANE;
+}
+async function authorizeFixturePolicyPlan(base, plan) {
+  const source = fixturePolicySources.get(base);
+  if (!source) throw new Error("Fixture-policy plan authorization requires the runner-created context.");
+  const executionPlanSha256 = normalizeRecipeDigest(plan.digest);
+  await mkdir(source.artifactsDir, { recursive: true, mode: 448 });
+  const artifactsDir = await realpath(source.artifactsDir);
+  const artifactsIdentitySha256 = await directoryIdentity(artifactsDir);
+  const executionLedgerRoot = path.join(artifactsDir, "mutation-ledger");
+  await ensurePrivateDirectory(artifactsDir, executionLedgerRoot);
+  const runId = sha256(canonical({
+    lane: FIXTURE_POLICY_LANE,
+    rootRecipeSha256: base.rootRecipeSha256,
+    executionPlanSha256,
+    artifactsIdentitySha256
+  }));
+  const authorized = deepFreeze({ ...base, runId, executionPlanSha256, artifactsIdentitySha256 });
+  fixturePolicySources.set(authorized, {
+    ...source,
+    executionLedgerRoot,
+    executionClaimSha256: sha256(canonical({ kind: "fixture-policy-execution-claim", runId, executionPlanSha256 }))
+  });
+  return authorized;
+}
 async function authorizeTrustedMutationPlan(base, plan, testIo = {}) {
+  if (isFixturePolicyBase(base)) return authorizeFixturePolicyPlan(base, plan);
   const source = fundingSources.get(base);
   if (!source) throw new Error("Funding plan authorization requires the original runner-verified context.");
   const executionPlanSha256 = normalizeRecipeDigest(plan.digest);
@@ -228,6 +292,20 @@ async function authorizeTrustedMutationPlan(base, plan, testIo = {}) {
   return authorized;
 }
 async function trustedMutationForAction(base, recipe, selectedIdentitySha256) {
+  if (isFixturePolicyBase(base)) {
+    const source2 = fixturePolicySources.get(base);
+    if (!source2?.executionLedgerRoot || !source2.executionClaimSha256) {
+      throw new Error("External mutation requires an authorized run-owned execution ledger.");
+    }
+    const trusted2 = deepFreeze({
+      ...base,
+      recipeSha256: normalizeRecipeDigest(digestRecipeDocument(recipe)),
+      executionLedgerRoot: source2.executionLedgerRoot,
+      executionClaimSha256: source2.executionClaimSha256
+    });
+    trustedActionContexts.add(trusted2);
+    return trusted2;
+  }
   if (!selectedIdentitySha256 || !SHA256.test(selectedIdentitySha256)) {
     throw new Error(
       "External mutation requires a successful same-run metamask.wallet.import selected identity proof. Next: run metamask.wallet.import before the mutation node."
@@ -1442,8 +1520,11 @@ function deepFreeze(value) {
   return value;
 }
 export {
+  FIXTURE_POLICY_LANE,
   authorizeTrustedMutationPlan,
+  fixturePolicyMutationBase,
   fundingOptionsFromCli,
+  isFixturePolicyBase,
   loadTrustedMutationBase,
   selectedIdentityFromWalletImport,
   serializeTrustedMutationContext,

package/dist/manifest.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { OFFICIAL_RECIPE_ACTIONS } from "@farmslot/protocol";
 import { getAdapterSurface } from "./adapters/surface.js";
-import { manifestPath, readJson, importRecipeProtocol } from "./paths.js";
+import { manifestPath, readJson, importRecipeProtocol, runnerDir } from "./paths.js";
 function loadMetaMaskMobileActionManifest() {
   return asActionManifest(readJson(manifestPath("mobile")));
 }
@@ -12,14 +12,26 @@ function loadMetaMaskExtensionActionManifest() {
 function loadMetaMaskCoreActionManifest() {
   return asActionManifest(readJson(manifestPath("core")));
 }
-function loadMetaMaskTerminalActionManifest() {
-  return asActionManifest(readJson(manifestPath("terminal")));
-}
 function loadActionManifest(adapter, overridePath) {
   if (overridePath) return asActionManifest(readJson(path.resolve(overridePath)));
   return asActionManifest(readJson(getAdapterSurface(adapter).actions.manifestPath()));
 }
+class ActionManifestError extends Error {
+  code = "ACTION_MANIFEST_INVALID";
+  userAction;
+  constructor(adapter, cause) {
+    super(cause instanceof Error ? cause.message : String(cause));
+    this.userAction = `fix the ${adapter} action manifest the message names, then rerun`;
+  }
+}
 async function resolveActionManifest(adapter, overridePath, librarySources, taskActionRoot) {
+  try {
+    return await resolveActionManifestSources(adapter, overridePath, librarySources, taskActionRoot);
+  } catch (error) {
+    throw error instanceof ActionManifestError ? error : new ActionManifestError(adapter, error);
+  }
+}
+async function resolveActionManifestSources(adapter, overridePath, librarySources, taskActionRoot) {
   if (overridePath) {
     const manifestPath2 = path.resolve(overridePath);
     const implementationRoot = path.resolve(
@@ -38,9 +50,12 @@ async function resolveActionManifest(adapter, overridePath, librarySources, task
       })
     };
   }
-  const canonicalPath = path.resolve(getAdapterSurface(adapter).actions.manifestPath());
+  const surfaceActions = getAdapterSurface(adapter).actions;
+  const canonicalPath = path.resolve(surfaceActions.manifestPath());
   const canonicalRoot = path.dirname(path.dirname(canonicalPath));
-  const sources = librarySources?.length ? librarySources : [{ name: "metamask", root: canonicalRoot }];
+  const bundledRoot = path.resolve(runnerDir, "library");
+  const canonicalName = canonicalRoot === bundledRoot ? "metamask" : path.basename(canonicalRoot);
+  const sources = librarySources?.length ? librarySources : [{ name: canonicalName, root: canonicalRoot }];
   const manifests = [];
   for (const source of sources) {
     const file = path.resolve(source.root, "manifests", `${adapter}.action-manifest.json`);
@@ -49,31 +64,39 @@ async function resolveActionManifest(adapter, overridePath, librarySources, task
     await validateManifest(manifest);
     manifests.push({ source, file, manifest });
   }
+  for (const declared of surfaceActions.manifestPaths?.() ?? []) {
+    const file = path.resolve(declared);
+    if (file === canonicalPath || manifests.some((entry) => entry.file === file)) continue;
+    const manifest = asActionManifest(readJson(file));
+    await validateManifest(manifest);
+    const root = path.dirname(path.dirname(file));
+    const source = sources.find((candidate) => path.resolve(candidate.root) === root) ?? { name: path.basename(root), root };
+    manifests.push({ source, file, manifest });
+  }
   if (!manifests.some((entry) => entry.file === canonicalPath)) {
     const manifest = loadActionManifest(adapter);
     await validateManifest(manifest);
     manifests.push({
-      source: { name: "metamask", root: canonicalRoot },
+      source: { name: canonicalName, root: canonicalRoot },
       file: canonicalPath,
       manifest
     });
   }
   const canonical = manifests.find((entry) => entry.file === canonicalPath);
   if (!canonical) throw new Error(`No ${adapter} action manifest could be resolved.`);
+  const isBundled = (entry) => path.resolve(entry.source.root) === bundledRoot;
+  const bundledParents = manifests.filter((entry) => entry !== canonical && isBundled(entry));
   const official = new Set(OFFICIAL_RECIPE_ACTIONS);
-  const canonicalActions = actionsOf(canonical.manifest);
   const mergedActions = {};
-  for (const [name, entry] of Object.entries(canonicalActions)) {
-    if (official.has(name)) mergedActions[name] = entry;
-  }
   const actionSources = /* @__PURE__ */ new Map();
-  for (const name of Object.keys(mergedActions)) {
-    actionSources.set(name, {
-      name: "official",
-      tier: "official",
-      manifestPath: canonical.file
-    });
+  for (const entry of [canonical, ...bundledParents]) {
+    for (const [name, action] of Object.entries(actionsOf(entry.manifest))) {
+      if (!official.has(name) || name in mergedActions) continue;
+      mergedActions[name] = action;
+      actionSources.set(name, { name: "official", tier: "official", manifestPath: entry.file });
+    }
   }
+  const observers = bundledParents.length ? [canonical, ...bundledParents].flatMap((entry) => entry.manifest.observers ?? []).filter((observer, index, all) => all.findIndex((other) => other.ref === observer.ref) === index) : canonical.manifest.observers;
   const custom = /* @__PURE__ */ new Set();
   const ordered = [
     ...manifests.filter((entry) => entry.file !== canonicalPath),
@@ -81,24 +104,25 @@ async function resolveActionManifest(adapter, overridePath, librarySources, task
   ];
   for (const entry of ordered) {
     const isCanonical = entry.file === canonicalPath;
-    if (!isCanonical && entry.manifest.observers?.length) {
+    const bundled = isBundled(entry);
+    if (!isCanonical && !bundled && entry.manifest.observers?.length) {
       throw new Error(
         `Library manifest ${entry.file} declares observers, but external library observers are not executable; remove observers or use an explicit task action manifest.`
       );
     }
-    const sourceName = isCanonical ? "metamask" : entry.source.name ?? path.basename(entry.source.root);
-    const tier = isCanonical ? "canonical" : sourceName === "personal" ? "personal" : "team";
+    const sourceName = bundled ? "metamask" : entry.source.name ?? path.basename(entry.source.root);
+    const tier = bundled ? "canonical" : sourceName === "personal" ? "personal" : "team";
     const implementationRoot = path.join(entry.source.root, "actions");
     const sourceInfo = {
       name: sourceName,
       tier,
       manifestPath: entry.file,
       implementationRoot,
-      trust: entry.source.provenance?.trust ?? (isCanonical ? "trusted" : "unknown")
+      trust: entry.source.provenance?.trust ?? (bundled ? "trusted" : "unknown")
     };
     for (const [name, action] of Object.entries(actionsOf(entry.manifest))) {
       if (official.has(name)) {
-        if (!isCanonical) {
+        if (!isCanonical && !bundled) {
           throw new Error(
             `Library action ${name} from ${entry.file} conflicts with an official action; team libraries may declare namespaced custom actions only.`
           );
@@ -121,7 +145,7 @@ async function resolveActionManifest(adapter, overridePath, librarySources, task
     manifest: {
       $schema: canonical.manifest.$schema,
       actions: mergedActions,
-      ...canonical.manifest.observers ? { observers: canonical.manifest.observers } : {}
+      ...observers ? { observers } : {}
     },
     actionSources
   };
@@ -163,11 +187,11 @@ function asActionManifest(value) {
   return value;
 }
 export {
+  ActionManifestError,
   loadActionManifest,
   loadMetaMaskCoreActionManifest,
   loadMetaMaskExtensionActionManifest,
   loadMetaMaskMobileActionManifest,
-  loadMetaMaskTerminalActionManifest,
   resolveActionManifest,
   validateManifest
 };

package/dist/mm-harness-cli.js

@@ -4,14 +4,16 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
-import { color, withCommandJournal, JsonStreamWriter, detectAdapter } from "@farmslot/recipe-cli/harness";
+import { color, withCommandJournal, JsonStreamWriter, detectAdapter, handleCallHelp } from "@farmslot/recipe-cli/harness";
 import { handleUpdate, maybeNudge } from "./commands/update.js";
 import { handlePin } from "./commands/pin.js";
-import { handleCallHelp } from "./commands/call.js";
+import { metaMaskEngine } from "./engine.js";
 import { handleHelp } from "./commands/help.js";
 import { handleTutorial } from "./commands/tutorial.js";
 import { handleSetupBase } from "./commands/setup-base.js";
+import { loadSelectedAdapter } from "./adapters/plugin-surface.js";
 import { getAdapterSurface } from "./adapters/surface.js";
+import { ActionManifestError } from "./manifest.js";
 import { configPath, hydrateLibraryPathEnv, readConfig } from "./review/knowledge.js";
 import {
   PUBLIC_COMMAND_CONTRACTS,
@@ -1088,6 +1090,17 @@ async function delegate(argv) {
   try {
     return await recipeMain(argv);
   } catch (error) {
+    const own = argv.includes("--") ? argv.slice(0, argv.indexOf("--")) : argv;
+    if (error instanceof ActionManifestError && own.includes("--json")) {
+      console.log(JSON.stringify({
+        schemaVersion: 1,
+        command: argv[0],
+        status: "fail",
+        exitCode: 1,
+        error: { code: error.code, message: error.message, userAction: error.userAction }
+      }, null, 2));
+      return 1;
+    }
     console.error(error instanceof Error ? error.message : String(error));
     return error !== null && typeof error === "object" && "exitCode" in error && typeof error.exitCode === "number" ? error.exitCode : 1;
   }
@@ -1226,11 +1239,15 @@ if (!preflightBypass.has(rawArgv[0] ?? "")) {
   }
 }
 await hydrateLibraryPathEnv({ target: targetFromArgv(rawArgv), config: readConfig(configPath()) });
+{
+  const refused = await loadSelectedAdapter(rawArgv[0] ?? "", rawArgv.slice(1));
+  if (refused !== void 0) process.exit(refused);
+}
 if (hasPassthroughHelp(rawArgv)) {
   process.exit(await delegate(rawArgv));
 }
 if (isCallActionHelp(rawArgv)) {
   const callHelp = REAL.find((command) => command.name === "call")?.helpText ?? "";
-  process.exit(await handleCallHelp(rawArgv.slice(1), callHelp));
+  process.exit(await handleCallHelp(rawArgv.slice(1), callHelp, { catalog: metaMaskEngine }));
 }
 await program.parseAsync(process.argv);

package/dist/performance-observation.js

@@ -15,19 +15,13 @@ const sessions = /* @__PURE__ */ new Map();
 const DEFAULT_MAX_DURATION_MS = 5 * 60 * 1e3;
 const MAX_DURATION_MS = 60 * 60 * 1e3;
 const gzipAsync = promisify(gzip);
-function startRunPerformanceObservation(adapter, target, artifactsDir, env, ports = {}) {
-  const observer = getAdapterSurface(adapter).observation?.performance;
-  if (!observer) return void 0;
+function startRunPerformanceObservation(observer, { target, artifactsDir, env }) {
   const key = path.resolve(artifactsDir);
   const session = {
     observer,
     artifactsDir: key,
-    env: {
-      ...env,
-      ...ports.watcherPort ? { WATCHER_PORT: ports.watcherPort } : {}
-    },
+    env,
     nodeEvents: [],
-    ports,
     target,
     windows: /* @__PURE__ */ new Map()
   };
@@ -154,7 +148,7 @@ async function performanceBackend(session) {
   if (session.backend) return session.backend;
   if (session.backendError) throw new Error(session.backendError);
   try {
-    session.backend = await session.observer.backend(session.target, session.env, session.ports);
+    session.backend = await session.observer.backend(session.target, session.env);
     return session.backend;
   } catch (error) {
     session.backendError = errorMessage(error);
@@ -517,13 +511,11 @@ function unavailableCapture(session, window, reason) {
     session.nodeEvents
   );
 }
-async function createExtensionPerformanceObserver(target, env, ports) {
-  return createExtensionPerformanceBackend(extensionCdpPort(ports, env), target);
+async function createExtensionPerformanceObserver(target, env) {
+  return createExtensionPerformanceBackend(extensionCdpPort(env), target);
 }
-function extensionCdpPort(ports, env) {
-  const port = Number(
-    ports.cdpPort ?? env.CDP_PORT ?? env.RECIPE_CDP_PORT
-  );
+function extensionCdpPort(env) {
+  const port = Number(env.CDP_PORT ?? env.RECIPE_CDP_PORT);
   if (!Number.isInteger(port) || port <= 0) {
     throw new Error("Extension performance observation requires CDP_PORT.");
   }

package/dist/recipe-assistance-context.js

@@ -1,11 +1,10 @@
 import fs from "node:fs";
 import { createHash } from "node:crypto";
 import { loadRecipeLibraries, resolveRecipeDependencies, rootResolutionRef } from "@farmslot/recipe-runner";
-import { isSensitiveKey, CliError, isRecord, optionStrings, EXIT } from "@farmslot/recipe-cli/harness";
+import { isSensitiveKey, CliError, describeManifestActions, isRecord, optionStrings, EXIT, resolveLibrarySources, validateRunRecipeStatic } 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 { metaMaskEngine } from "./engine.js";
 import { MAX_ADVICE_STATE_BYTES } from "./recipe-assistance-rubric.js";
 function digest(value) {
   return createHash("sha256").update(value).digest("hex");
@@ -46,7 +45,7 @@ async function buildAdviceContext(input) {
   const task = readInput(input.task);
   if (!input.recipe) throw new CliError("Advice requires a recipe. Next: use recipe-quality plan before authoring.", EXIT.usage);
   readInput(input.recipe);
-  const validated = await validateRunRecipeStatic(input.recipe, input.adapter, input.options ?? {}, input.params);
+  const validated = await validateRunRecipeStatic(metaMaskEngine, input.recipe, input.adapter, input.options ?? {}, input.params);
   if (validated.usageError || !validated.schemaValid || !isRecord(validated.recipe)) {
     const detail = validated.usageError?.message ?? validated.findings.map((finding) => finding.message).join("; ");
     throw new CliError(`Recipe is not statically valid: ${detail}. Next: run mm-harness run ${input.recipe} --plan --adapter ${input.adapter}.`, EXIT.validation);
@@ -56,7 +55,7 @@ async function buildAdviceContext(input) {
   const dependencies = resolveRecipeDependencies({ rootRef: rootResolutionRef(rootDigest), root: validated.recipe, rootSource: { kind: "recipe-file", trust: "unknown", digest: rootDigest }, recipes: library.recipes });
   const composition = recipeComposition(validated.recipe, dependencies.recipes);
   const { manifest, actionSources } = await resolveActionManifest(input.adapter, void 0, validated.librarySources);
-  const catalog = describeManifestActions(manifest, actionSources);
+  const catalog = describeManifestActions(metaMaskEngine, manifest, actionSources);
   const used = new Set(composition.actions);
   const actions = catalog.filter((action) => used.has(action.name)).map(({ name, description, schema, capabilities }) => ({ name, description, schema, capabilities }));
   const domains = new Set(composition.actions.map((name) => name.split(".").slice(0, -1).join(".")));
@@ -108,12 +107,12 @@ async function buildPlanningContext(input) {
     throw new CliError("Planning requires 1\u201320 non-empty acceptanceCriteria strings. Next: supply a focused JSON task.", EXIT.validation);
   }
   const criteria = task.acceptanceCriteria;
-  const sources = await resolveMetaMaskLibrarySources(optionStrings(input.options ?? {}, "library"));
+  const sources = await resolveLibrarySources(metaMaskEngine, optionStrings(input.options ?? {}, "library"));
   const library = await loadRecipeLibraries(sources ?? [], { adapter: input.adapter });
   const { manifest, actionSources } = await resolveActionManifest(input.adapter, void 0, sources);
   const candidates = [
     ...[...library.recipes.values()].map((recipe) => ({ id: `recipe:${recipe.ref}`, kind: "recipe", ref: recipe.ref, description: typeof recipe.document.description === "string" ? recipe.document.description : "", parameters: recipe.document.paramsSchema, source: recipe.source, provenance: recipe.provenance, shadows: recipe.shadows })),
-    ...describeManifestActions(manifest, actionSources).map((action) => ({ id: `action:${action.name}`, kind: "action", ref: action.name, description: action.description, parameters: action.schema, capabilities: action.capabilities, source: action.source, sourceTier: action.sourceTier, shadows: action.shadows }))
+    ...describeManifestActions(metaMaskEngine, manifest, actionSources).map((action) => ({ id: `action:${action.name}`, kind: "action", ref: action.name, description: action.description, parameters: action.schema, capabilities: action.capabilities, source: action.source, sourceTier: action.sourceTier, shadows: action.shadows }))
   ];
   const terms = new Set(criteria.join(" ").toLowerCase().match(/[a-z][a-z_]{3,}/gu) ?? []);
   const score = (candidate) => [...new Set(`${candidate.ref} ${candidate.description}`.toLowerCase().match(/[a-z][a-z_]{3,}/gu) ?? [])].filter((word) => terms.has(word)).length;

package/dist/runner.js

@@ -1,4 +1,5 @@
 import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { OFFICIAL_RECIPE_ACTIONS } from "@farmslot/protocol";
 import { createMetaMaskAdapters, createMetaMaskUiTransport } from "./adapters.js";
 import { getAdapterSurface } from "./adapters/surface.js";
@@ -8,6 +9,7 @@ import {
   resolveMetaMaskMobileLifecycleTarget
 } from "./app-lifecycle.js";
 import { loadMetaMaskExtensionActionManifest, loadMetaMaskMobileActionManifest } from "./manifest.js";
+import { adapterPlugin } from "@farmslot/recipe-cli/harness";
 import { actionSourceIntegrity, metaMaskActionExecutionCapabilities } from "./recipe-security.js";
 import {
   createRecordingTargetProvider,
@@ -23,6 +25,7 @@ import {
   runnerDir
 } from "./paths.js";
 import {
+  isFixturePolicyBase,
   selectedIdentityFromWalletImport,
   trustedMutationForAction
 } from "./funding-execution-context.js";
@@ -49,7 +52,12 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
   const { createReactNativeBridgeUiTransport } = await importRecipeHarnessRuntimeReactNativeBridge();
   const { createAppLifecycleAdapters } = await importRecipeHarnessAppLifecycle();
   const actions = Object.keys(actionManifest.actions);
-  const customActions = actions.filter((action) => !OFFICIAL_ACTIONS.has(action));
+  const surface = getAdapterSurface(adapter);
+  const coded = await surface.actions.adapters?.() ?? [];
+  const codedActions = new Set(coded.map((entry) => entry.action));
+  const customActions = actions.filter(
+    (action) => !OFFICIAL_ACTIONS.has(action) && !codedActions.has(action)
+  );
   const actionSources = options.actionSources ? new Map([...options.actionSources].map(([action, source]) => [action, { ...source }])) : void 0;
   const preparedLiveAdapters = await prepareLiveAdapterImplementations(
     adapter,
@@ -57,6 +65,7 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
     actionSources,
     options.trustTaskActions
   );
+  bindPluginDigest(actionSources, codedActions, adapterPlugin(adapter)?.digest);
   const declaredActions = new Set(actions);
   const core = createStandardCoreAdapters({ actions });
   const projectOwnedOfficialActions = /* @__PURE__ */ new Set(["app.status", "app.lifecycle"]);
@@ -72,7 +81,6 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
     }, preparedLiveAdapters, { hudPolicy: options.autoHud === true ? "show" : "auto" })
   });
   const existing = new Set([...core, ...ui].map((entry) => entry.action));
-  const surface = getAdapterSurface(adapter);
   const lifecycleAdapters = bindMetaMaskMobileLifecycleDeadline(
     createAppLifecycleAdapters({
       actions,
@@ -81,11 +89,12 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
     })
   );
   const lifecycle = surface.actions.lifecycle ? await surface.actions.lifecycle(lifecycleAdapters) : lifecycleAdapters;
-  const custom = createMetaMaskAdapters(
-    adapter,
-    customActions,
-    preparedLiveAdapters
-  ).filter(
+  const custom = [
+    ...coded,
+    ...createMetaMaskAdapters(adapter, customActions, preparedLiveAdapters).filter(
+      (entry) => !codedActions.has(entry.action)
+    )
+  ].filter(
     (entry) => declaredActions.has(entry.action) && !existing.has(entry.action) && !lifecycle.some((lifecycleEntry) => lifecycleEntry.action === entry.action)
   );
   const autoHudDisabled = options.autoHud === false || options.autoHud === void 0 && (process.env.METAMASK_RECIPE_AUTO_HUD === "0" || process.env.METAMASK_RECIPE_AUTO_HUD === "false");
@@ -166,7 +175,7 @@ function withTrustedMutationContext(adapters, base, externalMutationActions) {
         throw error;
       });
       if (invalidatesIdentity) selectedIdentitySha256 = void 0;
-      const selected = selectedIdentityFromWalletImport(entry.action, result, base);
+      const selected = isFixturePolicyBase(base) ? void 0 : selectedIdentityFromWalletImport(entry.action, result, base);
       if (selected) {
         if (base && base.selectedIdentitySha256 !== selected) {
           throw new Error("Same-run wallet identity changed after its trusted import proof.");
@@ -196,6 +205,17 @@ function deduplicateLibraryResolutionLogs(logger, suppress = false) {
     }
   };
 }
+function bindPluginDigest(sources, actions, pluginDigest) {
+  if (!sources || !pluginDigest) return;
+  const bind = (digest) => `sha256:${createHash("sha256").update(`${digest}\0${pluginDigest}`).digest("hex")}`;
+  for (const action of actions) {
+    const source = sources.get(action);
+    if (!source) continue;
+    const { digest, resolveDigest } = source;
+    source.digest = bind(digest ?? "");
+    source.resolveDigest = resolveDigest ? async () => bind(await resolveDigest()) : void 0;
+  }
+}
 async function prepareLiveAdapterImplementations(platform, actions, sources, trustTaskActions = false) {
   const prepared = /* @__PURE__ */ new Map();
   if (!sources) return prepared;

package/docs/CONTRIBUTING.md

@@ -79,8 +79,10 @@ context, prepare) and `readiness.ts` (doctor and status). Do not add
 command-local platform ladders for surface-owned behavior:
 - `launch` dispatches through `AdapterSurface.launch` (the device platforms
   share `src/commands/launch/device.ts` through a `DeviceLaunchProfile`);
-- `run`/`call` read `run`, `recording`, `diagnostics`, `observation` and
-  `sourceFingerprint`;
+- `run`/`call` come from `@farmslot/recipe-cli/harness` and read `run`,
+  `recording`, `diagnostics`, `observation` and `sourceFingerprint`;
+  mm-harness hands them its engine (`src/engine.ts`) and its device targeting
+  and plan steps (`src/cli.ts`);
 - the runner reads `actions` (manifest, bundled semantic actions, live adapter
   scripts, `cdp.target`, the `ui.*` transport, adapter wrappers, input checks);
 - `install`/`verify`/`cleanup` read `harness`, `agentic-runtime.json` reads

package/docs/RECIPES.md

@@ -245,9 +245,37 @@ Use the snapshot recipe's `history` object to bound existing record dates and
 `capture_path` to separate evidence when composing calls. Market sampling does
 not repeatedly fetch history.
 
-The two live recipes require explicit `confirm_live=true`. The trusted runner
-must also verify the exact consented funding request, preflight, release proof,
-and contained balance proof. Market placement declares the exact provider and
+Perps orders follow one rule on Mobile, Extension and Core
+(`library/actions/shared/perps/order-policy.mjs`), checked before dispatch:
+
+- Testnet: allowed with no funding proof.
+- Mainnet: only from a synced fixture account (`wallet-fixture.json`), as a 1x
+  isolated market order with `close_immediately: true`, and the node must
+  declare `network: mainnet`. The $15 limit bounds the size the controller would
+  submit: (amount + one size step × price) × (1 + max slippage). Anything else
+  is refused with `PERPS_MAINNET_ORDER_REFUSED`, naming each broken limit, and
+  no order is sent.
+- `close_immediately: true` needs a market order from a flat market: no
+  position and no resting order in it. Positions are netted per market, so the
+  close takes the market's whole position; don't share a fixture account's
+  market with a concurrent run. The action closes the opened position itself
+  and proves the market flat. On mainnet it also checks the position opened
+  isolated 1x and within $15. A placement that fails after dispatch has its
+  position closed too.
+- The account and network the rule allowed are rechecked around the flat-market
+  reads, before dispatch and before any close; if either changed, nothing is
+  sent or closed.
+- Core still needs `CORE_PERPS_ALLOW_MAINNET_WRITES=1` for any mainnet write.
+
+On the Extension, a run without funding files gets that rule through the
+fixture-policy lane: the runner binds the run and a run-owned execution ledger
+(`<artifacts>/mutation-ledger`), and each mutation completes the context from
+the live app, so receipts and resume work as in a funded run. The funding files
+below remain the stricter release lane.
+
+The two live recipes require explicit `confirm_live=true`. A funded run's
+trusted runner must also verify the exact consented funding request, preflight,
+release proof, and contained balance proof. Market placement declares the exact provider and
 network; background placement and cancellation refuse a mismatch without
 toggling it. Immediately before publication and dispatch, the action also reads
 the current visible Perps Home balance and requires the runner-trusted minimum.

package/docs/cli-contract.md

@@ -92,9 +92,11 @@ These are real farm bugs. The goldens freeze the current rejections, so fixing e
 
 ## Terminal adapter
 
-`goldens-terminal` freezes the `va-mmcx-terminal-farm` hooks with their exact argv (`recipe_action_manifest`, `recipe_doctor`, `recipe_harness_{install,verify,cleanup}`, `recipe_run`, the browser `boot`/`shutdown` resources and `teardown`), against a fresh fixture slot: no slot dev server, no Extension dist, and the farm's wallet fixture outside the slot, so `install` copies it in. `launch` is frozen on its cold path: it refuses at the missing dist before any browser starts. The slot's CDP port is the one port no port holder reserves: a farm slot with no browser has it free, and the Terminal's port checks probe it. `goldens-discovery` covers `terminal` in its per-adapter loop, so `terminal/actions-raw` and `discovery/actions-raw-terminal` freeze the same manifest and change together.
+`goldens-terminal` freezes the `va-mmcx-terminal-farm` hooks with their exact argv (`recipe_action_manifest`, `recipe_doctor`, `recipe_harness_{install,verify,cleanup}`, `recipe_run`, the browser `boot`/`shutdown` resources and `teardown`), against a fresh fixture slot: no slot dev server, no Extension dist, and the farm's wallet fixture outside the slot, so `install` copies it in. `launch` is frozen on its cold path: it refuses at the missing dist before any browser starts. The slot's CDP port is the one port no port holder reserves: a farm slot with no browser has it free, and the Terminal's port checks probe it.
 
-Outside this boundary: a successful `launch` and the `temp/recipe/runtime/terminal/` layout (`browser.pid`), recipes and actions from the farm's `RECIPE_LIBRARY_PATH` libraries, `run terminal.perps.<name> --plan`, and the recipe-terminal `console-guard.mjs` import paths.
+`terminal` is the plugin the `experimental-metamask-recipe-terminal` library declares (`adapters.terminal`, extends the built-in `web-dapp`), so the family loads it: set `GOLDENS_TERMINAL_LIBRARY` to a checkout of that library, which the family copies into its sandbox and puts on `RECIPE_LIBRARY_PATH`. CI has no access to the private library and skips the family (`CI` set); local runs need the variable, and without it outside CI the family fails. A release gate must set it too (proposed for the release checklist). `goldens-discovery` covers the built-in `web-dapp` in its per-adapter loop.
+
+Outside this boundary: a successful `launch` and the `temp/recipe/runtime/terminal/` layout (`browser.pid`), the library's recipes, `run terminal.perps.<name> --plan`, and the recipe-terminal `console-guard.mjs` import paths.
 
 ## Running the goldens
 
@@ -142,7 +144,7 @@ The goldens need the harness to be a git checkout: `execution-provenance.json` `
 2. UUIDs become `<UUID>`. Git object ids (40 hex, or a short hex value under a `*head`/`*gitRef`/`*commit` key) become `<GIT_REF>`. ISO-8601 timestamps become `<TIMESTAMP>`, and compact stamps in names `<STAMP>`. Path-derived slot ids `local-<adapter>-<8 hex>` become `local-<adapter>-<HASH>`.
 3. The package version becomes `<HARNESS_VERSION>`. Any other `x.y.z` under a key ending in `version` becomes `<VERSION>`.
 4. Numbers under volatile keys: `*pid` becomes `<PID>`, `inode` `<INODE>`, `*port` `<PORT>`, `*At`/`*Time`/`*timestamp`/`mtime*` `<TIMESTAMP>`, and `*Ms`/`duration*`/`elapsed*` `<DURATION>`. Values inside `schema` and `examples` subtrees (static manifest content) are never rewritten.
-5. `invocationDigest` becomes `<DIGEST>`: it hashes `recipe-invocation.json`, which carries sandbox paths and timestamps and is frozen itself in normalised form. `runner.sourceFingerprint` becomes `<FINGERPRINT>`: it hashes the harness source tree, so any harness edit changes it. A `status` holding `git status --porcelain` output (provenance `runner.status` and `libraries[].status`, empty when clean) becomes `<GIT_STATUS>`. Content-only digests (recipe and dependency digests) stay frozen.
+5. `invocationDigest` becomes `<DIGEST>`: it hashes `recipe-invocation.json`, which carries sandbox paths and timestamps and is frozen itself in normalised form. `runner.sourceFingerprint` becomes `<FINGERPRINT>`: it hashes the harness source tree, so any harness edit changes it. A `status` holding `git status --porcelain` output (provenance `runner.status` and `libraries[].status`, empty when clean) becomes `<GIT_STATUS>`. A loaded adapter plugin's code digest in doctor's `adapter-plugin:<id>` message becomes `sha256:<PLUGIN_DIGEST>`: it hashes the recipe library's plugin files, so any library edit changes it. Content-only digests (recipe and dependency digests) stay frozen.
 6. Durations in text (`0.3s`, `123ms`) become `<DURATION>`.
 
 In tree listings, files whose names differ only by a volatile token collapse into one row: a count and the union of their key shapes, or the sorted list of their values in a value tree.