@deeeed/metamask-harness 0.19.0 → 0.19.1

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 0.19.1 - 2026-07-23
+
+### Added
+
+- Mobile `ui.press` supports `long_press=true` for real long-press gestures such as resetting a keypad value.
+
+### Fixed
+
+- Perps position and order assertions honor `timeout_ms` consistently on Mobile, Extension, and Core.
+- Core Perps reads and assertions honor their explicit network instead of silently defaulting isolated actions to testnet.
+- Mobile and Extension `ensure_orders state=open` create a resting testnet limit order when missing and recognize live buy/sell sides consistently.
+- Reject invalid live-adapter process timeouts and use the safe default.
+
 ## 0.19.0 - 2026-07-22
 
 ### Added

package/adapters/mobile/bridge-runtime/cdp-bridge.cjs

@@ -254,6 +254,38 @@ const COMMANDS = {
     return { ...result, testId, deviceName };
   },
 
+  async 'long-press-test-id'(client, args, { deviceName } = {}) {
+    const testId = args[0];
+    if (!testId) {
+      throw new Error('Usage: long-press-test-id <testId>');
+    }
+    const expr = `(function() {
+      var hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (!hook) return { ok: false, error: 'No React DevTools hook' };
+      var renderers = hook.renderers;
+      if (!renderers) return { ok: false, error: 'No renderers' };
+      var getFiberRoots = hook.getFiberRoots;
+      function walk(fiber) {
+        if (!fiber) return false;
+        var props = fiber.memoizedProps;
+        if (props && props.testID === ${JSON.stringify(testId)}) {
+          if (typeof props.onLongPress === 'function') { props.onLongPress(); return true; }
+        }
+        return walk(fiber.child) || walk(fiber.sibling);
+      }
+      for (var [id] of renderers) {
+        var roots = getFiberRoots ? getFiberRoots(id) : undefined;
+        if (!roots) continue;
+        var found = false;
+        roots.forEach(function(r) { if (!found) found = walk(r.current); });
+        if (found) return { ok: true, testId: ${JSON.stringify(testId)} };
+      }
+      return { ok: false, error: 'No component with testID=' + ${JSON.stringify(testId)} + ' found or no onLongPress' };
+    })()`;
+    const result = await cdpEval(client, expr);
+    return { ...result, testId, deviceName };
+  },
+
   async 'press-text'(client, args, { deviceName } = {}) {
     const text = args[0];
     if (!text) {
@@ -693,6 +725,7 @@ Commands:
   get-selected-account                 Get the currently selected account
   switch-account <address>             Switch to account by address
   press-test-id <testId>               Press a component by its testID prop
+  long-press-test-id <testId>          Invoke a component's long-press gesture by testID
   press-text <text>                     Press a component containing visible text
   scroll-view [--test-id <id>] [--offset <n>] [--animated]
                                        Scroll a ScrollView/FlatList

package/dist/adapters.js

@@ -320,8 +320,13 @@ async function handleMobilePress(payload, context) {
   }
   const target = text ?? identifiers[0];
   if (target.trim() === "") throw new Error("ui.press target must be non-empty.");
+  const longPress = payload.long_press === true;
+  if (longPress && text !== void 0) {
+    throw new Error("ui.press long_press=true requires test_id, testID, or selector targeting.");
+  }
   const input = mobileUiInput(context, "press", payload);
-  return text !== void 0 ? bridgeCommand(input, ["press-text", target]) : bridgeCommand(input, ["press-test-id", target]);
+  if (text !== void 0) return bridgeCommand(input, ["press-text", target]);
+  return bridgeCommand(input, [longPress ? "long-press-test-id" : "press-test-id", target]);
 }
 async function handleMobileSetInput(payload, context) {
   const input = mobileUiInput(context, "set_input", payload);

package/dist/live-adapter-contract.js

@@ -312,6 +312,7 @@ async function runLiveAdapterScript({ platform, action, node, context, prepared
 `);
   const command = prepared ? commandForPrepared(context.projectRoot, platform) : commandFor(script, context.projectRoot, platform);
   const platformEnv = await platformAdapterEnv(platform, context.projectRoot, tempDir);
+  const processTimeoutMs = liveAdapterProcessTimeoutMs(node);
   const result = await runProcess(command.command, [...command.args, inputPath], {
     cwd: context.projectRoot,
     env: {
@@ -321,12 +322,12 @@ async function runLiveAdapterScript({ platform, action, node, context, prepared
       METAMASK_RECIPE_ADAPTER_INPUT: inputPath,
       METAMASK_RECIPE_ADAPTER_OUTPUT: outputPath
     },
-    timeoutMs: Number(node.live_adapter_timeout_ms ?? node.timeout_ms ?? 6e4),
+    timeoutMs: processTimeoutMs,
     ...prepared ? { stdin: prepared.sourceText } : {}
   });
   try {
     if (result.timedOut) {
-      throw new Error(`Live adapter ${script} timed out after ${Number(node.live_adapter_timeout_ms ?? node.timeout_ms ?? 6e4)}ms.`);
+      throw new Error(`Live adapter ${script} timed out after ${processTimeoutMs}ms.`);
     }
     if (result.exitCode !== 0) {
       throw new Error(`Live adapter ${script} exited ${result.exitCode}: ${result.stderr || result.stdout}`);
@@ -344,6 +345,17 @@ async function runLiveAdapterScript({ platform, action, node, context, prepared
     await rm(tempDir, { recursive: true, force: true });
   }
 }
+function liveAdapterProcessTimeoutMs(node) {
+  if (node.live_adapter_timeout_ms != null) {
+    const timeoutMs = Number(node.live_adapter_timeout_ms);
+    return Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 6e4;
+  }
+  if (node.timeout_ms != null) {
+    const timeoutMs = Number(node.timeout_ms);
+    return Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs + 5e3 : 6e4;
+  }
+  return 6e4;
+}
 function commandForPrepared(projectRoot, platform) {
   if (platform !== "core") {
     return { command: process.execPath, args: ["--input-type=module", "-"] };
@@ -364,6 +376,7 @@ function isPathWithin(root, candidate) {
   return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
 }
 export {
+  liveAdapterProcessTimeoutMs,
   prepareLiveAdapterScript,
   resolveLiveAdapter,
   runLiveAdapterScript

package/docs/RECIPES.md

@@ -67,6 +67,21 @@ Rules:
 - Parameterize repeated behavior instead of multiplying names.
 - Keep secrets out of recipes, libraries, and evidence.
 
+Keep responsibilities narrow:
+
+- **Parameters** expose caller choices that may vary without changing the
+  journey's meaning.
+- **Recipes** compose actions and own journey order, safe defaults, invariants,
+  and proof.
+- **Actions** translate one stable operation to existing UI, CDP, or controller
+  capabilities; they do not reimplement product business logic.
+- **Product/controllers** remain the source of truth for state transitions,
+  validation, transactions, and domain behavior.
+
+If changing a value would violate the recipe's postcondition, keep it as a
+documented recipe invariant rather than a parameter. Add a shared action only
+when repeated direct access has a stable cross-task contract.
+
 The protocol is authoritative:
 <https://farmslot.io/docs/reference/recipe-protocol-v1>.
 

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

@@ -23,11 +23,22 @@ export function expectedOpen(input) {
 export async function assertOrders(input, expectOpen = expectedOpen(input)) {
   requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreController(input);
-  const orders = await controller.getOpenOrders({
-    standalone: true,
-    userAddress: accountAddress,
-  });
-  const matching = selectedItems(input, orders);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 0);
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let orders;
+  let matching;
+  while (true) {
+    orders = await controller.getOpenOrders({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+    matching = selectedItems(input, orders);
+    if (expectOpen ? matching.length > 0 : matching.length === 0) break;
+    if (Date.now() >= deadline) break;
+    await new Promise((resolve) =>
+      setTimeout(resolve, Math.min(500, Math.max(1, deadline - Date.now()))),
+    );
+  }
   const hasOrder = matching.length > 0;
 
   if (expectOpen && !hasOrder) {

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

@@ -22,11 +22,22 @@ export function expectedOpen(input) {
 export async function assertPositions(input, expectOpen = expectedOpen(input)) {
   requireExplicitSelection(input);
   const { controller, accountAddress, network } = await getCoreController(input);
-  const positions = await controller.getPositions({
-    standalone: true,
-    userAddress: accountAddress,
-  });
-  const matching = selectedItems(input, positions);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 0);
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let positions;
+  let matching;
+  while (true) {
+    positions = await controller.getPositions({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+    matching = selectedItems(input, positions);
+    if (expectOpen ? matching.length > 0 : matching.length === 0) break;
+    if (Date.now() >= deadline) break;
+    await new Promise((resolve) =>
+      setTimeout(resolve, Math.min(500, Math.max(1, deadline - Date.now()))),
+    );
+  }
   const hasPosition = matching.length > 0;
 
   if (expectOpen && !hasPosition) {

package/library/actions/extension/perps/perps.mjs

@@ -10,7 +10,10 @@ function symbolForItem(item) {
 }
 
 function sideForItem(item) {
-  return String(item?.side ?? item?.direction ?? '').toLowerCase();
+  const side = String(item?.side ?? item?.direction ?? '').toLowerCase();
+  if (side === 'buy' || side === 'b') return 'long';
+  if (side === 'sell' || side === 'a' || side === 's') return 'short';
+  return side;
 }
 
 function uniqueSymbols(symbols) {
@@ -57,6 +60,35 @@ function requirePlaceOrderInputs(input) {
   if (node.amount == null && node.notional == null) throw new Error(`${input.action} requires amount=<usd> or notional=<usd>.`);
 }
 
+function resolveOrderType(input) {
+  const value = String(input.node?.order_type ?? input.node?.orderType ?? 'market').toLowerCase();
+  if (value !== 'market' && value !== 'limit') {
+    throw new Error(`${input.action} received unsupported order_type: ${value}.`);
+  }
+  return value;
+}
+
+function resolveLimitPrice(input, isBuy, currentPrice) {
+  const explicit = input.node?.limit_price ?? input.node?.limitPrice ?? input.node?.price;
+  if (explicit != null && String(explicit).length > 0) {
+    const value = Number(explicit);
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`${input.action} received invalid limit_price: ${explicit}.`);
+    }
+    return value;
+  }
+  const rawOffset = input.node?.offset_pct ?? input.node?.offsetPct;
+  const offset = rawOffset == null ? (isBuy ? -30 : 30) : Number(rawOffset);
+  if (!Number.isFinite(offset)) {
+    throw new Error(`${input.action} received invalid offset_pct: ${rawOffset}.`);
+  }
+  const value = currentPrice * (1 + offset / 100);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${input.action} computed a non-positive limit price (${value}).`);
+  }
+  return value;
+}
+
 export function positionSelectionState(input, positions) {
   return { hasMatching: selectedItems(input, positions).length > 0 };
 }
@@ -97,9 +129,9 @@ export async function readPositions(input) {
 
 export async function readOrders(input) {
   return withExtensionPage(input, async (page) => {
-    const orders = await readOpenOrders(page);
-    const matching = selectedItems(input, orders);
-    return { action: input.action, source: 'perps-stream-manager-cache', count: orders.length, matchingCount: matching.length, orders: matching.map(redactOrder) };
+    const state = await readOpenOrdersState(page);
+    const matching = selectedItems(input, state.orders);
+    return { action: input.action, source: state.source, count: state.orders.length, matchingCount: matching.length, orders: matching.map(redactOrder) };
   });
 }
 
@@ -107,11 +139,7 @@ export async function assertPositions(input, expectedOpen) {
   requireExplicitSelection(input);
   return withExtensionPage(input, async (page) => {
     const timeoutMs = Number(input.node?.timeout_ms ?? 0);
-    const requested = configuredSymbols(input, []);
-    if (expectedOpen && timeoutMs > 0 && requested.length === 1) {
-      await waitForPositionPresent(page, requested[0], timeoutMs);
-    }
-    const state = await page.readPositions();
+    const state = await waitForSelectedPositionState(page, input, expectedOpen, timeoutMs);
     if (!state.available) throw new Error('stateHooks.submitRequestToBackground is unavailable; cannot assert live Perps positions.');
     const matching = selectedItems(input, state.positions);
     const hasPosition = matching.length > 0;
@@ -124,12 +152,13 @@ export async function assertPositions(input, expectedOpen) {
 export async function assertOrders(input, expectedOpen) {
   requireExplicitSelection(input);
   return withExtensionPage(input, async (page) => {
-    const orders = await readOpenOrders(page);
-    const matching = selectedItems(input, orders);
+    const timeoutMs = Number(input.node?.timeout_ms ?? 0);
+    const state = await waitForSelectedOrderState(page, input, expectedOpen, timeoutMs);
+    const matching = selectedItems(input, state.orders);
     const hasOrders = matching.length > 0;
     if (expectedOpen && !hasOrders) throw new Error('Expected at least one matching open Perps order, but found none.');
     if (!expectedOpen && hasOrders) throw new Error(`Expected no matching open Perps orders, but found ${matching.length}.`);
-    return { action: input.action, expectedOpen, matchingCount: matching.length, orders: matching.map(redactOrder), source: 'perps-stream-manager-cache' };
+    return { action: input.action, expectedOpen, matchingCount: matching.length, orders: matching.map(redactOrder), source: state.source };
   });
 }
 
@@ -306,6 +335,10 @@ async function readCurrentMarketPrice(page, symbol, explicitPrice) {
 }
 
 async function readOpenOrders(page) {
+  return (await readOpenOrdersState(page)).orders;
+}
+
+async function readOpenOrdersState(page) {
   const state = await page.evaluate(`(async () => {
     const request = globalThis.stateHooks?.submitRequestToBackground;
     const manager = globalThis.stateHooks?.getPerpsStreamManager?.();
@@ -326,7 +359,7 @@ async function readOpenOrders(page) {
     };
   })()`);
   if (!state.available) throw new Error('Perps orders are unavailable from both background and stream manager cache.');
-  return state.orders;
+  return state;
 }
 
 async function readAccountState(page) {
@@ -393,12 +426,41 @@ async function waitForPositionPresent(page, symbol, timeoutMs) {
   return lastState;
 }
 
+async function waitForSelectedPositionState(page, input, expectedOpen, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let state;
+  while (true) {
+    state = await page.readPositions();
+    if (!state.available) {
+      throw new Error('stateHooks.submitRequestToBackground is unavailable; cannot assert live Perps positions.');
+    }
+    const matching = selectedItems(input, state.positions);
+    if (expectedOpen ? matching.length > 0 : matching.length === 0) return state;
+    if (Date.now() >= deadline) return state;
+    await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
+  }
+}
+
+async function waitForSelectedOrderState(page, input, expectedOpen, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let state;
+  while (true) {
+    state = await readOpenOrdersState(page);
+    const matching = selectedItems(input, state.orders);
+    if (expectedOpen ? matching.length > 0 : matching.length === 0) return state;
+    if (Date.now() >= deadline) return state;
+    await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
+  }
+}
+
 export async function placeOrder(input) {
   requirePlaceOrderInputs(input);
   const symbol = marketSymbol(input);
   const side = String(input.node.side).toLowerCase();
   const amount = String(input.node.amount ?? input.node.notional);
   const leverage = Number(input.node?.leverage ?? 3);
+  const isBuy = side !== 'short';
+  const orderType = resolveOrderType(input);
   return withExtensionPage(input, async (page) => {
     await page.navigateHash(`#/perps/market/${encodeURIComponent(symbol)}`);
     await page.evaluate(`(async () => {
@@ -415,6 +477,9 @@ export async function placeOrder(input) {
       symbol,
       input.node?.current_price ?? input.node?.currentPrice,
     );
+    const limitPrice = orderType === 'limit'
+      ? resolveLimitPrice(input, isBuy, resolvedPrice)
+      : null;
     await page.navigateHash(`#/perps/trade/${encodeURIComponent(symbol)}?direction=${encodeURIComponent(side)}&mode=new`);
     await page.waitForSelector(dataTestId('perps-order-entry-page'), { timeoutMs: 20000 });
     let order;
@@ -426,13 +491,27 @@ export async function placeOrder(input) {
       if (!Number.isFinite(currentPrice) || currentPrice <= 0) throw new Error('Unable to determine current Perps price for order placement.');
       const usdAmount = ${JSON.stringify(amount)};
       const leverage = ${JSON.stringify(leverage)};
-      const orderParams = {
+      const orderType = ${JSON.stringify(orderType)};
+      const limitPrice = ${JSON.stringify(limitPrice)};
+      const orderParams = orderType === 'limit' ? {
         symbol: ${JSON.stringify(symbol)},
-        isBuy: ${JSON.stringify(side !== 'short')},
+        isBuy: ${JSON.stringify(isBuy)},
+        size: ((Number(usdAmount) * Number(leverage)) / Number(limitPrice)).toString(),
+        orderType,
+        price: String(limitPrice),
+        timeInForce: 'GTC',
+        leverage,
+        currentPrice,
+        priceAtCalculation: currentPrice,
+        maxSlippageBps: ${JSON.stringify(Number(input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300))},
+      } : {
+        symbol: ${JSON.stringify(symbol)},
+        isBuy: ${JSON.stringify(isBuy)},
         size: ((Number(usdAmount) * Number(leverage)) / currentPrice).toString(),
-        orderType: 'market',
+        orderType,
         leverage,
         currentPrice,
+        priceAtCalculation: currentPrice,
         usdAmount,
         maxSlippageBps: ${JSON.stringify(Number(input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300))},
       };
@@ -446,8 +525,12 @@ export async function placeOrder(input) {
       const message = error instanceof Error ? error.message : String(error);
       throw new Error(`${message} (resolvedPrice=${resolvedPrice})`);
     }
-    await waitForPositionPresent(page, symbol, Number(input.node?.timeout_ms ?? 30000));
-    return { action: input.action, market: symbol, side, amount, leverage, submitted: true, order, proofPath: 'background-perpsPlaceOrder' };
+    if (orderType === 'limit') {
+      await waitForSelectedOrderState(page, input, true, Number(input.node?.timeout_ms ?? 30000));
+    } else {
+      await waitForPositionPresent(page, symbol, Number(input.node?.timeout_ms ?? 30000));
+    }
+    return { action: input.action, market: symbol, side, orderType, amount, leverage, limitPrice, submitted: true, order, proofPath: 'background-perpsPlaceOrder' };
   });
 }
 
@@ -479,7 +562,16 @@ export async function ensureOrders(input) {
     const close = await closeOrders(input);
     return { ...(await assertOrders(input, false)), close };
   }
-  if (state === 'open' || state === 'present') return assertOrders(input, true);
+  if (state === 'open' || state === 'present') {
+    const current = await withExtensionPage(input, async (page) => ({
+      orders: await readOpenOrders(page),
+    }));
+    let order = null;
+    if (selectedItems(input, current.orders).length === 0) {
+      order = await placeOrder({ ...input, node: { ...input.node, order_type: 'limit' } });
+    }
+    return { ...(await assertOrders(input, true)), order };
+  }
   throw new Error(`metamask.perps.ensure_orders received unsupported state: ${state}`);
 }
 

package/library/actions/mobile/perps/perps.mjs

@@ -24,7 +24,10 @@ function symbolForItem(item) {
 }
 
 function sideForItem(item) {
-  return String(item?.side ?? item?.direction ?? '').toLowerCase();
+  const side = String(item?.side ?? item?.direction ?? '').toLowerCase();
+  if (side === 'buy' || side === 'b') return 'long';
+  if (side === 'sell' || side === 'a' || side === 's') return 'short';
+  return side;
 }
 
 function configuredSymbols(input, items) {
@@ -67,6 +70,35 @@ function requirePlaceOrderInputs(input) {
   if (node.amount == null && node.notional == null) throw new Error(`${input.action} requires amount=<usd> or notional=<usd>.`);
 }
 
+function resolveOrderType(input) {
+  const value = String(input.node?.order_type ?? input.node?.orderType ?? 'market').toLowerCase();
+  if (value !== 'market' && value !== 'limit') {
+    throw new Error(`${input.action} received unsupported order_type: ${value}.`);
+  }
+  return value;
+}
+
+function resolveLimitPrice(input, isBuy, currentPrice) {
+  const explicit = input.node?.limit_price ?? input.node?.limitPrice ?? input.node?.price;
+  if (explicit != null && String(explicit).length > 0) {
+    const value = Number(explicit);
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`${input.action} received invalid limit_price: ${explicit}.`);
+    }
+    return value;
+  }
+  const rawOffset = input.node?.offset_pct ?? input.node?.offsetPct;
+  const offset = rawOffset == null ? (isBuy ? -30 : 30) : Number(rawOffset);
+  if (!Number.isFinite(offset)) {
+    throw new Error(`${input.action} received invalid offset_pct: ${rawOffset}.`);
+  }
+  const value = currentPrice * (1 + offset / 100);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${input.action} computed a non-positive limit price (${value}).`);
+  }
+  return value;
+}
+
 function uniqueSymbols(symbols) {
   return Array.from(new Set(symbols.filter(Boolean)));
 }
@@ -143,6 +175,20 @@ async function waitForPositionPresent(input, symbol, timeoutMs = 30000) {
   return last;
 }
 
+async function waitForSelectedState(input, readItems, expectedOpen, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let items;
+  while (true) {
+    items = await readItems(input);
+    const matching = selectedItems(input, items);
+    if (expectedOpen ? matching.length > 0 : matching.length === 0) {
+      return matching;
+    }
+    if (Date.now() >= deadline) return matching;
+    await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
+  }
+}
+
 function redactPosition(position) {
   return {
     symbol: position.symbol ?? position.coin ?? null,
@@ -270,8 +316,13 @@ export async function readOrders(input) {
 
 export async function assertPositions(input, expectedOpen) {
   requireExplicitSelection(input);
-  const positions = await readPositions(input);
-  const matching = selectedItems(input, positions);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 0);
+  const matching = await waitForSelectedState(
+    input,
+    readPositions,
+    expectedOpen,
+    timeoutMs,
+  );
   const hasPosition = matching.length > 0;
   if (expectedOpen && !hasPosition) throw new Error('Expected at least one matching open Perps position, but found none.');
   if (!expectedOpen && hasPosition) throw new Error(`Expected no matching open Perps positions, but found ${matching.length}.`);
@@ -280,8 +331,13 @@ export async function assertPositions(input, expectedOpen) {
 
 export async function assertOrders(input, expectedOpen) {
   requireExplicitSelection(input);
-  const orders = await readOpenOrders(input);
-  const matching = selectedItems(input, orders);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 0);
+  const matching = await waitForSelectedState(
+    input,
+    readOpenOrders,
+    expectedOpen,
+    timeoutMs,
+  );
   const hasOrders = matching.length > 0;
   if (expectedOpen && !hasOrders) throw new Error('Expected at least one matching open Perps order, but found none.');
   if (!expectedOpen && hasOrders) throw new Error(`Expected no matching open Perps orders, but found ${matching.length}.`);
@@ -407,12 +463,43 @@ export async function placeOrder(input) {
   const symbol = marketSymbol(input);
   const side = String(input.node.side).toLowerCase();
   const amount = String(input.node.amount ?? input.node.notional);
-  const size = String(input.node?.size ?? '0.0001');
   const leverage = Number(input.node?.leverage ?? 3);
   const maxSlippageBps = Number(input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300);
   const isBuy = orderSideIsBuy(side);
+  const orderType = resolveOrderType(input);
   const currentPrice = await currentPriceForOrder(input, symbol);
-  const result = await evalAsync(input, `Engine.context.PerpsController.placeOrder({ symbol: ${JSON.stringify(symbol)}, isBuy: ${JSON.stringify(isBuy)}, orderType: 'market', size: ${JSON.stringify(size)}, usdAmount: ${JSON.stringify(amount)}, leverage: ${JSON.stringify(leverage)}, currentPrice: ${JSON.stringify(currentPrice)}, maxSlippageBps: ${JSON.stringify(maxSlippageBps)} }).then(function(r){return JSON.stringify(r)})`);
+  const limitPrice = orderType === 'limit'
+    ? resolveLimitPrice(input, isBuy, currentPrice)
+    : null;
+  const size = String(
+    input.node?.size
+      ?? ((Number(amount) * leverage) / (limitPrice ?? currentPrice)),
+  );
+  const orderParams = orderType === 'limit'
+    ? {
+      symbol,
+      isBuy,
+      orderType,
+      size,
+      price: String(limitPrice),
+      timeInForce: 'GTC',
+      leverage,
+      currentPrice,
+      priceAtCalculation: currentPrice,
+      maxSlippageBps,
+    }
+    : {
+      symbol,
+      isBuy,
+      orderType,
+      size,
+      usdAmount: amount,
+      leverage,
+      currentPrice,
+      priceAtCalculation: currentPrice,
+      maxSlippageBps,
+    };
+  const result = await evalAsync(input, `Engine.context.PerpsController.placeOrder(${JSON.stringify(orderParams)}).then(function(r){return JSON.stringify(r)})`);
   if (result?.success === false || result == null) {
     throw new Error(`Failed to place ${symbol} ${side}: ${result?.error || JSON.stringify(result)}`);
   }
@@ -420,8 +507,12 @@ export async function placeOrder(input) {
     input,
     'globalThis.__AGENTIC__ && globalThis.__AGENTIC__.refreshPerpsStreams ? globalThis.__AGENTIC__.refreshPerpsStreams().then(function(r){return JSON.stringify(r)}) : Promise.resolve(JSON.stringify({ ok: false, reason: "refreshPerpsStreams unavailable" }))',
   );
-  await waitForPositionPresent(input, symbol, Number(input.node?.timeout_ms ?? 30000));
-  return { action: input.action, market: symbol, side, amount, size, leverage, submitted: true, result, refresh, proofPath: 'mobile-perps-controller-place-order' };
+  if (orderType === 'limit') {
+    await waitForSelectedState(input, readOpenOrders, true, Number(input.node?.timeout_ms ?? 30000));
+  } else {
+    await waitForPositionPresent(input, symbol, Number(input.node?.timeout_ms ?? 30000));
+  }
+  return { action: input.action, market: symbol, side, orderType, amount, size, leverage, limitPrice, submitted: true, result, refresh, proofPath: 'mobile-perps-controller-place-order' };
 }
 
 export async function ensurePositions(input) {
@@ -448,7 +539,14 @@ export async function ensureOrders(input) {
     const close = await closeOrders(input);
     return { ...(await assertOrders(input, false)), close };
   }
-  if (state === 'open' || state === 'present') return assertOrders(input, true);
+  if (state === 'open' || state === 'present') {
+    const current = await readOpenOrders(input);
+    let order = null;
+    if (selectedItems(input, current).length === 0) {
+      order = await placeOrder({ ...input, node: { ...input.node, order_type: 'limit' } });
+    }
+    return { ...(await assertOrders(input, true)), order };
+  }
   throw new Error(`metamask.perps.ensure_orders received unsupported state: ${state}`);
 }
 

package/library/manifests/core.action-manifest.json

@@ -590,6 +590,15 @@
             "type": "string",
             "description": "EVM address to read positions for; defaults to the canonical wallet fixture account."
           },
+          "network": {
+            "type": "string",
+            "enum": [
+              "testnet",
+              "mainnet"
+            ],
+            "default": "testnet",
+            "description": "Controller network for this isolated Core read."
+          },
           "timeout_ms": {
             "type": "number"
           }
@@ -607,7 +616,7 @@
         }
       ],
       "proof_effect": "E2E validation must record this action in trace.json; live-proof actions include liveAdapter/proofPath or controller output.",
-      "safety_notes": "Read-only HyperLiquid testnet HTTP query; must not inject controller/UI state to fabricate proof.",
+      "safety_notes": "Read-only HyperLiquid query on the explicitly selected network; must not inject controller/UI state to fabricate proof.",
       "execution_capabilities": []
     },
     {
@@ -697,6 +706,15 @@
             "type": "string",
             "description": "EVM address to read orders for; defaults to the canonical wallet fixture account."
           },
+          "network": {
+            "type": "string",
+            "enum": [
+              "testnet",
+              "mainnet"
+            ],
+            "default": "testnet",
+            "description": "Controller network for this isolated Core read."
+          },
           "timeout_ms": {
             "type": "number"
           }
@@ -714,7 +732,7 @@
         }
       ],
       "proof_effect": "E2E validation must record this action in trace.json; live-proof actions include liveAdapter/proofPath or controller output.",
-      "safety_notes": "Read-only HyperLiquid testnet HTTP query; must not inject controller/UI state to fabricate proof.",
+      "safety_notes": "Read-only HyperLiquid query on the explicitly selected network; must not inject controller/UI state to fabricate proof.",
       "execution_capabilities": []
     },
     {
@@ -1101,6 +1119,15 @@
             "type": "string",
             "description": "EVM address to read for; defaults to the canonical wallet fixture account."
           },
+          "network": {
+            "type": "string",
+            "enum": [
+              "testnet",
+              "mainnet"
+            ],
+            "default": "testnet",
+            "description": "Controller network for this isolated Core assertion."
+          },
           "timeout_ms": {
             "type": "number"
           }
@@ -1122,7 +1149,7 @@
         }
       ],
       "proof_effect": "E2E validation must record this action in trace.json; live-proof actions include liveAdapter/proofPath or controller output.",
-      "safety_notes": "Read-only HyperLiquid testnet HTTP query; must not inject controller state to fabricate proof.",
+      "safety_notes": "Read-only HyperLiquid query on the explicitly selected network; must not inject controller state to fabricate proof.",
       "execution_capabilities": []
     },
     {
@@ -1458,6 +1485,15 @@
             ],
             "description": "Optional position/order side filter."
           },
+          "network": {
+            "type": "string",
+            "enum": [
+              "testnet",
+              "mainnet"
+            ],
+            "default": "testnet",
+            "description": "Controller network for this isolated Core assertion."
+          },
           "timeout_ms": {
             "type": "number"
           },
@@ -1490,7 +1526,7 @@
         }
       ],
       "proof_effect": "E2E validation must record this action in trace.json; live-proof actions include liveAdapter/proofPath or target runtime output.",
-      "safety_notes": "Must not inject mid-recipe UI/app state to fabricate proof.",
+      "safety_notes": "Read-only HyperLiquid query on the explicitly selected network; must not inject mid-recipe state to fabricate proof.",
       "execution_capabilities": []
     },
     {

package/library/manifests/extension.action-manifest.json

@@ -782,7 +782,11 @@
             "type": "string"
           },
           "value": {
-            "type": "string"
+            "type": [
+              "string",
+              "number"
+            ],
+            "description": "Text or a typed numeric recipe parameter; numbers are entered as their decimal text."
           },
           "text": {
             "type": "string"
@@ -2015,7 +2019,7 @@
     {
       "name": "metamask.perps.ensure_orders",
       "owner": "metamask",
-      "description": "extension Default to testnet for Perps mutations; mainnet is read-only unless explicitly requested. Higher-level wrapper that reads selected orders, cancels when needed, then asserts final order state.",
+      "description": "extension Converge selected testnet orders to open or absent, then independently assert the final state. Creating an open state uses a resting limit order.",
       "schema": {
         "type": "object",
         "properties": {
@@ -2098,6 +2102,16 @@
           "timeout_ms": {
             "type": "number"
           },
+          "notional": {
+            "type": "number",
+            "default": 10,
+            "description": "Small testnet USD notional used only when creating a missing open order."
+          },
+          "leverage": {
+            "type": "number",
+            "default": 3,
+            "description": "Testnet leverage used only when creating a missing open order."
+          },
           "state": {
             "type": "string",
             "enum": [
@@ -2124,6 +2138,18 @@
             "mode": "all",
             "intent": "Converge Perps orders to the requested state"
           }
+        },
+        {
+          "description": "Ensure one small resting ETH short order exists",
+          "node": {
+            "action": "metamask.perps.ensure_orders",
+            "market": "ETH",
+            "side": "short",
+            "state": "open",
+            "notional": 10,
+            "leverage": 2,
+            "intent": "Converge ETH open orders to one deterministic testnet precondition"
+          }
         }
       ],
       "proof_effect": "E2E validation must record this action in trace.json; live-proof actions include liveAdapter/proofPath or target runtime output.",

package/library/manifests/mobile.action-manifest.json

@@ -316,6 +316,10 @@
           },
           "settle": {
             "type": "boolean"
+          },
+          "long_press": {
+            "type": "boolean",
+            "description": "Invoke the target component's long-press gesture. Requires identifier targeting."
           }
         },
         "additionalProperties": false
@@ -336,6 +340,15 @@
             "text": "Ethereum",
             "intent": "Press the component containing the visible Ethereum label"
           }
+        },
+        {
+          "description": "Long-press a component by stable React Native testID",
+          "node": {
+            "action": "ui.press",
+            "test_id": "keypad-delete-button",
+            "long_press": true,
+            "intent": "Clear the current keypad value through its human reset gesture"
+          }
         }
       ]
     },
@@ -2143,7 +2156,7 @@
     {
       "name": "metamask.perps.ensure_orders",
       "owner": "metamask",
-      "description": "mobile Default to testnet for Perps mutations; mainnet is read-only unless explicitly requested. Higher-level wrapper that reads selected orders, cancels when needed, then asserts final order state.",
+      "description": "mobile Converge selected testnet orders to open or absent, then independently assert the final state. Creating an open state uses a resting limit order.",
       "schema": {
         "type": "object",
         "properties": {
@@ -2226,6 +2239,16 @@
           "timeout_ms": {
             "type": "number"
           },
+          "notional": {
+            "type": "number",
+            "default": 10,
+            "description": "Small testnet USD notional used only when creating a missing open order."
+          },
+          "leverage": {
+            "type": "number",
+            "default": 3,
+            "description": "Testnet leverage used only when creating a missing open order."
+          },
           "state": {
             "type": "string",
             "enum": [
@@ -2252,6 +2275,18 @@
             "mode": "all",
             "intent": "Converge Perps orders to the requested state"
           }
+        },
+        {
+          "description": "Ensure one small resting ETH short order exists",
+          "node": {
+            "action": "metamask.perps.ensure_orders",
+            "market": "ETH",
+            "side": "short",
+            "state": "open",
+            "notional": 10,
+            "leverage": 2,
+            "intent": "Converge ETH open orders to one deterministic testnet precondition"
+          }
         }
       ],
       "proof_effect": "E2E validation must record this action in trace.json; live-proof actions include liveAdapter/proofPath or target runtime output.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"
@@ -21,7 +21,7 @@
   "dependencies": {
     "@farmslot/agent-runtime": "^0.2.0",
     "@farmslot/protocol": "^0.11.0",
-    "@farmslot/recipe-harness": "^0.9.0",
+    "@farmslot/recipe-harness": "^0.9.1",
     "commander": "^12.0.0",
     "es-module-lexer": "2.3.1",
     "esbuild": "0.28.1",