@deeeed/metamask-harness 0.62.0 → 0.64.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## Unreleased
 
+## 0.64.0 - 2026-09-25
+
+### Added
+
+- Preflight behavioral proof bindings with `run --proof`, including `--plan`, before launching QA recipes. Executed outcomes and evidence still require runtime validation.
+- Read source-development Extension pending approval IDs and types with `metamask.wallet.read_state scope=pending_approvals`, without mutating requests or exposing payloads.
+
+### Fixed
+
+- Gate all Extension source launch paths on current dependencies and reject bundles compiled against stale or changed installed resolutions. Successful watch and LavaMoat builds record their dependency baseline; verified release artifacts retain their independent launch path.
+
+### Documentation
+
+- Clarify how reusable recipes support daily domain and release QA through the scope-owning skill.
+
+## 0.63.0 - 2026-09-23
+
+### Added
+
+- Show the task's acceptance criteria and recorded verdicts in `status`, `status --watch`, and `status --task`, using the Farmslot handoff and acceptance ledger.
+- Show the active preparation step and elapsed time in `status --watch` and `status --task` even when the agent buffers preparation output.
+
+### Fixed
+
+- Allow 30 seconds for iOS simulator discovery so a cold CoreSimulator startup does not fail at five seconds.
+
 ## 0.62.0 - 2026-09-22
 
 ### Added

package/README.md

@@ -10,6 +10,21 @@ and runtime paths are detected automatically.
 The generic graph engine and evidence schemas live in [Farmslot](https://farmslot.io) packages.
 `mm-harness` owns MetaMask runtime control and domain capabilities.
 
+## Daily and release QA
+
+The same recipes can validate yesterday's domain changes together or a release
+that is behind `main`. The `mms-recipe-qa` skill freezes the change scope and
+criteria; the team library supplies smoke and reusable journeys; this CLI runs
+them on the selected app and retains assertions, traces and captures.
+
+Use the installed skill's `references/domain-qa.md` for window/range inputs and
+report policy. Scope selection and scheduling are outside the harness. Discover
+recipes through `run --list` and `run <recipe> --describe`, then follow the
+locked version's `help --json` for composition and drift diagnosis. Adapt a
+recipe to the tested release without changing the release or weakening its
+criteria. An internal action that needs development instrumentation cannot
+prove behavior on an unmodified release artifact.
+
 ## Getting started from zero
 
 No checkouts yet? `mm-harness setup-base` clones the MetaMask product repos into one

package/adapters/extension/build-lavamoat.sh

@@ -4,11 +4,13 @@ set -euo pipefail
 
 TARGET="$PWD"
 RUNTIME_DIR="temp/recipe/runtime"
+RUNNER_BIN=""
 while [ "$#" -gt 0 ]; do
   case "$1" in
     --target) [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; TARGET="$2"; shift 2 ;;
     --runtime-dir) [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; RUNTIME_DIR="$2"; shift 2 ;;
-    -h|--help) echo "Usage: build-lavamoat.sh [--target <metamask-extension>] [--runtime-dir <relative path>]"; exit 0 ;;
+    --runner-bin) [ "$#" -ge 2 ] || { echo "Missing value for $1" >&2; exit 2; }; RUNNER_BIN="$2"; shift 2 ;;
+    -h|--help) echo "Usage: build-lavamoat.sh [--target <metamask-extension>] [--runtime-dir <relative path>] [--runner-bin <path>]"; exit 0 ;;
     *) echo "Unknown arg: $1" >&2; exit 2 ;;
   esac
 done
@@ -55,4 +57,7 @@ test -f dist/chrome/manifest.json || {
   echo "build-lavamoat: build completed without dist/chrome/manifest.json" >&2
   exit 1
 }
+if [ -n "$RUNNER_BIN" ]; then
+  "$RUNNER_BIN" runtime-decision --adapter extension --target "$TARGET" --record-baseline --json >/dev/null
+fi
 echo "[recipe-harness] non-test LavaMoat build completed"

package/adapters/extension/live.sh

@@ -308,7 +308,7 @@ NODE
     prepare_parts+=("bash ${quoted_start_watch} --runtime-dir ${quoted_runtime_dir} --runner-bin ${quoted_runner}")
   fi
   if $BUILD_LAVAMOAT; then
-    prepare_parts+=("bash ${quoted_build_lavamoat} --target ${quoted_target} --runtime-dir ${quoted_runtime_dir}")
+    prepare_parts+=("bash ${quoted_build_lavamoat} --target ${quoted_target} --runtime-dir ${quoted_runtime_dir} --runner-bin ${quoted_runner}")
   fi
   if ! $EXTERNAL_ARTIFACT; then
     prepare_parts+=("node ${quoted_check_infura} --target ${quoted_target} --runtime-dist ${quoted_dist}")

package/adapters/extension/start-watch.sh

@@ -12,7 +12,7 @@
 #   --runtime-dir <rel> (default from adapters/shared path-defaults)
 #   --watcher-port <port> (default env WATCHER_PORT/RECIPE_WATCHER_PORT,
 #     runtime json, or slot suffix e.g. metamask-extension-1 => 9011)
-#   --runner-bin <path> (optional; records deps/cache baseline best-effort)
+#   --runner-bin <path> (optional; records deps/cache baseline)
 #   --summary <file> (optional; writes the standard summary.json shape)
 #
 # Outputs:
@@ -352,7 +352,7 @@ if ! write_canonical_watch_pid; then
 fi
 echo '[recipe-harness] yarn start compiled successfully'
 if [ -n "$RUNNER_BIN" ]; then
-  "$RUNNER_BIN" runtime-decision --adapter extension --target . --record-baseline --json >/dev/null 2>&1 || true
+  "$RUNNER_BIN" runtime-decision --adapter extension --target . --record-baseline --json >/dev/null
   echo '[recipe-harness] recorded webpack cache baseline (runtime-decision --record-baseline)'
 fi
 status=pass

