@deeeed/metamask-harness 0.63.0 → 0.64.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## 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

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/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/mm-harness-cli.js

@@ -464,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/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/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.63.0",
+  "version": "0.64.0",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"