@deeeed/metamask-harness 0.21.0 → 0.23.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## Unreleased
 
+## 0.23.0 - 2026-07-28
+
+### Added
+
+- Core Perps actions support trigger orders, attached and partial TP/SL, and position TP/SL updates.
+
+### Fixed
+
+- Core advanced-order mutations verify the submitted order fields, use executable trigger-limit defaults, honor bounded evidence polling, and classify mutation capabilities correctly.
+- Core advanced-order camelCase aliases validate consistently with their documented snake_case forms.
+
+## 0.22.0 - 2026-07-26
+
+### Added
+
+- Added `execution-template` as the thin public boundary for shared checklist discovery and materialization.
+
+### Fixed
+
+- `ui.navigate page=home` recognizes both the current bottom navigation and the selected legacy Tokens tab.
+- Extension readiness recovers deterministically from transient target-list failures.
+- Team-library calls retain their source provenance.
+
 ## 0.21.0 - 2026-07-24
 
 ### Changed

package/dist/adapters/extension/ensure-ready.js

@@ -36,9 +36,11 @@ async function openHome(port, extensionId) {
   try {
     let res = await fetch(endpoint, { method: "PUT", signal: AbortSignal.timeout(8e3) });
     if (res.status === 404 || res.status === 405) res = await fetch(endpoint, { signal: AbortSignal.timeout(8e3) });
-    return res.ok;
+    if (!res.ok) return null;
+    const value = await res.json();
+    return value && typeof value === "object" ? value : {};
   } catch {
-    return false;
+    return null;
   }
 }
 function homePages(targets, extensionId) {
@@ -94,7 +96,7 @@ async function ensureExtensionReady(target, options) {
         continue;
       }
       action = "opened";
-      opened = await openHome(cdpPort, extensionId) || opened;
+      opened = Boolean(await openHome(cdpPort, extensionId)) || opened;
       await sleep(1500);
     } else {
       action = "pruned";
@@ -149,20 +151,47 @@ async function ensureExtensionReady(target, options) {
   if (action === "pruned" && (health.status !== "PASS" || after !== 1)) {
     const listing = await jsonList(cdpPort);
     if (listing.ok) {
-      action = "reopened";
-      for (const h of homePages(listing.targets, extensionId)) {
-        await closeTab(cdpPort, String(h.id));
-        closed += 1;
-      }
-      await sleep(500);
-      opened = await openHome(cdpPort, extensionId) || opened;
+      const existingHomeIds = new Set(
+        homePages(listing.targets, extensionId).map((home) => String(home.id))
+      );
+      const replacement = await openHome(cdpPort, extensionId);
+      opened = Boolean(replacement) || opened;
       await sleep(1500);
-      const relisted = await jsonList(cdpPort);
-      if (!relisted.ok) {
-        return base({ extensionId, opened, action, homeTabs: { before, closed, after }, reasonCode: "cdp-unreachable" });
+      const replacementListing = await jsonList(cdpPort);
+      if (!replacementListing.ok) {
+        return base({
+          extensionId,
+          opened,
+          action,
+          homeTabs: { before, closed, after },
+          reasonCode: "cdp-unreachable"
+        });
+      }
+      const replacementHomes = homePages(replacementListing.targets, extensionId);
+      const replacementId = replacement?.id && replacementHomes.some((home) => home.id === replacement.id) ? String(replacement.id) : replacementHomes.find((home) => !existingHomeIds.has(String(home.id)))?.id;
+      if (replacementId) {
+        action = "reopened";
+        for (const home of replacementHomes) {
+          if (String(home.id) === replacementId) continue;
+          await closeTab(cdpPort, String(home.id));
+          closed += 1;
+        }
+        await sleep(500);
+        const relisted = await jsonList(cdpPort);
+        if (!relisted.ok) {
+          return base({
+            extensionId,
+            opened,
+            action,
+            homeTabs: { before, closed, after },
+            reasonCode: "cdp-unreachable"
+          });
+        }
+        after = homePages(relisted.targets, extensionId).length;
+        health = await checkHealth();
+      } else {
+        after = replacementHomes.length;
       }
-      after = homePages(relisted.targets, extensionId).length;
-      health = await checkHealth();
     }
   }
   let slotTitle;

package/dist/cli-commands.js

@@ -18,6 +18,7 @@ const SPEC = {
     { 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: "execution-template", desc: "Discover and materialize shared agent checklists", args: ["list", "materialize", "lint", "new"], flags: ["--dir", "--domain-dir", "--project-worker", "--project-name", "--package-templates", "--package-id", "--flow", "--run-mode", "--platform", "--domain", "--id", "--provenance", "--include-shadowed", "--no-include-shadowed", "--title", "--force", "--json"] },
     { name: "recipe-quality", desc: "Build the recipe-quality artifact from compact JSON", args: ["build"], flags: ["--input", "--output", "--json"] },
     { name: "interactive", aliases: ["menu"], desc: "Interactive command menu" },
     { name: "prepare", desc: "Install harness (+ optional validate)", flags: ["--target", "--runtime-dir", "--json"] },

package/dist/cli.js

@@ -20,6 +20,7 @@ import { handleRecipeQuality } from "./commands/recipe-quality.js";
 import { handleStatus } from "./commands/status.js";
 import { handleCheck } from "./commands/check.js";
 import { handleChecklist } from "./commands/checklist.js";
+import { handleExecutionTemplate } from "./commands/execution-template.js";
 import { handleLast } from "./commands/last.js";
 import { parseArgs, targetPath } from "./commands/parse-args.js";
 const COMMANDS = {
@@ -121,6 +122,7 @@ async function main(argv) {
   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));
+  if (command === "execution-template") return handleExecutionTemplate(argv.slice(1));
   if (command === "last") return handleLast(parseArgs(argv.slice(1), command));
   const handler = COMMANDS[command];
   if (!handler) throw new Error(`Unknown command: ${command}`);

package/dist/command-contract.js

@@ -88,6 +88,32 @@ const PUBLIC_COMMAND_CONTRACTS = {
     ],
     minimumPositionals: 2
   },
+  "execution-template": {
+    usage: "mm-harness execution-template <list|materialize|lint|new> [target] [options]",
+    options: options(HELP, JSON, {
+      "--dir": value(),
+      "--domain-dir": value(),
+      "--project-worker": value(),
+      "--project-name": value(),
+      "--package-templates": value(),
+      "--package-id": value(),
+      "--flow": value(),
+      "--run-mode": value(["autonomous", "interactive", "validation"]),
+      "--platform": value(),
+      "--domain": value(),
+      "--id": value(),
+      "--provenance": value(),
+      "--include-shadowed": bool(),
+      "--no-include-shadowed": bool(),
+      "--title": value(),
+      "--force": bool()
+    }),
+    positionals: [
+      { label: "action", choices: ["list", "materialize", "lint", "new"] }
+    ],
+    minimumPositionals: 1,
+    variadic: { label: "target", validate: (value2) => value2.length > 0 }
+  },
   actions: {
     options: options(HELP, JSON, TARGET, ADAPTER, ADAPTER_OR_MOBILE_PLATFORM, {
       "--action": value(),
@@ -360,6 +386,37 @@ function validatePublicInvocation(argv, examples = {}) {
       );
     }
   }
+  if (name === "execution-template") {
+    const action = positionals[0];
+    const validAction = ["list", "materialize", "lint", "new"].includes(action ?? "");
+    const targetCount = Math.max(0, positionals.length - 1);
+    if (validAction && action === "list" && targetCount > 0) {
+      return usageFailure(
+        "CLI_EXCESS_POSITIONAL",
+        name,
+        `execution-template list does not accept positional '${positionals[1]}'.`,
+        contract,
+        examples
+      );
+    }
+    if (validAction && (action === "materialize" || action === "lint" || action === "new") && targetCount === 0) {
+      return missingPositionalFailure(
+        name,
+        `execution-template ${action} requires <target>.`,
+        contract,
+        examples
+      );
+    }
+    if (validAction && targetCount > 1) {
+      return usageFailure(
+        "CLI_EXCESS_POSITIONAL",
+        name,
+        `unexpected positional '${positionals[2]}'; execution-template ${action} accepts one <target>.`,
+        contract,
+        examples
+      );
+    }
+  }
   if (contract.leadingPositionals && !contract.requiredUnless?.some((option) => seenOptions.has(option)) && tokens.slice(0, contract.leadingPositionals).some((argument) => !argument || argument.startsWith("-"))) {
     const missing = contract.positionals?.[0]?.label ?? "argument";
     return missingPositionalFailure(name, `${name} requires <${missing}> first.`, contract, examples);

package/dist/commands/execution-template.js

@@ -0,0 +1,28 @@
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+const require2 = createRequire(import.meta.url);
+async function handleExecutionTemplate(argv) {
+  let entrypoint;
+  try {
+    entrypoint = require2.resolve(
+      "@farmslot/agent-runtime/scripts/execution-template-cli.mjs"
+    );
+  } catch (error) {
+    console.error(
+      `mm-harness execution-template: installed @farmslot/agent-runtime does not expose the catalog command: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return 1;
+  }
+  const result = spawnSync(process.execPath, [entrypoint, ...argv], {
+    env: process.env,
+    stdio: "inherit"
+  });
+  if (result.error) {
+    console.error(`mm-harness execution-template: ${result.error.message}`);
+    return 1;
+  }
+  return result.status ?? 1;
+}
+export {
+  handleExecutionTemplate
+};

package/dist/commands/run-engine.js

@@ -21,6 +21,7 @@ import {
 import { captureHelperSupportsRecordSessionSnapshots } from "../recording-target.js";
 import { startRecipeRecording, stopRecipeRecording } from "../run-recording.js";
 import { validateMetaMaskActionInputs } from "../metamask-action-validation.js";
+import { gitLibraryProvenance } from "../library-provenance.js";
 import {
   beginRunDiagnostics,
   finishRunDiagnostics
@@ -655,14 +656,22 @@ async function resolveMetaMaskLibrarySources(libraryEntry, recipePath) {
   if (!sources.some((source) => path.resolve(source.root) === canonicalRoot)) {
     sources.push({ name: "metamask", root: canonicalRoot });
   }
-  return sources.map((source) => ({
-    ...source,
-    provenance: source.provenance ?? {
-      kind: source.name === "metamask" ? "bundled" : "library",
-      trust: source.name === "metamask" ? "trusted" : "unknown",
-      name: source.name ?? path.basename(source.root)
-    }
-  }));
+  return Promise.all(
+    sources.map(async (source) => {
+      const isBundled = source.name === "metamask";
+      const detected = isBundled ? {} : await gitLibraryProvenance(source.root);
+      return {
+        ...source,
+        provenance: {
+          kind: isBundled ? "bundled" : "library",
+          trust: isBundled ? "trusted" : "unknown",
+          name: source.name ?? path.basename(source.root),
+          ...detected,
+          ...source.provenance
+        }
+      };
+    })
+  );
 }
 function synthesizeOneNodeRecipe(action, args) {
   return {

package/dist/library-provenance.js

@@ -0,0 +1,33 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+async function gitLibraryProvenance(root) {
+  try {
+    const { stdout: tracked } = await execFileAsync("git", ["-C", root, "ls-files", "--", "."], {
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    if (!tracked.trim()) return {};
+    const [{ stdout: revision }, { stdout: status }] = await Promise.all([
+      execFileAsync("git", ["-C", root, "rev-parse", "HEAD"], {
+        encoding: "utf8",
+        timeout: 5e3
+      }),
+      execFileAsync(
+        "git",
+        ["-C", root, "status", "--porcelain=v1", "--untracked-files=normal", "--", "."],
+        {
+          encoding: "utf8",
+          timeout: 5e3
+        }
+      )
+    ]);
+    const trimmedRevision = revision.trim();
+    return trimmedRevision ? { revision: trimmedRevision, dirty: status.trim().length > 0 } : {};
+  } catch {
+    return {};
+  }
+}
+export {
+  gitLibraryProvenance
+};

package/dist/mm-harness-cli.js

@@ -77,6 +77,40 @@ Example:
   mm-harness checklist mark temp/tasks/recipe-cook/<task> complete --mark-last
   mm-harness checklist closeout temp/tasks/recipe-cook/<task> --share`
   },
+  {
+    name: "execution-template",
+    summary: "Discover, validate, and materialize shared agent checklists.",
+    example: "mm-harness execution-template list --package-templates <path> --json",
+    helpText: `mm-harness execution-template <list|materialize|lint|new> [options]
+
+  Shared Markdown checklist catalog used by direct and orchestrated workflows.
+  Sources use the flow-tree shape <root>/<flow>/<variant>.md.
+
+  list        List compatible templates and portable source provenance.
+  materialize Select one template, copy its immutable snapshot, and optionally
+              write a provenance record.
+  lint        Validate one template file or flow-tree directory.
+  new         Create a minimal starter template.
+
+Common source/filter options:
+  --dir <path>                       Custom flow-tree source (repeatable)
+  --domain-dir <domain=path>         Domain-scoped team source (repeatable)
+  --package-templates <path>         Canonical package flow-tree root
+  --package-id <id>                  Source label for the package root
+  --project-worker <path>            Project template directory
+  --project-name <name>              Source label for project templates
+  --flow <flow>                      Exact flow
+  --platform <platform>              Exact platform
+  --run-mode <mode>                  autonomous|interactive|validation
+  --domain <domain>                  Exact domain
+  --id <id>                          Exact template id
+  --json                             Machine-readable output
+
+Materialize:
+  mm-harness execution-template materialize <output> --flow fix-bug \\
+    --platform mobile --run-mode autonomous --id fix-bug/autonomous.mobile \\
+    --package-templates <path> --provenance <path> --json`
+  },
   {
     name: "actions",
     summary: "Discover typed single operations and their fields.",
@@ -552,7 +586,7 @@ const HELP_GROUPS = [
   {
     title: "DISCOVER",
     blurb: "discover atomic actions and reusable recipes (--json is the agent-primary form)",
-    commands: ["actions", "call"]
+    commands: ["actions", "call", "execution-template"]
   },
   {
     title: "PROVE",

package/dist/recipe-security.js

@@ -18,6 +18,7 @@ const APP_MUTATION_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.perps.close_positions",
   "metamask.perps.close_orders",
   "metamask.perps.place_order",
+  "metamask.perps.update_position_tpsl",
   "metamask.perps.ensure_positions",
   "metamask.perps.ensure_orders",
   "metamask.perps.start_state",
@@ -27,6 +28,7 @@ const EXTERNAL_MUTATION_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.perps.close_positions",
   "metamask.perps.close_orders",
   "metamask.perps.place_order",
+  "metamask.perps.update_position_tpsl",
   "metamask.perps.ensure_positions",
   "metamask.perps.ensure_orders",
   "metamask.perps.start_state",

package/library/actions/core/perps/_controller.mjs

@@ -625,6 +625,13 @@ export function redactOrder(order) {
     size: order.size ?? order.sz ?? order.szi ?? null,
     price: order.price ?? order.limitPx ?? order.px ?? null,
     type: order.orderType ?? order.type ?? null,
+    // Trigger data, so evidence shows what a stop / take-profit placement
+    // actually round-tripped from the exchange.
+    triggerOrderType: order.triggerOrderType ?? null,
+    triggerPrice: order.triggerPrice ?? order.triggerPx ?? null,
+    detailedOrderType: order.detailedOrderType ?? null,
+    isTrigger: order.isTrigger ?? null,
+    reduceOnly: order.reduceOnly ?? null,
   };
 }
 

package/library/actions/core/perps/assert_orders.mjs

@@ -11,6 +11,13 @@ import {
 // over the controller's standalone getOpenOrders path (no signer / provider init
 // needed) — throws on mismatch so the recipe fails loudly. Mirrors
 // assert_positions.mjs.
+//
+// Optional expect_* fields additionally assert the TRIGGER DATA the exchange
+// round-tripped for every matching order: expect_trigger_order_type (the
+// normalized placement type, e.g. stop_market), expect_trigger_price,
+// expect_execution (market | limit once triggered), expect_reduce_only, and
+// expect_size (proves a partial TP/SL quantity). They use the controller's own
+// field names (triggerOrderType, triggerPrice, orderType, reduceOnly, size).
 
 export function expectedOpen(input) {
   if (input.node?.state == null) throw new Error('metamask.perps.assert_orders requires state=open or state=none.');
@@ -20,6 +27,79 @@ export function expectedOpen(input) {
   throw new Error(`metamask.perps.assert_orders received unsupported state: ${state}`);
 }
 
+/**
+ * Collect the optional trigger-data expectations from the node.
+ *
+ * @param input - Adapter input.
+ * @returns The expectations the node set, keyed by controller field name.
+ */
+/**
+ * Whether the node narrowed matching to trigger orders only.
+ *
+ * @param input - Adapter input.
+ * @returns True when only trigger orders should be considered.
+ */
+export function onlyTriggerOrders(input) {
+  const value = input.node?.only_trigger_orders ?? input.node?.onlyTriggerOrders;
+  return value === true || String(value).toLowerCase() === 'true';
+}
+
+export function expectedTriggerData(input) {
+  const node = input.node ?? {};
+  const expectations = {
+    triggerOrderType:
+      node.expect_trigger_order_type ?? node.expectTriggerOrderType,
+    triggerPrice: node.expect_trigger_price ?? node.expectTriggerPrice,
+    orderType: node.expect_execution ?? node.expectExecution,
+    reduceOnly: node.expect_reduce_only ?? node.expectReduceOnly,
+    size: node.expect_size ?? node.expectSize,
+  };
+  return Object.fromEntries(
+    Object.entries(expectations).filter(
+      ([, value]) => value !== undefined && value !== null,
+    ),
+  );
+}
+
+/**
+ * Assert every matching order carries the expected trigger data.
+ *
+ * @param orders - Matching open orders.
+ * @param expectations - Expectations from `expectedTriggerData`.
+ */
+export function assertTriggerData(orders, expectations) {
+  const fields = Object.keys(expectations);
+  if (fields.length === 0) return;
+
+  for (const order of orders) {
+    for (const field of fields) {
+      const expected = expectations[field];
+      const actual = order[field];
+      const expectedNumber = Number(expected);
+      const actualNumber = Number(actual);
+      const numeric =
+        typeof expected !== 'boolean' &&
+        expected !== '' &&
+        actual !== null &&
+        actual !== undefined &&
+        Number.isFinite(expectedNumber) &&
+        Number.isFinite(actualNumber);
+      const matches =
+        typeof expected === 'boolean'
+          ? Boolean(actual) === expected
+          : // Prices and sizes round-trip with exchange formatting
+            // ('44000' -> '44000.0'), so compare them numerically.
+            (numeric && expectedNumber === actualNumber) ||
+            String(actual) === String(expected);
+      if (!matches) {
+        throw new Error(
+          `Open Perps order ${order.orderId ?? '?'} (${order.symbol ?? '?'}) has ${field}=${JSON.stringify(actual)}, expected ${JSON.stringify(expected)}.`,
+        );
+      }
+    }
+  }
+}
+
 export async function assertOrders(input, expectOpen = expectedOpen(input)) {
   requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreController(input);
@@ -33,6 +113,11 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
       userAddress: accountAddress,
     });
     matching = selectedItems(input, orders);
+    if (onlyTriggerOrders(input)) {
+      // Narrow to the trigger orders on the market so expectations are not
+      // applied to an unrelated parent order resting alongside them.
+      matching = matching.filter((order) => order.isTrigger === true);
+    }
     if (expectOpen ? matching.length > 0 : matching.length === 0) break;
     if (Date.now() >= deadline) break;
     await new Promise((resolve) =>
@@ -44,6 +129,11 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
   if (expectOpen && !hasOrder) {
     throw new Error('Expected at least one matching open Perps order, but found none.');
   }
+
+  const triggerExpectations = expectedTriggerData(input);
+  if (expectOpen) {
+    assertTriggerData(matching, triggerExpectations);
+  }
   if (!expectOpen && hasOrder) {
     throw new Error(`Expected no matching open Perps orders, but found ${matching.length}.`);
   }
@@ -54,6 +144,8 @@ export async function assertOrders(input, expectOpen = expectedOpen(input)) {
     network,
     account: accountAddress,
     expectedOpen: expectOpen,
+    expectedTrigger:
+      Object.keys(triggerExpectations).length === 0 ? null : triggerExpectations,
     matchingCount: matching.length,
     orders: matching.map(redactOrder),
     proofPath: 'perps-controller-getOpenOrders',