package/dist/adapters/extension/runtime-decision.js

@@ -56,6 +56,13 @@ function webpackFingerprint(target) {
   for (const dir of WEBPACK_RECURSIVE_INPUTS) walk(hash, target, dir);
   return { gitHead: git(target, ["rev-parse", "HEAD"]) ?? "unknown", fingerprint: hash.digest("hex") };
 }
+function installedDepsFingerprint(target) {
+  const hash = crypto.createHash("sha256");
+  for (const rel of INSTALL_MARKERS) {
+    if (fs.existsSync(path.join(target, rel))) addFile(hash, target, rel);
+  }
+  return hash.digest("hex");
+}
 function stateDir(target) {
   return recipeHarnessPath(target, "extension", "decision-state");
 }
@@ -328,6 +335,10 @@ function distCheck(target) {
   } catch {
     return { status: "no-build" };
   }
+  const baseline = readBaseline(target, "webpack-cache-state.json");
+  if (!baseline || !("installedDepsFingerprint" in baseline) || baseline?.depsCurrent === false || typeof baseline?.installedDepsFingerprint === "string" && baseline.installedDepsFingerprint !== installedDepsFingerprint(target)) {
+    return { status: "stale", reason: "dependencies-changed" };
+  }
   const description = typeof manifest.description === "string" ? manifest.description : "";
   const match = /from git id:\s*([0-9a-f]{7,40})/iu.exec(description);
   const head = (git(target, ["rev-parse", "HEAD"]) ?? "").toLowerCase();
