@deeeed/metamask-harness 0.89.0 → 0.90.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+## 0.90.0 - 2026-10-12
+
+- Use typed iOS simulator recording targets, retain original Android recording segments, and use the shared action-context snapshot API for Extension evidence.
+
+- Share compact log viewing and owned-window recovery with the project recipe CLI, preserving event counts and cancellation.
+
+- Preserve project doctor reports, setup advisories, explicit fixture repairs and wallet-aware health indicators through the shared provider host.
+
+### Changed
+
+- Pin the coordinated shared runtime releases: protocol 0.39.0, recipe-runner 0.30.0, adapter-sdk 0.9.0, agent-runtime 0.18.0, recipe-cli 0.14.1, adapter-node 0.1.13, adapter-rn 0.20.0 and adapter-web 0.7.0.
+- Preserve checkout status details, resolved project library revisions and owned collector cleanup for shared project lifecycle commands; keep readiness device selection read-only and refuse Metro-wide reload when multiple devices are connected and forward interruption to owned reload processes.
+- Collect opt-in rendered HUD observations around screenshot capture for live conformance.
+- Bind navigation-memory suite claims to explicit assertions on the measured bounds.
+
 ## 0.89.0 - 2026-10-11
 
 ### Added

package/adapters/mobile/reload-app.mjs

@@ -79,6 +79,16 @@ async function reload(port) {
       `No React Native debug target with a stable ID is connected to Metro on port ${numericPort}`,
     );
   }