@@ -363,7 +374,11 @@ async function cdpCheck(target, cdpPort, pageMode) {
 }
 function recordWebpackBaseline(target) {
   const cache = webpackFingerprint(target);
-  writeBaseline(target, "webpack-cache-state.json", cache);
+  writeBaseline(target, "webpack-cache-state.json", {
+    ...cache,
+    depsCurrent: depsCheck(target).status === "current",
+    installedDepsFingerprint: installedDepsFingerprint(target)
+  });
 }
 async function decideExtensionReadiness(target, options = {}) {
   const resolved = path.resolve(target);
@@ -424,7 +439,7 @@ async function decideExtensionReadiness(target, options = {}) {
       when: dist.status === "stale",
       decision: "build",
       reasonCode: "dist-stale",
-      reasons: [dist.reason === "uncommitted-source" ? `Uncommitted source since the build (${dist.modified?.length ?? 0} file(s)); rebuild.` : `dist git id ${dist.distGitId} != HEAD ${dist.head}; rebuild.`],
+      reasons: [dist.reason === "uncommitted-source" ? `Uncommitted source since the build (${dist.modified?.length ?? 0} file(s)); rebuild.` : dist.reason === "dependencies-changed" ? "Dependency installation changed or was not current at compilation; rebuild." : `dist git id ${dist.distGitId} != HEAD ${dist.head}; rebuild.`],
       actions: buildAction(resolved, false)
     },
     {

package/dist/cli-commands.js

@@ -25,7 +25,7 @@ const SPEC = {
     { name: "fixtures", desc: "Manage the canonical wallet fixture (sync/set/reset/generate)", args: ["sync", "set", "reset", "generate"], flags: ["--fixture", "--out", "--adapter", "--target", "--device", "--json"] },
     { name: "actions", desc: "List runnable recipe actions", flags: ["--json", "--matrix", "--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: "run", desc: "Execute a proof recipe (path or library name, e.g. run perps.smoke)", args: ["recipe.json|name"], flags: ["--list", "--device", "--plan", "--proof"] },
     { 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 canonical quality or request optional recipe planning/advice", args: ["build", "plan", "advise", "advisor-status"], flags: ["--input", "--output", "--recipe", "--task", "--evidence", "--params", "--adapter", "--library", "--advisor", "--advisor-model", "--advisor-stages", "--json"] },
     { name: "interactive", aliases: ["menu"], desc: "Interactive command menu" },

package/dist/command-contract.js

@@ -254,6 +254,7 @@ const PUBLIC_COMMAND_CONTRACTS = {
     options: options(HELP, JSON, JSON_STREAM, TARGET, ADAPTER, MOBILE_PLATFORM, DEVICE, RUNTIME_PORTS, RECIPE_RUNTIME, RUN_FUNDING, {
       "--list": bool(),
       "--plan": bool(),
+      "--proof": bool(),
       "--describe": bool(),
       "--hud": value(["auto", "show", "hide"])
     }),

package/dist/commands/launch/extension.js

@@ -52,6 +52,7 @@ function extensionDepsBlock(target) {
   return null;
 }
 async function installExtensionDeps(target) {
+  stopExtensionWatcher(target);
   const installScript = path.join(runnerDir, "adapters/shared/install-repo-deps.sh");
   const result = await spawnScriptStreaming(installScript, ["--target", target], target);
   if (result.status === 0) recordDepsBaseline(target);
@@ -91,6 +92,16 @@ async function launchExtension(target, tier, wantWatch, displayMode = "fullscree
 Next: rerun runtime-launch with the same artifact source.`
     };
   }
+  if (artifact.status === "none") {
+    const depsBlock = extensionDepsBlock(target);
+    if (depsBlock) {
+      return {
+        status: EXIT.infra,
+        output: `EXTENSION_DEPENDENCIES_REQUIRED: ${depsBlock.message}
+Next: ${depsBlock.userAction}`
+      };
+    }
+  }
   if (!reusable) {
     const block = extensionProductConfigBlock(target);
     if (block) {
@@ -105,7 +116,7 @@ Next: ${block.userAction}`
   restoreRequestedPorts();
   if (wantWatch) {
     const startWatchSh = path.join(runnerDir, "adapters/extension/start-watch.sh");
-    const watchArgs = ["--target", target];
+    const watchArgs = ["--target", target, "--runner-bin", path.join(runnerDir, "bin/mm-harness")];
     if (process.env.WATCHER_PORT) watchArgs.push("--watcher-port", process.env.WATCHER_PORT);
     console.error(colorHumanMessage(`\u2192 extension watch \u2014 webpack :${process.env.WATCHER_PORT ?? "default"} (output streams below)`));
     return spawnScriptStreaming(startWatchSh, watchArgs, target);

package/dist/commands/parse-args.js

@@ -28,6 +28,7 @@ function parseArgs(argv, command) {
     "preserveProfile",
     "record",
     "plan",
+    "proof",
     "list",
     "describe",
     "raw",

package/dist/commands/prepare.js

@@ -7,7 +7,7 @@ import {
 import { color, stripAnsi } from "../cli-color.js";
 import { runnerProvenance } from "../doctor.js";
 import { detectAdapter } from "../harness.js";
-import { harnessExecutable, manifestPath, recipeRuntimeDir } from "../paths.js";
+import { harnessExecutable, manifestPath, PREPARE_PROGRESS_ARTIFACT, recipeRuntimeDir } from "../paths.js";
 import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
 import { EXIT } from "./shared.js";
 import { formatDuration } from "./status-watch.js";
@@ -336,13 +336,32 @@ async function handlePrepare(argv) {
   const remoteFlagArgs = remoteFlag === void 0 ? [] : ["--remote-flag", remoteFlag];
   let mobilePlatform = mobilePlatformOption(optionString(options, "mobilePlatform"));
   const recordPath = path.join(artifactsDir, READINESS_RECORD);
+  const progressPath = path.join(artifactsDir, PREPARE_PROGRESS_ARTIFACT);
   const chain = stepChain(platform);
   const view = json ? void 0 : createStepView(chain, stepHints(chain, lastRunDurations(recordPath)));
   view?.begin();
   const steps = [];
+  let activeStep;
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const writeProgress = () => {
+    fs.mkdirSync(path.dirname(progressPath), { recursive: true });
+    const temporaryPath = `${progressPath}.${process.pid}.tmp`;
+    fs.writeFileSync(temporaryPath, `${JSON.stringify({
+      schemaVersion: 1,
+      startedAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      total: chain.length,
+      steps: steps.filter(({ id }) => chain.includes(id)).map(({ id, status, durationMs }) => ({ id, status, durationMs })),
+      ...activeStep ? { active: activeStep } : {}
+    })}
+`);
+    fs.renameSync(temporaryPath, progressPath);
+  };
   const failed = () => steps.some((step) => step.status === "fail");
   const addStep = (step) => {
     steps.push(step);
+    activeStep = void 0;
+    writeProgress();
     view?.finish(step);
     return step;
   };
@@ -352,10 +371,17 @@ async function handlePrepare(argv) {
     }
     const step = await runStep(executable, target, artifactsDir, id, args, {
       json,
-      onSpawn: (startedAt) => view?.start(id, startedAt)
+      onSpawn: (stepStartedAt) => {
+        activeStep = { id, startedAt: new Date(stepStartedAt).toISOString() };
+        writeProgress();
+        view?.start(id, stepStartedAt);
+      }
     });
     return addStep(step);
   };
+  const heartbeat = setInterval(() => {
+    if (activeStep) writeProgress();
+  }, 1e4);
   try {
     await run("doctor", ["doctor", "--fix", "--json", "--adapter", platform, ...targetArgs]);
     await run("status", ["status", "--json", ...targetArgs]);
@@ -384,6 +410,7 @@ async function handlePrepare(argv) {
     }
     await run("verify", ["verify", "--json", "--adapter", platform, ...targetArgs]);
   } finally {
+    clearInterval(heartbeat);
     view?.end();
   }
   const provenance = runnerProvenance(manifestPath(platform));
@@ -404,6 +431,7 @@ async function handlePrepare(argv) {
   fs.mkdirSync(artifactsDir, { recursive: true });
   fs.writeFileSync(recordPath, `${JSON.stringify(record, null, 2)}
 `);
+  fs.rmSync(progressPath, { force: true });
   if (json) {
     console.log(JSON.stringify(record, null, 2));
   } else {

package/dist/commands/run-engine.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { mkdtemp } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { validateRuntimeProofPlan } from "../runtime-proof.js";
 import {
   ensureOverlay,
   newHealState,
@@ -46,6 +47,7 @@ import { EXIT } from "./shared.js";
 import {
   actionManifestPathOption,
   optionString,
+  optionFlag,
   optionStrings,
   isRecord,
   shellQuoteArg,
@@ -563,7 +565,7 @@ function restoreEnv(key, value) {
   if (value === void 0) delete process.env[key];
   else process.env[key] = value;
 }
-async function validateRecipeAdapterAware(adapter, recipe, manifest, librarySources, rootRef, params) {
+async function validateRecipeAdapterAware(adapter, recipe, manifest, librarySources, rootRef, params, proof = false) {
   const protocol = await importRecipeProtocol();
   let externalRecipeIds;
   let libraryResolution;
@@ -641,6 +643,12 @@ async function validateRecipeAdapterAware(adapter, recipe, manifest, librarySour
         }
       };
       validateDependencyInstances(recipe, params ?? {});
+      if (proof && !findings.some((finding) => finding.severity === "error")) {
+        findings.push(...validateRuntimeProofPlan(
+          recipe,
+          new Map([...dependencies.recipes].map(([ref, dependency]) => [ref, dependency.document]))
+        ));
+      }
     } catch (error) {
       const resolutionError = error instanceof harness.RecipeResolutionError ? error : void 0;
       if (!resolutionError) throw error;
@@ -919,7 +927,8 @@ async function validateRunRecipeStatic(recipeArg, adapter, options, params = {})
     manifest,
     librarySources,
     resolved.ref,
-    effectiveParams
+    effectiveParams,
+    optionFlag(options, "proof")
   ) : {
     status: "invalid",
     findings: [],

package/dist/commands/run.js

@@ -613,6 +613,12 @@ async function handleRunPlan(recipeArg, params, options, stream) {
       status: manifestOk && schemaValid ? "ok" : "error",
       detail: "recipe document schema + action existence/platform vs the adapter manifest"
     },
+    ...optionFlag(options, "proof") ? [{
+      step: "validate.proofBindings",
+      confidence: "static",
+      status: findings.some((finding) => finding.code.startsWith("proof.")) ? "error" : errorCount ? "planned" : "ok",
+      detail: "checks possible behavioral assertion bindings only; runtime order, branches, results and proof artifact indexing remain unverified"
+    }] : [],
     {
       step: "fixture.file",
       confidence: "static",

package/dist/commands/runtime-launch.js

@@ -10,6 +10,8 @@ import {
   writeMobileReleaseArtifactState
 } from "../adapters/mobile/release-artifact-state.js";
 import { recipeHarnessPath } from "../paths.js";
+import { extensionDepsBlock } from "./launch/extension.js";
+import { isExtensionDistStale } from "../adapters/extension/runtime-decision.js";
 import {
   adapterOption,
   isRecord,
@@ -152,6 +154,23 @@ async function handleRuntimeLaunch({ options }) {
     printRuntimeLaunchReport(report2, optionFlag(options, "json"));
     return 1;
   }
+  if (!artifact) {
+    const depsBlock = extensionDepsBlock(target);
+    const staleDist = mode === "existing-dist" && isExtensionDistStale(target);
+    if (depsBlock || staleDist) {
+      const report2 = runtimeLaunchReport("fail", {
+        adapter,
+        target,
+        cdpPort,
+        artifactsDir,
+        reason: depsBlock ? "extension_dependencies_required" : "extension_dist_stale",
+        fix: depsBlock?.userAction ?? `mm-harness launch --adapter extension --target ${shellQuote(target)}`,
+        command
+      });
+      printRuntimeLaunchReport(report2, optionFlag(options, "json"));
+      return 1;
+    }
+  }
   fs.mkdirSync(artifactsDir, { recursive: true });
   const jsonMode = optionFlag(options, "json");
   if (!jsonMode) {

package/dist/commands/status-watch.js

@@ -103,9 +103,13 @@ function renderTaskView(view, title, explicitTask = false) {
   const contextLine = joinParts([
     view.libraries.length > 0 && `libraries ${out("info", view.libraries.map(libraryLabel).join(" "))}`,
     showTask && view.fixture && `fixture ${out("info", path.basename(view.fixture.fixture ?? "unknown"))} ${statusWord(out, view.fixture.status)}${view.fixture.walletReset ? out("warn", " reset") : ""}`,
-    showTask && view.sandbox?.ready !== void 0 && `sandbox ${view.sandbox.ready ? out("ok", "ready") : out("warn", "not ready")}`
+    showTask && (view.prepare ? `sandbox ${out("info", "preparing")}` : view.sandbox?.ready !== void 0 && `sandbox ${view.sandbox.ready ? out("ok", "ready") : out("warn", "not ready")}`)
   ]);
   if (contextLine) lines.push(contextLine);
+  if (showTask && view.acceptance?.length) lines.push("", ...renderAcceptanceLines(view));
+  if (showTask && view.prepare) {
+    lines.push(`prepare ${out("info", view.prepare.step)} \xB7 ${view.prepare.completed}/${view.prepare.total} steps \xB7 ${formatDuration(view.prepare.elapsedMs)} elapsed`);
+  }
   const last = view.lastCommand;
   if (showTask && last) {
     lines.push(joinParts([
@@ -148,6 +152,19 @@ function renderTaskView(view, title, explicitTask = false) {
   }
   return lines;
 }
+function renderAcceptanceLines(view) {
+  if (!view.acceptance?.length) return [];
+  const out = (style, text) => color(style, text, { stream: process.stdout });
+  const proven = view.acceptance.filter((row) => row.status?.verdict === "proven").length;
+  return [
+    `acceptance criteria ${proven}/${view.acceptance.length} proven`,
+    ...view.acceptance.map((row) => {
+      const verdict = row.status?.verdict ?? "no verdict";
+      const style = verdict === "proven" ? "ok" : verdict === "weak" ? "warn" : verdict === "no verdict" ? "dim" : "err";
+      return `  ${row.id} [${out(style, verdict)}] ${row.text}`;
+    })
+  ];
+}
 function idleReason(view) {
   if (!view.taskDir) return "no task directory under temp/tasks";
   const { reason, idleMs, branchCarriesTicket } = view.activity;
@@ -161,15 +178,33 @@ function idleReason(view) {
 }
 function changedLines(previous, next) {
   if (!previous || previous.taskDir !== next.taskDir) {
-    return [joinParts([
-      path.basename(next.checkout.target),
-      next.taskDir ? path.basename(next.taskDir) : "no-task-dir",
-      `status=${next.signal?.status ?? "unknown"}`,
-      `step=${next.signal?.step ? stepLabel(next.signal.step) : "none"}`
-    ], " ")];
+    return [
+      joinParts([
+        path.basename(next.checkout.target),
+        next.taskDir ? path.basename(next.taskDir) : "no-task-dir",
+        `status=${next.signal?.status ?? "unknown"}`,
+        `step=${next.signal?.step ? stepLabel(next.signal.step) : "none"}`
+      ], " "),
+      ...(next.acceptance ?? []).map((row) => `${row.id} ${row.status?.verdict ?? "no verdict"} ${row.text}`),
+      ...next.prepare ? [`prepare ${next.prepare.step} started (${next.prepare.completed}/${next.prepare.total} steps)`] : []
+    ];
   }
   const lines = [];
+  for (const step of next.prepare?.steps ?? []) {
+    if (!previous.prepare?.steps.some((prior) => prior.id === step.id && prior.status === step.status)) {
+      lines.push(`prepare ${step.id} ${step.status} (${formatDuration(step.durationMs)})`);
+    }
+  }
+  if (next.prepare && (previous.prepare?.step !== next.prepare.step || previous.prepare.startedAt !== next.prepare.startedAt)) {
+    lines.push(`prepare ${next.prepare.step} started (${next.prepare.completed}/${next.prepare.total} steps)`);
+  }
   const before = new Map(previous.checklist.map((row) => [row.number, row.checked]));
+  const beforeAcceptance = new Map(previous.acceptance?.map((row) => [row.id, row.status?.verdict]));
+  for (const row of next.acceptance ?? []) {
+    if (beforeAcceptance.get(row.id) !== row.status?.verdict || !beforeAcceptance.has(row.id)) {
+      lines.push(`${row.id} ${row.status?.verdict ?? "no verdict"} ${row.text}`);
+    }
+  }
   for (const row of next.checklist) {
     if (!row.checked || before.get(row.number) === true) continue;
     lines.push(`checked ${row.number} ${row.label}${row.durationMs !== void 0 ? ` (${formatDuration(row.durationMs)})` : ""}`);
@@ -254,6 +289,7 @@ export {
   changedLines,
   formatDuration,
   handleStatusTaskView,
+  renderAcceptanceLines,
   renderTaskView,
   runStatusWatch
 };

package/dist/commands/status.js

@@ -20,7 +20,8 @@ import {
   renderMobileLiveBlock
 } from "./mobile-device-view.js";
 import { ADAPTER_DETECT_NEXT, EXIT, usageOut } from "./shared.js";
-import { handleStatusTaskView } from "./status-watch.js";
+import { handleStatusTaskView, renderAcceptanceLines } from "./status-watch.js";
+import { collectTaskView, findTaskDir } from "../task-view.js";
 import { optionFlag, optionString, targetPath } from "./parse-args.js";
 async function handleStatus({ options }) {
   const target = targetPath(options);
@@ -106,6 +107,12 @@ async function handleStatus({ options }) {
   const out = (style, text) => color(style, text, { stream: process.stdout });
   console.log(`${out("label", "status")} ${out("bold", adapter)} ${out("dim", target)}`);
   console.log(renderCheckoutView(view));
+  if (!fast) {
+    const taskView = collectTaskView(target, findTaskDir(target), Date.now());
+    if (taskView.activity.ongoing && taskView.acceptance?.length) {
+      console.log(renderAcceptanceLines(taskView).join("\n"));
+    }
+  }
   if (adapter !== "mobile") renderFeatureFlagLine(staticFeatureFlags, out);
   if (deviceView) renderMobileDeviceList(deviceView, out);
   if (!fast && adapter === "mobile" && deviceView !== null && deviceView.allConnectedDevices.length > 0) {

package/dist/devices.js

@@ -1,9 +1,11 @@
 import { execFileSync } from "node:child_process";
 import { resolveMobileToolPath } from "../library/actions/mobile/platform/tool-paths.mjs";
+const IOS_DEVICE_DISCOVERY_TIMEOUT_MS = 3e4;
 function reportProbeFailure(errors, platform, error) {
   const code = error?.code;
   if (code === "ENOENT") return;
-  const reason = code === "ETIMEDOUT" ? "timed out after 5 seconds" : "failed";
+  const timeoutSeconds = platform === "ios" ? IOS_DEVICE_DISCOVERY_TIMEOUT_MS / 1e3 : 5;
+  const reason = code === "ETIMEDOUT" ? `timed out after ${timeoutSeconds} seconds` : "failed";
   const probeCode = code ?? error?.status;
   errors.push({
     platform,
@@ -61,7 +63,7 @@ function listIosSimulators(scope, errors) {
   try {
     output = execFileSync("xcrun", ["simctl", "list", "devices", scope, "-j"], {
       encoding: "utf8",
-      timeout: 5e3,
+      timeout: IOS_DEVICE_DISCOVERY_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"]
     });
   } catch (error) {

package/dist/mm-harness-cli.js

@@ -192,8 +192,10 @@ Example:
   The task view reads task files only \u2014 no probe, no launch, no write \u2014 and shows
   the same facts whether a skill or a control plane started the run: slot and
   device isolation, template and flow, fixture and sandbox readiness, then the
-  checklist with the time each row took and how long the current row has been
-  running. --task without --watch prints it once. With --json, --watch emits one
+  checklist with the time each row took, how long the current row has been
+  running, and acceptance criteria with recorded verdicts. The home dashboard
+  also shows criteria for an ongoing task. --task without --watch prints it once.
+  With --json, --watch emits one
   object per change (newline-delimited) instead of redrawing.
 
   The checkout view (also under "view" in --json, and printed by doctor) is what
@@ -462,6 +464,7 @@ Discovery:
   --list                             List complete recipes accepted by run for this adapter; no <recipe> needed
   --describe                         Show one recipe's parameters, composed actions/recipes, and runnable command
   --plan                             Validate + print execution plan, touching nothing. Exit 5 if invalid.
+  --proof                            Preflight behavioral proof bindings before planning/execution; runtime evidence is still required.
 
 Common overrides:
   --device <udid|serial|name>        Mobile only: target this device (sets IOS_SIMULATOR / ADB_SERIAL and updates agentic-runtime.json). Without it, >1 connected mobile device fails fast and lists them. Do not shut down other devices to force selection.

package/dist/paths.js

@@ -5,6 +5,7 @@ const runnerDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..
 const pathDefaults = readPathDefaults();
 const DEFAULT_RECIPE_RUNTIME_DIR = pathDefaults.recipeRuntimeDir;
 const DEFAULT_RECIPE_HARNESS_ROOT = pathDefaults.recipeHarnessRoot;
+const PREPARE_PROGRESS_ARTIFACT = "prepare/progress.json";
 function recipeRuntimeDir() {
   return validateRelativeRecipePath("RECIPE_RUNTIME_DIR", process.env.RECIPE_RUNTIME_DIR || DEFAULT_RECIPE_RUNTIME_DIR);
 }
@@ -171,6 +172,7 @@ function isMissingPackageError(error, packageName) {
 export {
   DEFAULT_RECIPE_HARNESS_ROOT,
   DEFAULT_RECIPE_RUNTIME_DIR,
+  PREPARE_PROGRESS_ARTIFACT,
   assertAdapter,
   extensionIdPath,
   harnessExecutable,

package/dist/runtime-proof.js

@@ -9,23 +9,8 @@ function validateRuntimeProof(bundle, smokeTarget) {
   assert(entries.length && entries.every((entry) => entry.ok === true), "Runtime trace contains failed or unknown actions");
   assert(entries.some((entry) => entry.action === "end" && entry.status === "pass" && !String(entry.nodeId ?? entry.id).includes("/")), "Runtime recipe did not reach its passing end");
   const documents = new Map(recipeResolution.dependencies.map((dependency) => [normalizeRecipeRef(dependency.ref), resolvedRecipes[dependency.digest]]));
-  const nodes = /* @__PURE__ */ new Map();
-  function collect(document, prefix = "", stack = /* @__PURE__ */ new Set()) {
-    for (const [id, node] of Object.entries(document.workflow.nodes)) {
-      nodes.set(prefix + id, node);
-      if (node.action === "call" && typeof node.ref === "string") {
-        const ref = normalizeRecipeRef(node.ref);
-        assert(!stack.has(ref), "Recursive recipe proof");
-        const nested = documents.get(ref);
-        assert(nested, `Missing resolved recipe ${ref}`);
-        collect(nested, `${prefix}${id}/`, new Set(stack).add(ref));
-      }
-    }
-  }
-  collect(recipe);
+  const nodes = collectProofNodes(recipe, documents);
   const executed = new Map(entries.map((entry, index) => [entry.nodeId ?? entry.id, { entry, index }]));
-  const assertions = /* @__PURE__ */ new Set(["assert_output", "assert_json", "ui.wait_for"]);
-  const controls = /* @__PURE__ */ new Set(["end", "wait", "manual", "switch", "call", "index_artifacts", "assert_exit_code", "assert_file", "branch", "repeat", "set", "log"]);
   function proves(id) {
     const node = nodes.get(id);
     const current = executed.get(id);
@@ -33,13 +18,12 @@ function validateRuntimeProof(bundle, smokeTarget) {
     if (node.action === "call") return [...nodes.keys()].some((child) => child.startsWith(`${id}/`) && proves(child));
     if (!assertions.has(node.action) || !current.entry.output || typeof current.entry.output !== "object") return false;
     if (node.action === "assert_output") {
-      const prefix = id.includes("/") ? id.slice(0, id.lastIndexOf("/") + 1) : "";
-      const source = prefix + String(node.source ?? node.node ?? "");
+      const source = assertionSource(id, node);
       const prior = executed.get(source);
       const action = nodes.get(source)?.action;
-      return Boolean(prior && prior.index < current.index && action && action === prior.entry.action && !controls.has(action) && !assertions.has(action));
+      return Boolean(prior && prior.index < current.index && action && action === prior.entry.action && isObservation(action));
     }
-    if (node.action === "ui.wait_for") return entries.slice(0, current.index).some((entry) => ["ui.press", "ui.key_press", "ui.set_input", "ui.swipe", "ui.drag", "ui.long_press"].includes(entry.action));
+    if (node.action === "ui.wait_for") return entries.slice(0, current.index).some((entry) => inputs.has(entry.action));
     return typeof node.path === "string" && manifest.artifacts.some((artifact) => artifact.path === node.path && artifact.category === "proof");
   }
   assert(recipe.proofTargets?.length, "Runtime recipe has no behavioral proof targets");
@@ -49,6 +33,58 @@ function validateRuntimeProof(bundle, smokeTarget) {
   }
   if (smokeTarget) assert(recipe.proofTargets.some((target) => target.id === smokeTarget), "Smoke target is absent from recipe");
 }
+const assertions = /* @__PURE__ */ new Set(["assert_output", "assert_json", "ui.wait_for"]);
+const controls = /* @__PURE__ */ new Set(["end", "wait", "manual", "switch", "call", "index_artifacts", "assert_exit_code", "assert_file", "branch", "repeat", "set", "log"]);
+const inputs = /* @__PURE__ */ new Set(["ui.press", "ui.key_press", "ui.set_input", "ui.swipe", "ui.drag", "ui.long_press"]);
+function isObservation(action) {
+  return !controls.has(action) && !assertions.has(action);
+}
+function assertionSource(id, node) {
+  const prefix = id.includes("/") ? id.slice(0, id.lastIndexOf("/") + 1) : "";
+  return prefix + String(node.source ?? node.node ?? "");
+}
+function collectProofNodes(recipe, documents) {
+  const nodes = /* @__PURE__ */ new Map();
+  function collect(document, prefix = "", stack = /* @__PURE__ */ new Set()) {
+    for (const [id, node] of Object.entries(document.workflow.nodes)) {
+      nodes.set(prefix + id, node);
+      if (node.action === "call" && typeof node.ref === "string") {
+        const ref = normalizeRecipeRef(node.ref);
+        assert(!stack.has(ref), "Recursive recipe proof");
+        const nested = documents.get(ref);
+        assert(nested, `Missing resolved recipe ${ref}`);
+        collect(nested, `${prefix}${id}/`, new Set(stack).add(ref));
+      }
+    }
+  }
+  collect(recipe);
+  return nodes;
+}
+function validateRuntimeProofPlan(recipe, documents = /* @__PURE__ */ new Map()) {
+  const finding = (code, path, message) => ({ severity: "error", code, path, message });
+  if (!recipe.proofTargets?.length) return [finding("proof.targets_missing", "proofTargets", "Behavioral proof requires at least one proof target.")];
+  const nodes = collectProofNodes(recipe, documents);
+  const hasInput = [...nodes.values()].some((node) => inputs.has(node.action));
+  function eligible(id) {
+    const node = nodes.get(id);
+    if (node.action === "call") return [...nodes.keys()].some((child) => child.startsWith(`${id}/`) && eligible(child));
+    if (node.action === "assert_output") {
+      const source = nodes.get(assertionSource(id, node));
+      return Boolean(source && isObservation(source.action));
+    }
+    if (node.action === "ui.wait_for") return hasInput;
+    return node.action === "assert_json" && typeof node.path === "string";
+  }
+  return recipe.proofTargets.flatMap((target, index) => {
+    const linked = [...nodes].filter(([, node]) => node.proves?.includes(target.id));
+    return linked.some(([id]) => eligible(id)) ? [] : [finding(
+      "proof.no_runtime_assertion",
+      `proofTargets[${index}]`,
+      `Proof target ${target.id} has no potentially eligible runtime assertion. Bind proves to assert_output over an observation, ui.wait_for with an input action, assert_json over a proof artifact, or a call containing one. Runtime order, outcomes and artifact indexing remain unverified.`
+    )];
+  });
+}
 export {
-  validateRuntimeProof
+  validateRuntimeProof,
+  validateRuntimeProofPlan
 };

package/dist/task-view.js

@@ -2,6 +2,12 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { HANDOFF_INPUT, latestTaskDir } from "@farmslot/agent-runtime";
+import {
+  ACCEPTANCE_STATUS_ARTIFACT,
+  acceptanceCriteriaView,
+  acceptanceCriterionId,
+  validateAcceptanceStatusLedger
+} from "@farmslot/protocol/contracts/acceptance";
 import {
   checklistStepName,
   deriveChecklistStepDurations,
@@ -17,7 +23,7 @@ import {
 } from "@farmslot/protocol";
 import { readCommandJournal } from "./command-journal.js";
 import { resolveRuntimeContextPath } from "./harness.js";
-import { recipeRuntimeDir } from "./paths.js";
+import { PREPARE_PROGRESS_ARTIFACT, recipeRuntimeDir } from "./paths.js";
 import { parseLibraryPathEnv } from "./review/knowledge.js";
 const CHECKLIST_LABEL_LIMIT = 70;
 const TASK_SILENT_AFTER_MS = 10 * 60 * 1e3;
@@ -42,8 +48,22 @@ function collectTaskView(target, taskDir, now) {
   const checklist = readChecklistRows(path.join(taskDir, INTERACTIVE_CHECKLIST_MARKDOWN));
   const template = asObject(handoff?.executionTemplate);
   const task = asObject(handoff?.task);
+  const rawCriteria = task?.acceptanceCriteria;
+  if (rawCriteria !== void 0 && !Array.isArray(rawCriteria)) {
+    throw new Error(`${path.join(taskDir, HANDOFF_INPUT)}: task.acceptanceCriteria must be an array.`);
+  }
+  const criteria = rawCriteria?.map((text, index) => ({
+    id: acceptanceCriterionId(index),
+    text: String(text)
+  })).filter((criterion) => criterion.text.trim().length > 0) ?? [];
+  const rawLedger = readJsonObject(path.join(taskDir, ACCEPTANCE_STATUS_ARTIFACT));
+  if (rawLedger) {
+    const issues = validateAcceptanceStatusLedger(rawLedger);
+    if (issues.length > 0) throw new Error(`${ACCEPTANCE_STATUS_ARTIFACT}: ${issues.join("; ")}`);
+  }
   const startedAtIso = pickString(handoff, "startedAt");
   const startedAt = parseTime(startedAtIso);
+  const prepare = readPrepareProgress(taskDir, now, startedAt, parseTime(pickString(sandbox, "recordedAt")));
   const timing = applyTiming(checklist, signal, startedAtIso, now);
   const ticket = pickString(task, "ticket");
   const journal = readLastCommand(target, now);
@@ -56,7 +76,8 @@ function collectTaskView(target, taskDir, now) {
       startedAt,
       parseTime(pickString(signal, "timestamp")),
       ...readMarkEvents(signal).map((event) => Date.parse(event.checkedAt)),
-      commandCounts ? commandAt : void 0
+      commandCounts ? commandAt : void 0,
+      prepare ? parseTime(prepare.updatedAt) : void 0
     ],
     branch: base.checkout.branch,
     ticket,
@@ -79,6 +100,7 @@ function collectTaskView(target, taskDir, now) {
       title: pickString(task, "title"),
       ticket
     }),
+    ...criteria.length > 0 || rawLedger ? { acceptance: acceptanceCriteriaView(criteria, rawLedger ? rawLedger : null) } : {},
     fixture: section({
       fixture: pickString(fixtures, "fixture"),
       canonicalFixture: pickString(fixtures, "canonicalFixture"),
@@ -86,6 +108,7 @@ function collectTaskView(target, taskDir, now) {
       walletReset: pickBoolean(fixtures, "walletReset")
     }),
     sandbox: section({ ready: pickBoolean(sandbox, "ready") }),
+    ...prepare ? { prepare } : {},
     checklist,
     subtasks: readSubtasks(taskDir),
     signal: section({
@@ -99,6 +122,26 @@ function collectTaskView(target, taskDir, now) {
     activity
   };
 }
+function readPrepareProgress(taskDir, now, taskStartedAt, recordedAt) {
+  const progress = readJsonObject(path.join(taskDir, "artifacts", PREPARE_PROGRESS_ARTIFACT));
+  const active = asObject(progress?.active);
+  const step = pickString(active, "id");
+  const startedAt = pickString(active, "startedAt");
+  const stepStartedAt = parseTime(startedAt);
+  const runStartedAt = parseTime(pickString(progress, "startedAt"));
+  const updatedAtIso = pickString(progress, "updatedAt");
+  const updatedAt = parseTime(updatedAtIso);
+  const total = pickNumber(progress, "total");
+  if (!step || !["doctor", "status", "launch", "fixtures", "verify"].includes(step) || stepStartedAt === void 0 || runStartedAt === void 0 || updatedAt === void 0 || now - updatedAt > 3e4 || total === void 0 || total < 1 || taskStartedAt !== void 0 && runStartedAt < taskStartedAt || recordedAt !== void 0 && recordedAt >= runStartedAt) return void 0;
+  const steps = Array.isArray(progress?.steps) ? progress.steps.flatMap((value) => {
+    const item = asObject(value);
+    const id = pickString(item, "id");
+    const status = pickString(item, "status");
+    const durationMs = pickNumber(item, "durationMs");
+    return id && ["doctor", "status", "launch", "fixtures", "verify"].includes(id) && status && ["pass", "fail", "skipped"].includes(status) && durationMs !== void 0 ? [{ id, status, durationMs }] : [];
+  }) : [];
+  return { step, startedAt, updatedAt: updatedAtIso, elapsedMs: Math.max(0, now - stepStartedAt), completed: steps.length, total, steps };
+}
 function readLastCommand(target, now) {
   const { record } = readCommandJournal(target);
   if (!record) return void 0;

package/docs/RELEASE-QA-CAPABILITY-MAP.md

@@ -118,6 +118,24 @@ current manifests do not expose the required durable capability.
 | Bridge tracking and details | Completed supported bridge route | Read-only Swap/Bridge evidence exists, but Extension cannot create the terminal bridge transaction | **MISSING** for a complete Extension bridge journey |
 | Android multi-network visibility | Imported wallet with holdings on multiple chains | Native Assets read reports aggregate visible holdings without Metro or a development bridge | **AVAILABLE** |
 
+## Pending approval observation
+
+On source-dev Extension runtimes, `metamask.wallet.read_state` with
+`scope: "pending_approvals"` reads `stateHooks.store.getState()` once. It returns
+only `state.pendingApprovals`, an ID-sorted array of `{ id, type }`, and
+`state.pendingApprovalCount`. It neither approves nor rejects requests and does
+not navigate, reload, or call the background controller. Missing or malformed
+approval state fails the read instead of reporting an empty queue.
+
+Capture the IDs before entering a confirmation flow and again after its explicit
+UI teardown. Check that newly created IDs are gone and pre-existing IDs remain.
+A count alone or Back navigation does not prove cleanup. This observes pending
+approvals only, not transaction settlement or other controller queues.
+
+This scope requires the development store hook. It is unsupported on official
+Extension artifacts without that hook and on Mobile. Do not patch a release or
+mutate controller state to make the read available.
+
 ## Platform scope
 
 The 135-case source inventory targets Extension. It must not be relabeled as an

package/library/actions/extension/wallet/read_state.mjs

@@ -1,8 +1,16 @@
-// Reads wallet identity, onboarding, and network state from state hooks alongside the password-input marker.
+// Reads wallet state or pending approval identities without changing requests.
 import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
 import { readWalletStateExpression } from './state.mjs';
 
 runAdapter((input) => withExtensionPage(input, async (page) => {
-  const state = await page.evaluate(readWalletStateExpression(), { awaitPromise: true });
-  return { action: input.action, source: 'extension-stateHooks-clean-state', state, redacted: true, proofPath: 'extension-wallet-state' };
+  const scope = input.node?.scope ?? 'wallet';
+  const state = await page.evaluate(readWalletStateExpression(scope), { awaitPromise: true });
+  return {
+    action: input.action,
+    source: scope === 'pending_approvals' ? 'extension-stateHooks-store' : 'extension-stateHooks-clean-state',
+    scope,
+    state,
+    redacted: true,
+    proofPath: 'extension-wallet-state',
+  };
 }));

package/library/actions/extension/wallet/state.mjs

@@ -22,7 +22,31 @@ const walletStatePreamble = `
     };
 `;
 
-export function readWalletStateExpression() {
+export function readWalletStateExpression(scope = 'wallet') {
+  if (scope === 'pending_approvals') {
+    return `(() => {
+      const hooks = globalThis.stateHooks;
+      if (typeof hooks?.store?.getState !== 'function') {
+        throw new Error('Pending approval reads require source-dev stateHooks.store.getState; official artifacts are unsupported.');
+      }
+      const root = hooks.store.getState();
+      const pending = (root?.metamask || root)?.pendingApprovals;
+      if (!pending || typeof pending !== 'object' || Array.isArray(pending)) {
+        throw new Error('Pending approval state is unavailable; an empty queue cannot be inferred.');
+      }
+      const pendingApprovals = Object.entries(pending).map(([id, approval]) => {
+        if (!id || !approval || approval.id !== id ||
+            typeof approval.type !== 'string' || !approval.type) {
+          throw new Error('Pending approval state contains an invalid request identity or type.');
+        }
+        return { id, type: approval.type };
+      }).sort((left, right) => left.id.localeCompare(right.id));
+      return { pendingApprovals, pendingApprovalCount: pendingApprovals.length };
+    })()`;
+  }
+  if (scope !== 'wallet') {
+    throw new Error('metamask.wallet.read_state scope must be wallet or pending_approvals.');
+  }
   return `(async () => {
     ${walletStatePreamble}
     const { metamask, internal } = await readWalletState();

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

@@ -1753,10 +1753,16 @@
       "execution_capabilities": []
     },
     "metamask.wallet.read_state": {
-      "description": "Read the redacted wallet state (selected account, route, and device) from the running app.",
+      "description": "Read redacted wallet state, or pending approval IDs/types/count from the source-dev store without modifying requests. Pending approvals are unsupported on official artifacts without the dev store.",
       "schema": {
         "type": "object",
-        "properties": {},
+        "properties": {
+          "scope": {
+            "type": "string",
+            "enum": ["wallet", "pending_approvals"],
+            "default": "wallet"
+          }
+        },
         "additionalProperties": false
       },
       "examples": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.62.0",
+  "version": "0.64.0",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"