+  const response = await fetch(`http://127.0.0.1:${numericPort}/json/list`, {
+    signal: AbortSignal.timeout(5000),
+  });
+  if (!response.ok) throw new Error(`Cannot inspect Metro clients on port ${numericPort}`);
+  const clients = rankRuntimeCandidates(await response.json());
+  const deviceIds = new Set(clients.map((client) => deviceIdFromUrl(client.webSocketDebuggerUrl)));
+  // Metro's message channel reloads every connected client, even when CDP is pinned.
+  if (deviceIds.size !== 1 || !deviceIds.has(deviceIdFromUrl(targetBefore.wsUrl))) {
+    throw new Error(`Metro reload needs one connected device on port ${numericPort}. Next: use a dedicated slot Metro or an explicit targeted app.lifecycle restart.`);
+  }
   const processBefore = readAndroidPid();
   if (androidSerial() && !processBefore) {
     throw new Error(`The Android app is not running on ${androidSerial()}`);

package/dist/adapters/extension/reload.js

@@ -1,7 +1,7 @@
-import { EXIT, spawnScript, usageOut } from "@farmslot/recipe-cli/harness";
+import { EXIT, spawnScriptStreaming, usageOut } from "@farmslot/recipe-cli/harness";
 import path from "node:path";
 import { runnerDir } from "../../paths.js";
-function reloadExtension(target, json) {
+async function reloadExtension(target, json) {
   const adapter = "extension";
   if (!process.env.CDP_PORT) {
     return usageOut(
@@ -16,7 +16,7 @@ function reloadExtension(target, json) {
   if (process.env.WATCHER_PORT) {
     args.push("--watcher-port", process.env.WATCHER_PORT);
   }
-  const result = spawnScript(script, args, target, json);
+  const result = await spawnScriptStreaming(script, args, target, { forward: json ? "none" : "stderr" });
   if (json) {
     console.log(
       JSON.stringify(

package/dist/adapters/extension/run.js

@@ -159,12 +159,7 @@ async function ensureExtensionProofRuntime(target, heal, state, json, deps = {})
   return null;
 }
 const extensionRecording = {
-  target: (context) => resolveExtensionRecordingTarget(context),
-  framed: {
-    browserPid: (projectRoot, artifactsDir, cdpPort) => resolveExtensionBrowserPid(projectRoot, artifactsDir, cdpPort),
-    // cdp.mjs snapshots the framed recording of this pid.
-    activePidEnv: "METAMASK_RECIPE_EXTENSION_ACTIVE_RECORDING_PID"
-  }
+  target: (context) => resolveExtensionRecordingTarget(context)
 };
 async function resolveExtensionRecordingTarget(context) {
   const pid = resolveExtensionBrowserPid(

package/dist/adapters/mobile/android-screenrecord.js

@@ -173,38 +173,38 @@ async function startRecording(serial, request, adb, options) {
         }
         if (recorded.length === 0) throw recordingFailure("RECORDING_FAILED", `Android recording output is empty: ${request.outputPath}`);
         const startedAtUnixMs = recorded[0].startedAtUnixMs;
-        const stoppedAtUnixMs = recorded.at(-1).stoppedAtUnixMs;
         const placed = recorded.map((segment) => ({ ...segment, offsetMs: segment.startedAtUnixMs - startedAtUnixMs }));
-        joinSegments(placed, request.outputPath);
         const timingEvidencePath = `${path.basename(request.outputPath)}.segments.json`;
-        fs.writeFileSync(
-          path.join(stagingDir, timingEvidencePath),
-          `${JSON.stringify({
-            recorder: "adb-screenrecord",
-            serial,
-            segments: placed.map((segment) => ({
-              offsetMs: segment.offsetMs,
-              startedAtUnixMs: segment.startedAtUnixMs,
-              stoppedAtUnixMs: segment.stoppedAtUnixMs,
-              bytes: segment.bytes
-            }))
-          })}
-`
-        );
-        const timing = await optionalVideoTiming(request.outputPath, { startedAtUnixMs, stoppedAtUnixMs });
+        fs.writeFileSync(path.join(stagingDir, timingEvidencePath), `${JSON.stringify({
+          recorder: "adb-screenrecord",
+          serial,
+          segments: placed.map(({ offsetMs, startedAtUnixMs: startedAtUnixMs2, stoppedAtUnixMs, bytes }) => ({
+            offsetMs,
+            startedAtUnixMs: startedAtUnixMs2,
+            stoppedAtUnixMs,
+            bytes
+          }))
+        })}
+`);
         const recorder = { name: "adb-screenrecord", platform: "android", target: { selector: "adb-serial", value: serial } };
-        return {
-          ...timing.timing ? { timing: { ...timing.timing, clock: { ...timing.timing.clock, latestZeroUnixMs: latestVideoZero(timing.timing, placed) } } } : timing,
+        const originals = await Promise.all(recorded.map(async (segment, index) => ({
+          path: path.basename(segment.localPath),
+          ...index > 0 ? { gapBefore: true } : {},
+          ...await optionalVideoTiming(segment.localPath, {
+            startedAtUnixMs: segment.startedAtUnixMs,
+            stoppedAtUnixMs: segment.stoppedAtUnixMs
+          }),
           timingEvidencePath,
-          recorder,
-          // The runner keeps the files finished before the failure and fails the run as CAPTURE_INTERRUPTED.
-          ...interruption ? {
-            interruption: {
-              frames: timing.timing?.framesMs.length ?? 0,
-              mediaTimeMs: timing.timing?.framesMs.at(-1) ?? 0,
-              cause: interruption
-            }
-          } : {}
+          recorder
+        })));
+        for (const segment of recorded) localFiles.delete(segment.localPath);
+        return {
+          segments: originals,
+          ...interruption ? { interruption: {
+            frames: originals.reduce((sum, segment) => sum + (segment.timing?.framesMs.length ?? 0), 0),
+            mediaTimeMs: placed.at(-1).offsetMs + (originals.at(-1).timing?.framesMs.at(-1) ?? 0),
+            cause: interruption
+          } } : {}
         };
       } finally {
         abandon();
@@ -213,36 +213,6 @@ async function startRecording(serial, request, adb, options) {
     }
   };
 }
-function latestVideoZero(timing, segments) {
-  return segments.reduce((latest, segment, index) => {
-    const to = segments[index + 1]?.offsetMs ?? Infinity;
-    const last = timing.framesMs.filter((time) => time >= segment.offsetMs && time < to).at(-1);
-    return last === void 0 ? latest : Math.max(latest, segment.stoppedAtUnixMs - last);
-  }, timing.clock.latestZeroUnixMs);
-}
-function joinSegments(segments, outputPath) {
-  if (segments.length === 1) {
-    fs.renameSync(segments[0].localPath, outputPath);
-    return;
-  }
-  const listPath = `${outputPath}.segments.txt`;
-  const list = segments.map((segment, index) => {
-    const entry = `file '${segment.localPath.replaceAll("'", "'\\''")}'`;
-    const next = segments[index + 1];
-    return next ? `${entry}
-duration ${((next.offsetMs - segment.offsetMs) / 1e3).toFixed(3)}` : entry;
-  });
-  fs.writeFileSync(listPath, `${list.join("\n")}
-`);
-  try {
-    const join = spawnSync(ffmpegPath(), ["-v", "error", "-y", "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", outputPath], {
-      encoding: "utf8"
-    });
-    if (join.status !== 0) throw new Error(`Could not join Android recording segments: ${failure(join)}`);
-  } finally {
-    fs.rmSync(listPath, { force: true });
-  }
-}
 function ffmpegPath() {
   return process.env.FFMPEG_PATH || "ffmpeg";
 }

package/dist/adapters/mobile/devices.js

@@ -12,12 +12,13 @@ const mobileDevices = {
   // adapter-sdk's live view names the app's feature-flag overrides `featureFlags`.
   async live(target, view) {
     const live = await mobileDeviceLiveView(target, view);
-    return { ...live, featureFlags: live.featureFlagOverrides };
+    return { ...live, featureFlags: live.featureFlagOverrides, statusFields: live.androidPortHints.length ? { androidPortHints: live.androidPortHints } : {} };
   },
   renderList: renderMobileDeviceList,
   renderAdditional: renderAdditionalReachableDevices,
   renderLive: renderMobileLiveBlock,
   renderPortHints: renderAndroidPortHints,
+  renderHints: (live, paint) => renderAndroidPortHints(live.androidPortHints, paint),
   nextForLive
 };
 export {

package/dist/adapters/mobile/reload.js

@@ -1,12 +1,12 @@
-import { EXIT, spawnScript } from "@farmslot/recipe-cli/harness";
+import { EXIT, spawnScriptStreaming } from "@farmslot/recipe-cli/harness";
 import path from "node:path";
 import { runnerDir } from "../../paths.js";
-function reloadMobile(target, json) {
+async function reloadMobile(target, json) {
   const script = path.join(runnerDir, "adapters/mobile/reload-app.mjs");
   const args = [];
   if (process.env.WATCHER_PORT) args.push("--port", process.env.WATCHER_PORT);
   if (json) args.push("--json");
-  const result = spawnScript(process.execPath, [script, ...args], target, json);
+  const result = await spawnScriptStreaming(process.execPath, [script, ...args], target, { forward: json ? "none" : "stderr" });
   if (json) process.stdout.write(result.output);
   return result.status === 0 ? EXIT.ok : EXIT.runtime;
 }

package/dist/adapters/mobile/run.js

@@ -1,7 +1,6 @@
 import { EXIT, isRecord } from "@farmslot/recipe-cli/harness";
 import { spawnSync } from "node:child_process";
 import path from "node:path";
-import { IOS_SIMULATOR_RECORDING_TARGET_PREFIX } from "@farmslot/adapter-rn";
 import { devicePlatformFromEnv } from "../performance/device-platform.js";
 import {
   resolveAndroidDeviceSerial,
@@ -171,8 +170,8 @@ async function resolveMobileRecordingTarget(context) {
     );
   }
   return {
-    kind: "window-id",
-    windowId: `${IOS_SIMULATOR_RECORDING_TARGET_PREFIX}${simulator}`
+    kind: "simulator",
+    device: simulator
   };
 }
 const mobileDiagnostics = {

package/dist/checkout-view.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { color, recipeRuntimeDir } from "@farmslot/recipe-cli/harness";
+import { color, harnessContext, recipeRuntimeDir } from "@farmslot/recipe-cli/harness";
 import { renderRuntimeContext, runtimeContextSummary } from "./doctor.js";
 import {
   configPath,
@@ -12,11 +12,18 @@ const NO_LIBRARIES = "none registered. Learn how: docs/RECIPES.md, or run: mm-ha
 const FIXTURE_REPORT = path.join("prepare", "fixtures.json");
 function collectCheckoutView(target, adapter) {
   const declared = declaredLibraryPathEnv();
-  const libraries = discoverLibraries({
+  const bound = harnessContext()?.project?.libraries;
+  const sources = bound !== void 0 ? bound.map((library) => ({
+    name: library.name,
+    root: library.root,
+    source: "binding",
+    revision: library.identity.head ?? library.revision
+  })) : discoverLibraries({
     target,
     config: readConfig(configPath()),
     ...declared ? { env: { ...process.env, RECIPE_LIBRARY_PATH: declared.value } } : {}
-  }).map((library) => ({
+  });
+  const libraries = sources.map((library) => ({
     name: library.name,
     root: library.root,
     source: library.source,

package/dist/command-contract.js

@@ -42,6 +42,7 @@ const RECIPE_RUNTIME = {
   "--validation-runtime-dir": value(),
   "--launch-existing-dist": bool(),
   "--record-video": optionalValue(["full-run", "off"]),
+  "--recording-reason": value(),
   "--source-trust": value(["trusted", "untrusted", "unknown"]),
   "--source-kind": value(["bundled", "operator", "task", "recipe-file", "library", "custom-adapter"]),
   "--source-name": value(),
@@ -788,6 +789,7 @@ Common overrides:
   --json                             Machine-readable output
   --json-stream                      Line-flushed JSONL progress + terminal event
   --record-video=full-run            Record a video of the run
+  --recording-reason <text>          Explain an explicit recording opt-out
   --hud <show|hide>                  Recipe HUD: each node's intent drawn over the app on every adapter, headless included (default: show)
 
 Advanced integrations:

package/dist/commands/device-target.js

@@ -129,7 +129,7 @@ function applyDeviceTargeting(command, adapter, options, opts) {
       }
       if (matched.platform === "android") setAndroidDeviceEnv(matched.id, matched.name);
       else setIosDeviceEnv(matched.id, matched.name);
-      persistExplicitDevicePin(targetPath(options), matched);
+      if (opts.persistPin !== false) persistExplicitDevicePin(targetPath(options), matched);
       return { ok: true };
     };
     const androidById = connected2.find((d) => d.platform === "android" && d.id === device);

package/dist/commands/doctor.js

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { featureFlagReport } from "../feature-flags.js";
-import { adapterPluginChecks, color, acquireCheckoutLock, contextAdapter, resolveRuntimeContextPath, ensureOverlay, newHealState, recipeRunning, adapterDetectNext, checkoutBusyOut, EXIT, usageOut, actionManifestPathOption, applyRuntimeDirOption, optionFlag, optionString, shellQuote, targetPath } from "@farmslot/recipe-cli/harness";
+import { adapterPluginChecks, color, acquireCheckoutLock, contextAdapter, resolveRuntimeContextPath, ensureOverlay, newHealState, recipeRunning, adapterDetectNext, checkoutBusyOut, EXIT, usageOut, actionManifestPathOption, applyRuntimeDirOption, optionFlag, optionString, shellQuote, spawnScriptStreaming, doctorReady, renderDoctorRecorder, targetPath } from "@farmslot/recipe-cli/harness";
 import { collectCheckoutView, renderCheckoutView } from "../checkout-view.js";
 import { createDoctorReport, fixtureSummary, requiredDoctorCheckSummary } from "../doctor.js";
 import { assertAdapter, runnerDir } from "../paths.js";
@@ -110,7 +110,7 @@ async function handleDoctor({ options }) {
       } else if (runtimeProbeError2) {
         console.log(`runtime probe failed: ${runtimeProbeError2}`);
       }
-      if (recorder2) console.log(`recorder: ${recorder2.status} ${recorder2.message}`);
+      renderDoctorRecorder(recorder2);
       for (const action of nextActions) console.error(`  Next: ${action}`);
     }
     return status === "pass" ? 0 : 1;
@@ -230,7 +230,7 @@ async function handleDoctor({ options }) {
     } else if (runtimeProbeError) {
       console.log(`${out("err", "runtime probe failed:")} ${out("dim", runtimeProbeError)}`);
     }
-    if (recorder) console.log(`${out("label", "recorder:")} ${out(recorder.status === "pass" ? "ok" : "err", recorder.status)} ${recorder.message}`);
+    renderDoctorRecorder(recorder, out);
     console.log(renderCheckoutView(view));
     console.log(`${out("label", "feature flags:")} ${out(
       featureFlags.error || (featureFlags.overrideCount ?? 0) > 0 ? "warn" : "dim",
@@ -255,9 +255,7 @@ async function handleDoctor({ options }) {
   }
   return doctorResult.status === "pass" ? 0 : 1;
 }
-function doctorReady(runtime, recorder) {
-  return runtime?.decision === "ready" && recorder?.status !== "fail";
-}
+import { doctorReady as doctorReady2 } from "@farmslot/recipe-cli/harness";
 async function platformDoctorChecks(adapter, target) {
   try {
     return await getAdapterSurface(adapter).doctor?.(target) ?? [];
@@ -295,11 +293,7 @@ function doctorFixNextActions(failed, fixture, adapter, target, block) {
   const actions = [];
   const executable = process.env.MM_HARNESS_EXECUTABLE ? shellQuote(process.env.MM_HARNESS_EXECUTABLE) : "mm-harness";
   const scope = `--adapter ${adapter} --target ${shellQuote(target)}`;
-  if (failed.includes("wallet-fixture")) {
-    const force = fixture.status === "invalid" || fixture.status === "incomplete" ? " --force" : "";
-    actions.push(`1) ${executable} fixtures init --from <path>${force} ${scope}   # existing team/test fixture`);
-    actions.push(`2) ${executable} fixtures init --dev${force} ${scope}           # disposable public test wallet; never real funds`);
-  }
+  actions.push(...doctorFixtureNextActions(failed, fixture, scope, executable));
   if (failed.includes("runtime-context")) {
     actions.push(
       `inspect ${shellQuote(resolveRuntimeContextPath(target))}, then retry ${executable} doctor --fix ${scope}`
@@ -309,6 +303,15 @@ function doctorFixNextActions(failed, fixture, adapter, target, block) {
   if (block?.userAction && failed.includes(block.id)) actions.push(block.userAction);
   return actions;
 }
+function doctorFixtureNextActions(failed, fixture, scope, executable = process.env.MM_HARNESS_EXECUTABLE ? shellQuote(process.env.MM_HARNESS_EXECUTABLE) : "mm-harness") {
+  const actions = [];
+  if (failed.includes("wallet-fixture")) {
+    const force = fixture.status === "invalid" || fixture.status === "incomplete" ? " --force" : "";
+    actions.push(`1) ${executable} fixtures init --from <path>${force} ${scope}   # existing team/test fixture`);
+    actions.push(`2) ${executable} fixtures init --dev${force} ${scope}           # disposable public test wallet; never real funds`);
+  }
+  return actions;
+}
 function emitExpectLiveVerdict(adapter, target, runtime, verdict, recorder) {
   const out = (style, text) => color(style, text, { stream: process.stderr });
   const detail = runtime ? `${runtime.decision}${runtime.reasonCode ? ` (${runtime.reasonCode})` : ""}` : "runtime probe unavailable";
@@ -456,26 +459,27 @@ async function runDoctorFix(adapter, target, manifestValidation, json) {
   const ensured = await ensureOverlay(adapter, target, "infra-only", state, json);
   if (!ensured.ok) failed.push("overlay");
   else if (state.mutations.length > 0) fixed.push("overlay");
-  let fixture = fixtureSummary(target, adapter);
-  if (fixture.status !== "ready") {
-    const syncFixture = path.join(runnerDir, "adapters/shared/sync-wallet-fixture.sh");
-    try {
-      execFileSync("bash", [syncFixture, "--target", target], {
-        encoding: "utf8",
-        stdio: json ? ["ignore", "ignore", "ignore"] : "inherit",
-        timeout: 3e4
-      });
-    } catch {
-    }
-    fixture = fixtureSummary(target, adapter);
-    if (fixture.status === "ready") fixed.push("wallet-fixture");
-    else failed.push("wallet-fixture");
-  }
+  const fixture = await repairDoctorFixture(target, adapter, json);
+  fixed.push(...fixture.fixed);
+  failed.push(...fixture.failed);
   return { fixed, failed };
 }
+async function repairDoctorFixture(target, adapter, json) {
+  if (fixtureSummary(target, adapter).status === "ready") return { fixed: [], failed: [] };
+  const syncFixture = path.join(runnerDir, "adapters/shared/sync-wallet-fixture.sh");
+  await spawnScriptStreaming("bash", [syncFixture, "--target", target], target, {
+    forward: json ? "none" : "stderr",
+    timeoutMs: 3e4
+  });
+  return fixtureSummary(target, adapter).status === "ready" ? { fixed: ["wallet-fixture"], failed: [] } : { fixed: [], failed: ["wallet-fixture"] };
+}
 export {
   doctorFixNextActions,
-  doctorReady,
+  doctorFixtureNextActions,
+  doctorReady2 as doctorReady,
   handleDoctor,
+  renderSkillsView,
+  renderUpdateStatus,
+  repairDoctorFixture,
   skillsView
 };

package/dist/commands/logs.js

@@ -1,7 +1,7 @@
-import { adapterDetectNext, EXIT, flag, parseFlags, contextAdapter, spawnInherit, spawnScript, str, targetOf, usageOut } from "@farmslot/recipe-cli/harness";
+import { adapterDetectNext, EXIT, flag, parseFlags, contextAdapter, spawnInherit, str, targetOf, usageOut } from "@farmslot/recipe-cli/harness";
 import fs from "node:fs";
 import path from "node:path";
-import { runnerDir } from "../paths.js";
+import { createLogsOptions } from "../provider-logs.js";
 import { getAdapterSurface } from "../adapters/surface.js";
 const LOGS_BOOLEANS = /* @__PURE__ */ new Set(["full", "json", "window"]);
 async function handleLogs(argv) {
@@ -66,27 +66,12 @@ async function handleLogs(argv) {
     );
   }
   if (flag(options, "window")) {
-    surface.resolveSlotPorts(target);
-    const port = process.env.WATCHER_PORT ?? process.env.METRO_PORT ?? "default";
-    const windowName = `${surface.devServer.label}-${port}`;
-    const devLog = logSources[0].path;
-    const leaf = path.join(runnerDir, "adapters/shared/open-log-window.sh");
-    const result = spawnScript(
-      leaf,
-      ["--window", windowName, "--log", devLog, "--runtime-dir", path.dirname(devLog)],
+    const result = await createLogsOptions(surface).window({
       target,
-      json
-    );
-    if (json) {
-      console.log(
-        JSON.stringify(
-          { schemaVersion: 1, command: "logs", action: "window", adapter, window: windowName, logFile: devLog, exitCode: result.status === 0 ? EXIT.ok : EXIT.runtime },
-          null,
-          2
-        )
-      );
-    }
-    return result.status === 0 ? EXIT.ok : EXIT.runtime;
+      logFile: logSources[0].path
+    });
+    if (json) console.log(JSON.stringify({ schemaVersion: 1, command: "logs", action: "window", adapter, ...result }, null, 2));
+    return result.exitCode;
   }
   if (json) {
     console.log(JSON.stringify({ schemaVersion: 1, command: "logs", adapter, source, logFile, exitCode: EXIT.ok }, null, 2));
@@ -102,14 +87,12 @@ async function handleLogs(argv) {
   if (full) {
     return spawnInherit("tail", ["-n", "+1", "-F", logFile], target) === 0 ? EXIT.ok : EXIT.runtime;
   }
-  const logTui = path.join(runnerDir, "adapters/shared/log-tui.mjs");
-  const eventCount = process.env.RECIPE_LOG_EVENTS ?? "20";
-  const uiMode = process.env.RECIPE_LOG_UI_MODE ?? "compact";
-  return spawnInherit(
-    process.execPath,
-    [logTui, "tail", "--log", logFile, "--events", eventCount, "--follow", "--mode", uiMode],
-    target
-  ) === 0 ? EXIT.ok : EXIT.runtime;
+  return createLogsOptions(surface).compact({
+    target,
+    logFile,
+    events: process.env.RECIPE_LOG_EVENTS ?? "20",
+    mode: process.env.RECIPE_LOG_UI_MODE ?? "compact"
+  });
 }
 export {
   handleLogs

package/dist/doctor.js

@@ -1,11 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { RECIPE_CLI_VERSION } from "@farmslot/recipe-cli";
-import { color, harnessContext, harnessContextField, harnessExecutable, recipeHarnessRoot, recipeRuntimeDir, readRuntimeContextField, resolveRuntimeContextPath } from "@farmslot/recipe-cli/harness";
+import { color, createDoctorReport as sharedDoctorReport, harnessContext, recipeHarnessRoot, recipeRuntimeDir, readRuntimeContextField, resolveRuntimeContextPath, runnerInstallKind as sharedInstallKind, runnerProvenance as sharedProvenance } from "@farmslot/recipe-cli/harness";
 import { normalizeFeatureFlagRecord } from "./feature-flags.js";
 import { getAdapterSurface } from "./adapters/surface.js";
 import { isPin } from "./harness-pin.js";
-import { readJson, runnerDir } from "./paths.js";
+import { readJson } from "./paths.js";
 function requiredDoctorCheckSummary(checks) {
   const required = checks.filter((check) => check.required);
   const failed = required.filter((check) => check.status === "fail").map((check) => check.id);
@@ -139,99 +138,40 @@ function renderRuntimeContext(runtimeContext) {
   }
   return lines.join("\n");
 }
-function createDoctorReport(adapter, target, manifestValidation, actionManifestPath = getAdapterSurface(adapter).actions.manifestPath(), platform) {
-  const readiness = getAdapterSurface(adapter).readiness;
-  const mode = compatibilityMode(adapter, target);
-  const manifestErrors = Number(manifestValidation.summary?.errors ?? 0);
-  const checks = [
-    {
-      id: "manifest",
-      status: manifestErrors === 0 ? "pass" : "fail",
-      required: true,
-      message: manifestErrors === 0 ? "Action manifest is valid Recipe v1." : `Action manifest has ${manifestErrors} validation error(s).`
-    },
-    {
+const doctorReportOptions = {
+  provenance: { name: "@metamask/recipe-runner", pinned: isPin },
+  checks(target, adapter) {
+    const mode = compatibilityMode(adapter, target);
+    return [{
       id: "bridge",
       status: mode === "unsupported/no bridge" ? "fail" : "pass",
       required: false,
       message: mode === "unsupported/no bridge" ? `No ${adapter} bridge is available for this checkout.` : `${adapter} compatibility mode: ${mode}.`
-    },
-    ...readiness.checks?.(target, platform) ?? []
-  ];
-  const requiredChecks = requiredDoctorCheckSummary(checks);
-  return {
-    schemaVersion: 1,
-    protocolVersion: "v1",
-    runner_protocol_version: 1,
-    status: requiredChecks.status,
-    checks,
-    requiredChecks,
-    adapter,
-    target,
-    ...harnessContextField(),
-    runner: runnerProvenance(actionManifestPath),
-    compatibilityMode: mode,
+    }];
+  },
+  fields: (target, adapter, environment) => ({
+    compatibilityMode: compatibilityMode(adapter, target),
     shape: repoShape(target),
     fixture: fixtureSummary(target, adapter),
-    environment: readiness.environment?.(target) ?? {},
-    runtimeContext: runtimeContextSummary(target, adapter),
-    manifestValidation: manifestValidation.summary
-  };
+    environment,
+    runtimeContext: runtimeContextSummary(target, adapter)
+  })
+};
+function createDoctorReport(adapter, target, manifestValidation, actionManifestPath = getAdapterSurface(adapter).actions.manifestPath(), platform) {
+  const report = sharedDoctorReport(adapter, target, manifestValidation, actionManifestPath, platform, doctorReportOptions);
+  return { ...report, runner: metaMaskProvenance(report.runner), manifestValidation: manifestValidation.summary };
 }
 function runnerInstallKind(runnerRoot, invokedPath, executablePath) {
-  if (isPin(runnerRoot)) return "pinned-install";
-  const normalizedRoot = path.normalize(runnerRoot);
-  const nodeModulesSegment = `${path.sep}node_modules${path.sep}`;
-  const globalNodeModulesSegment = `${path.sep}lib${path.sep}node_modules${path.sep}`;
-  if (normalizedRoot.includes(globalNodeModulesSegment)) return "global-install";
-  const nodeModulesIndex = normalizedRoot.lastIndexOf(nodeModulesSegment);
-  if (nodeModulesIndex >= 0) {
-    const nodeModulesRoot = normalizedRoot.slice(
-      0,
-      nodeModulesIndex + nodeModulesSegment.length - 1
-    );
-    const invoked = path.resolve(invokedPath);
-    const projectBin = `${path.join(nodeModulesRoot, ".bin")}${path.sep}`;
-    if (invoked === path.resolve(executablePath) || invoked.startsWith(projectBin)) {
-      return "project-install";
-    }
-    return "global-install";
-  }
-  if (path.resolve(invokedPath) !== path.resolve(executablePath)) return "local-link";
-  return "source-checkout";
+  return sharedInstallKind(runnerRoot, invokedPath, executablePath, isPin);
 }
 function runnerProvenance(actionManifestPath) {
-  const packagePath = path.join(runnerDir, "package.json");
-  const packageDocument = readJsonObject(packagePath);
-  const packageName = packageDocument.name;
-  const version = packageDocument.version;
-  if (packageName !== "@deeeed/metamask-harness") {
-    throw new Error(`Expected @deeeed/metamask-harness package name in ${packagePath}`);
-  }
-  if (typeof version !== "string" || !version) {
-    throw new Error(`Expected package version in ${packagePath}`);
+  return metaMaskProvenance(sharedProvenance(actionManifestPath, doctorReportOptions.provenance));
+}
+function metaMaskProvenance(provenance) {
+  if (provenance.name !== "@metamask/recipe-runner" || provenance.packageName !== "@deeeed/metamask-harness") {
+    throw new Error("Doctor provenance does not identify the MetaMask provider.");
   }
-  const executablePath = harnessExecutable();
-  const invokedPath = path.resolve(process.env.MM_HARNESS_INVOKED_AS ?? executablePath);
-  const installKind = runnerInstallKind(runnerDir, invokedPath, executablePath);
-  const packageSource = isPin(runnerDir) ? "pin" : runnerDir.includes(`${path.sep}node_modules${path.sep}`) ? "node_modules" : "source-checkout";
-  return {
-    name: "@metamask/recipe-runner",
-    packageName,
-    version,
-    runnerDir,
-    packagePath,
-    packageSource,
-    installKind,
-    linked: installKind === "local-link",
-    global: installKind === "global-install",
-    invokedPath,
-    executablePath,
-    actionManifestPath,
-    harnessPackage: "@farmslot/recipe-runner",
-    // The @farmslot/recipe-cli this harness runs on (`--version --verbose` prints it too).
-    recipeCliVersion: RECIPE_CLI_VERSION
-  };
+  return { ...provenance, name: provenance.name, packageName: provenance.packageName };
 }
 function readJsonObject(file) {
   const value = readJson(file);
@@ -243,6 +183,7 @@ function readJsonObject(file) {
 export {
   compatibilityMode,
   createDoctorReport,
+  doctorReportOptions,
   fixtureFileSummary,
   fixtureSummary,
   renderRuntimeContext,

package/dist/mm-harness-cli.js

@@ -20,7 +20,7 @@ import {
   parseArgs,
   targetPath
 } from "@farmslot/recipe-cli/harness";
-import { stopProjectCollector } from "../library/actions/shared/analytics/collector.mjs";
+import { stopOptions } from "./provider-lifecycle.js";
 import { adoptPluginAdapter, afterAdapterLoad, configuredLibrarySources } from "./adapters/plugin-surface.js";
 import { withMainnetOrderAbort } from "./adapters/perps-mainnet-cleanup.js";
 import { adapterRegistry } from "./adapters/registry.js";
@@ -70,12 +70,6 @@ const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "
 function hostVersion() {
   return JSON.parse(fs.readFileSync(path.join(harnessHost().packageRoot, "package.json"), "utf8")).version;
 }
-const stopOptions = {
-  companions: async (target) => {
-    const collector = await stopProjectCollector(target);
-    return collector.stopped && collector.pid !== null ? [{ label: "analytics collector", pid: collector.pid }] : [];
-  }
-};
 const targetDevice = (command, adapter, options) => applyDeviceTargeting(command, adapter, options, { gate: true, rerun: "" });
 const runOptions = {
   engine: metaMaskEngine,

package/dist/provider-doctor.js

@@ -0,0 +1,36 @@
+import { doctorFixtureNextActions, repairDoctorFixture, renderSkillsView, renderUpdateStatus, skillsView } from "./commands/doctor.js";
+import { farmslotReadyIndicator } from "./commands/farmslot-ready.js";
+import { updateStatus } from "./commands/update.js";
+import { doctorReportOptions, fixtureSummary } from "./doctor.js";
+import { loadActionManifest, validateManifest } from "./manifest.js";
+import { statusOptions } from "./provider-lifecycle.js";
+import { ensureRuntimeContext } from "./runtime-context.js";
+const doctorOptions = {
+  ...statusOptions,
+  manifest: async (adapter, override) => validateManifest(loadActionManifest(adapter, override)),
+  report: doctorReportOptions,
+  orphanDevServers: { field: "orphanMetros", label: "orphan Metro" },
+  advisory(target) {
+    const skills = skillsView(target);
+    const update = updateStatus();
+    return [
+      { key: "skills", value: skills, render: (out) => renderSkillsView(skills, out) },
+      { key: "update", value: update, render: (out) => renderUpdateStatus(update, out) }
+    ];
+  },
+  fix: {
+    ensureRuntimeContext,
+    repair: repairDoctorFixture,
+    nextActions: (failed, { adapter, target, scope }) => doctorFixtureNextActions(failed, fixtureSummary(target, adapter), scope),
+    userAction: (failed, retry) => failed.includes("wallet-fixture") ? `choose one wallet fixture source from nextActions, run it, then retry: ${retry}` : void 0
+  }
+};
+function configureProviderReadiness(runtime) {
+  Object.assign(runtime.readiness, {
+    readyIndicator: (devices) => farmslotReadyIndicator(runtime.id, [...devices])
+  });
+}
+export {
+  configureProviderReadiness,
+  doctorOptions
+};

package/dist/provider-lifecycle.js

@@ -0,0 +1,26 @@
+import { stopProjectCollector } from "../library/actions/shared/analytics/collector.mjs";
+import { collectCheckoutView, renderCheckoutView } from "./checkout-view.js";
+import { applyDeviceTargeting } from "./commands/device-target.js";
+import { featureFlagReport } from "./feature-flags.js";
+const statusOptions = {
+  checkoutView(target, adapter) {
+    const view = collectCheckoutView(target, adapter);
+    return { json: view, text: renderCheckoutView(view) };
+  },
+  featureFlags: { report: (overrides, detail) => featureFlagReport(overrides, detail) },
+  previewDevice: (command, adapter, options) => applyDeviceTargeting(command, adapter, options, {
+    gate: false,
+    rerun: "",
+    persistPin: false
+  })
+};
+const stopOptions = {
+  companions: async (target) => {
+    const collector = await stopProjectCollector(target);
+    return collector.stopped && collector.pid !== null ? [{ label: "analytics collector", pid: collector.pid }] : [];
+  }
+};
+export {
+  statusOptions,
+  stopOptions
+};

package/dist/provider-logs.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { EXIT, spawnScriptStreaming } from "@farmslot/recipe-cli/harness";
+import { runnerDir } from "./paths.js";
+function createLogsOptions(surface) {
+  return {
+    async compact({ target, logFile, events, mode, signal }) {
+      const result = await spawnScriptStreaming(
+        process.execPath,
+        [path.join(runnerDir, "adapters/shared/log-tui.mjs"), "tail", "--log", logFile, "--events", events, "--follow", "--mode", mode],
+        target,
+        { signal, forward: "original", capture: false }
+      );
+      return result.status === 0 ? EXIT.ok : EXIT.runtime;
+    },
+    async window({ target, logFile, signal }) {
+      surface.resolveSlotPorts(target);
+      const port = process.env.WATCHER_PORT ?? process.env.METRO_PORT ?? "default";
+      const window = `${surface.devServer.label}-${port}`;
+      const result = await spawnScriptStreaming(
+        path.join(runnerDir, "adapters/shared/open-log-window.sh"),
+        ["--window", window, "--log", logFile, "--runtime-dir", path.dirname(logFile)],
+        target,
+        { signal, forward: "stderr", capture: false }
+      );
+      return { window, logFile, exitCode: result.status === 0 ? EXIT.ok : EXIT.runtime };
+    }
+  };
+}
+export {
+  createLogsOptions
+};

package/dist/provider.js

@@ -17,6 +17,9 @@ import { getAdapterSurface } from "./adapters/surface.js";
 import { applyDeviceTargeting } from "./commands/device-target.js";
 import { metaMaskEngine } from "./engine.js";
 import { providerHost } from "./host.js";
+import { configureProviderReadiness, doctorOptions } from "./provider-doctor.js";
+import { statusOptions, stopOptions } from "./provider-lifecycle.js";
+import { createLogsOptions } from "./provider-logs.js";
 import { providerHost as providerHost2 } from "./host.js";
 import { PUBLIC_COMMANDS } from "./command-contract.js";
 async function createProvider(context) {
@@ -37,8 +40,9 @@ async function createProvider(context) {
   });
   await afterAdapterLoad();
   const runtime = getAdapterSurface(adapter);
+  configureProviderReadiness(runtime);
   const executes = isRecipeExecution(context.command, options);
-  if (executes) {
+  if (executes || context.command === "reload") {
     applyRuntimeDirOption(options);
     runtime.resolveSlotPorts(context.target.value);
     const selected = applyDeviceTargeting(context.command, adapter, {
@@ -52,6 +56,7 @@ async function createProvider(context) {
   return {
     runtime,
     engine: metaMaskEngine,
+    commandOptions: { status: statusOptions, stop: stopOptions, doctor: doctorOptions, logs: createLogsOptions(runtime) },
     ...executes ? {
       async cancel() {
         await abortRunMainnetOrders(context.target.value);

package/dist/runner.js

@@ -70,6 +70,7 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
   const core = createStandardCoreAdapters({ actions });
   const projectOwnedOfficialActions = /* @__PURE__ */ new Set(["app.status", "app.lifecycle"]);
   const ui = createStandardUiAdapters({
+    captureHudEvidence: options.captureHudEvidence,
     actions: actions.filter((action) => !projectOwnedOfficialActions.has(action)),
     transport: createMetaMaskUiTransport(adapter, {
       createCdpWebUiTransport,

package/library/actions/extension/platform/cdp.mjs

@@ -20,7 +20,7 @@ import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 
-import { captureActiveRecipeRecordingSnapshot, recipeHarnessPath } from '@farmslot/recipe-cli/harness';
+import { recipeHarnessPath } from '@farmslot/recipe-cli/harness';
 import { importRecipeHarnessRuntimeBrowserExtension, importRecipeHarnessRuntimeCdp, extensionIdPath, walletFixturePath } from '../../harness-exports.mjs';
 import { liveAdapterDeadline } from '../../shared/app/live-adapter-deadline.mjs';
 import { withRateLimitRetry } from '../../shared/perps/rate-limit.mjs';
@@ -375,25 +375,9 @@ export async function captureHelperSnapshot(page, context, relPath, metadata) {
   try {
     pid = await captureHelperBrowserPid(context, page.port);
     const timeoutMs = Number(metadata?.timeoutMs ?? 30000);
-    const sessionSnapshot = await captureActiveRecipeRecordingSnapshot(
-      pid,
-      destination.stagedPath,
-      timeoutMs,
-    );
-    if (sessionSnapshot) {
+    if (context.captureRecordingSnapshot) {
       mode = 'record_session_snapshot';
-      details = sessionSnapshot;
-    } else if (
-      parsePositivePid(process.env.METAMASK_RECIPE_EXTENSION_ACTIVE_RECORDING_PID) === pid
-    ) {
-      await cleanupEvidenceStaging(destination.stagingDir);
-      return captureCdpSnapshot(
-        page,
-        context,
-        relPath,
-        metadata,
-        'native snapshot skipped while full-run recording owns the browser window',
-      );
+      details = await context.captureRecordingSnapshot(path.relative(artifactsRoot, destination.stagedPath));
     } else {
       await reapOrphanedCaptureHelpers(context);
       const result = await runProcess(

package/library/actions/mobile/platform/observe-ui.mjs

@@ -53,10 +53,29 @@ const IOS_TEXT_TEST_IDS = `(() => {
 })()`;
 
 export async function observeNativeUi(payload, context) {
-  await hideAccessibilityMaskingHud(payload, context);
   const refs = Array.isArray(payload?.refs)
     ? payload.refs.filter((ref) => typeof ref === 'string')
     : [];
+  if (refs.length === 1 && refs[0] === 'ui.hud') {
+    // The HUD must stay visible for this capture-bound observation.
+    try {
+      const hierarchy = await readNativeHierarchy(payload, context, []);
+      const expected = String(payload?.node?.intent ?? '').replace(/\s+/gu, ' ').trim();
+      const intents = hierarchy.visible.items.flatMap((item) => {
+        const label = String(item.label ?? '').replace(/\s+/gu, ' ').trim();
+        const intent = hudLabelIntent(label);
+        return intent && item.visible !== false && item.bounds?.width > 0 && item.bounds?.height > 0 ? [intent] : [];
+      });
+      const intent = intents.find((value) => value === expected);
+      return { observations: { 'ui.hud': {
+        visible: Boolean(expected && intent && hierarchy.visible.truncated !== true),
+        intent: intent ?? '', provider: hierarchy.screen.provider,
+      } } };
+    } catch (error) {
+      return { warnings: [{ ref: 'ui.hud', message: error instanceof Error ? error.message : String(error) }] };
+    }
+  }
+  await hideAccessibilityMaskingHud(payload, context);
   const supported = refs.filter((ref) => ref === 'ui.screen' || ref === 'ui.visible');
   const warnings = refs
     .filter((ref) => !supported.includes(ref))
@@ -139,6 +158,10 @@ export async function hideAccessibilityMaskingHud(payload, context) {
   }
 }
 
+function hudLabelIntent(label) {
+  return /^(?:RUN|PASS|FAIL|OK)(?: \d+\/\d+)?\s+(.+)$/u.exec(text(label) ?? '')?.[1];
+}
+
 async function readNativeHierarchy(payload, context, textTestIds) {
   const node = record(payload?.node);
   const env = {
@@ -149,23 +172,24 @@ async function readNativeHierarchy(payload, context, textTestIds) {
     env.METAMASK_RECIPE_PROJECT_ROOT = String(context.projectRoot);
   }
   const platform = resolvePlatform(node, env);
+  const hudIntent = payload?.refs?.length === 1 && payload.refs[0] === 'ui.hud' ? text(node.intent) : undefined;
   const appLabel = nativeAppLabel(env);
   const hierarchy = platform === 'android'
-    ? await readAndroidHierarchy(node, env)
-    : await readIosHierarchy(node, env, textTestIds);
+    ? await readAndroidHierarchy(node, env, hudIntent, context?.signal)
+    : await readIosHierarchy(node, env, textTestIds, hudIntent, context?.signal);
   // No screen name and no labelled item: name the screen after the app.
   hierarchy.screen.name ??= appLabel;
   return hierarchy;
 }
 
-async function readIosHierarchy(node, env, textTestIds) {
+async function readIosHierarchy(node, env, textTestIds, hudIntent, signal) {
   const idbPath = resolveMobileToolPath('idb');
   if (!idbPath) {
     throw new Error(
       `iOS UI observation requires the idb client.\n  Next: ${mobileToolRecovery('idb')}`,
     );
   }
-  const udid = await resolveIosUdid(node, env);
+  const udid = await resolveIosUdid(node, env, signal);
   const { stdout } = await execFileAsync(
     idbPath,
     ['ui', 'describe-all', '--udid', udid],
@@ -174,10 +198,11 @@ async function readIosHierarchy(node, env, textTestIds) {
       timeout: 15_000,
       maxBuffer: 16 * 1024 * 1024,
       env,
+      signal,
     },
   );
   const parsed = parseJsonOutput(stdout);
-  const hierarchy = flattenIosHierarchy(parsed, textTestIds);
+  const hierarchy = flattenIosHierarchy(parsed, textTestIds, hudIntent);
   if (hierarchy.nodeCount === 0) {
     throw new Error('idb returned an empty accessibility hierarchy.');
   }
@@ -191,15 +216,16 @@ async function readIosHierarchy(node, env, textTestIds) {
   );
 }
 
-async function readAndroidHierarchy(node, env) {
+async function readAndroidHierarchy(node, env, hudIntent, signal) {
   const adbPath = resolveMobileToolPath('adb');
   if (!adbPath) {
     throw new Error(
       `Android UI observation requires Android SDK Platform-Tools.\n  Next: ${mobileToolRecovery('adb')}`,
     );
   }
-  const serial = await resolveAndroidSerial(adbPath, node, env);
+  const serial = await resolveAndroidSerial(adbPath, node, env, signal);
   if (isOpaqueRuntime(env)) {
+    if (hudIntent) throw new Error('An opaque runtime has no observable HUD.');
     return readAndroidAgentDeviceHierarchy(serial, env);
   }
   const { stdout } = await execFileAsync(
@@ -210,10 +236,12 @@ async function readAndroidHierarchy(node, env) {
       timeout: 15_000,
       maxBuffer: 16 * 1024 * 1024,
       env,
+      signal,
     },
   );
-  const hierarchy = parseAndroidHierarchy(stdout);
+  const hierarchy = parseAndroidHierarchy(stdout, hudIntent);
   if (hierarchy.nodeCount === 0) {
+    if (hudIntent) throw new Error('The native HUD hierarchy is empty.');
     return readAndroidAgentDeviceHierarchy(serial, env);
   }
   return normalizedHierarchy(
@@ -338,7 +366,7 @@ function normalizedHierarchy(
   };
 }
 
-async function resolveIosUdid(node, env) {
+async function resolveIosUdid(node, env, signal) {
   const requested = text(node.simulator) ?? text(node.ios_simulator) ??
     text(env.SIM_UDID) ?? text(env.IOS_SIMULATOR) ?? 'booted';
   if (/^[0-9a-f-]{36}$/iu.test(requested)) return requested;
@@ -350,6 +378,7 @@ async function resolveIosUdid(node, env) {
       timeout: 5_000,
       maxBuffer: 4 * 1024 * 1024,
       env,
+      signal,
     },
   );
   const parsed = JSON.parse(stdout);
@@ -368,7 +397,7 @@ async function resolveIosUdid(node, env) {
   return udid;
 }
 
-async function resolveAndroidSerial(adbPath, node, env) {
+async function resolveAndroidSerial(adbPath, node, env, signal) {
   const explicit = text(node.adb_serial) ?? text(node.android_serial) ??
     text(env.ADB_SERIAL) ?? text(env.ANDROID_SERIAL);
   if (explicit) return explicit;
@@ -377,6 +406,7 @@ async function resolveAndroidSerial(adbPath, node, env) {
     timeout: 5_000,
     maxBuffer: 4 * 1024 * 1024,
     env,
+    signal,
   });
   const serials = stdout
     .split(/\r?\n/u)
@@ -418,7 +448,7 @@ function parseJsonOutput(output) {
   }
 }
 
-function flattenIosHierarchy(value, textTestIds = []) {
+function flattenIosHierarchy(value, textTestIds = [], hudIntent) {
   const texts = (Array.isArray(textTestIds) ? textTestIds : []).map((entry) => ({
     testId: text(entry?.testId),
     label: text(entry?.label),
@@ -449,7 +479,7 @@ function flattenIosHierarchy(value, textTestIds = []) {
       screenName ??= label;
       screenBounds ??= bounds;
     }
-    if (isActionableRole(role) || testId) {
+    if (isActionableRole(role) || testId || (hudIntent && hudLabelIntent(label) === hudIntent)) {
       const normalized = compactItem({
         role,
         label,
@@ -473,7 +503,7 @@ function flattenIosHierarchy(value, textTestIds = []) {
   return { visible, hidden, nodeCount, screenName };
 }
 
-function parseAndroidHierarchy(output) {
+function parseAndroidHierarchy(output, hudIntent) {
   const xmlStart = Math.max(output.indexOf('<?xml'), output.indexOf('<hierarchy'));
   const xml = xmlStart >= 0 ? output.slice(xmlStart) : output;
   const visible = [];
@@ -514,7 +544,7 @@ function parseAndroidHierarchy(output) {
       isActionableRole(role) ||
       attributes.clickable === 'true' ||
       attributes['long-clickable'] === 'true';
-    if (isActionable || item.test_id) {
+    if (isActionable || item.test_id || (hudIntent && hudLabelIntent(label) === hudIntent)) {
       if (isVisible) {
         visible.push(item);
       } else {

package/library/recipes/extension/performance/navigation-memory-suite.recipe.json

@@ -184,10 +184,7 @@
         "timeout_ms": 400000,
         "max_detached_growth": 50,
         "intent": "Compare retained detached DOM before and after market-detail navigation churn.",
-        "proves": [
-          "detached-dom"
-        ],
-        "next": "idle-control-market-detail"
+        "next": "assert-detached"
       },
       "idle-control-market-detail": {
         "action": "metamask.performance.compare_idle_navigation_memory",
@@ -199,10 +196,7 @@
         "timeout_ms": 400000,
         "max_attributable_listeners_per_cycle": 2,
         "intent": "Subtract equal-duration idle growth from the market-detail navigation slope.",
-        "proves": [
-          "idle-control"
-        ],
-        "next": "return-home"
+        "next": "assert-idle-control"
       },
       "return-home": {
         "action": "ui.navigate",
@@ -213,6 +207,34 @@
       "done": {
         "action": "end",
         "status": "pass"
+      },
+      "assert-detached": {
+        "action": "assert_output",
+        "source": "detached-market-detail",
+        "assert": {
+          "path": "$.passed",
+          "operator": "eq",
+          "value": true
+        },
+        "proves": [
+          "detached-dom"
+        ],
+        "intent": "Verify the observed detached-DOM growth stays within its bound",
+        "next": "idle-control-market-detail"
+      },
+      "assert-idle-control": {
+        "action": "assert_output",
+        "source": "idle-control-market-detail",
+        "assert": {
+          "path": "$.passed",
+          "operator": "eq",
+          "value": true
+        },
+        "proves": [
+          "idle-control"
+        ],
+        "intent": "Verify the observed navigation-attributable growth stays within its bound",
+        "next": "return-home"
       }
     }
   }

package/library/recipes/extension/performance/navigation-memory.recipe.json

@@ -69,11 +69,33 @@
         "screen_timeout_ms": "{{params.screen_timeout_ms}}",
         "timeout_ms": "{{params.timeout_ms}}",
         "intent": "Measure post-GC retained-node and listener slopes for the requested screen",
-        "next": "done"
+        "next": "assert-node-bound"
       },
       "done": {
         "action": "end",
         "status": "pass"
+      },
+      "assert-node-bound": {
+        "action": "assert_output",
+        "source": "measure",
+        "assert": {
+          "path": "$.passed.nodes",
+          "operator": "eq",
+          "value": true
+        },
+        "intent": "Verify the observed retained-node slope satisfies its declared bound",
+        "next": "assert-listener-bound"
+      },
+      "assert-listener-bound": {
+        "action": "assert_output",
+        "source": "measure",
+        "assert": {
+          "path": "$.passed.listeners",
+          "operator": "eq",
+          "value": true
+        },
+        "intent": "Verify the observed listener slope satisfies its declared bound",
+        "next": "done"
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.89.0",
+  "version": "0.90.0",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"
@@ -21,15 +21,15 @@
     "check:syntax": "find . -name '*.mjs' -print0 | xargs -0 -n1 node --check"
   },
   "dependencies": {
-    "@farmslot/adapter-node": "0.1.12",
-    "@farmslot/adapter-rn": "0.19.10",
-    "@farmslot/adapter-sdk": "0.8.6",
-    "@farmslot/adapter-web": "0.6.10",
-    "@farmslot/agent-runtime": "0.17.5",
+    "@farmslot/adapter-node": "0.1.13",
+    "@farmslot/adapter-rn": "0.20.0",
+    "@farmslot/adapter-sdk": "0.9.0",
+    "@farmslot/adapter-web": "0.7.0",
+    "@farmslot/agent-runtime": "0.18.0",
     "@farmslot/handoff": "^0.3.1",
-    "@farmslot/protocol": "0.37.0",
-    "@farmslot/recipe-cli": "0.13.0",
-    "@farmslot/recipe-runner": "0.29.0",
+    "@farmslot/protocol": "0.39.0",
+    "@farmslot/recipe-cli": "0.14.1",
+    "@farmslot/recipe-runner": "0.30.0",
     "agent-device": "0.19.3",
     "commander": "^12.0.0",
     "esbuild": "0.28.1",